keejef
/
session-desktop
mirror of https://github.com/oxen-io/session-desktop
2
0
Fork 0
Code Issues 8 Projects Releases Wiki Activity

Updated messenger to work with slightly different storage server API and changed swarm requests to go through storage server

Browse Source
pull/258/head
Beaudan 6 years ago
parent 9a52319da3
commit 531ee92dcb
7 changed files with 140 additions and 177 deletions
Show Stats Download Patch File Download Diff File

3
config/default.json
Unescape Escape View File

@ -3,8 +3,7 @@
"localUrl": "localhost.loki", "localUrl": "localhost.loki",
"cdnUrl": "random.snode", "cdnUrl": "random.snode",
"localServerPort": "8081", "localServerPort": "8081",
"messageServerPort": "8080", "snodeServerPort": "8080",
"swarmServerPort": "8079",
"disableAutoUpdate": false, "disableAutoUpdate": false,
"openDevTools": false, "openDevTools": false,
"buildExpiration": 0, "buildExpiration": 0,

93
js/modules/loki_fetch.js
Unescape Escape View File

@ -0,0 +1,93 @@
/* global log, libloki, textsecure */
const nodeFetch = require('node-fetch');
const { parse } = require('url');
const LOKI_EPHEMKEY_HEADER = 'X-Loki-EphemKey';
const endpointBase = '/v1/storage_rpc';
// A small wrapper around node-fetch which deserializes response
const fetch = async (url, options = {}) => {
const timeout = options.timeout || 10000;
const method = options.method || 'GET';
const address = parse(url).hostname;
const doEncryptChannel = address.endsWith('.snode');
if (doEncryptChannel) {
try {
// eslint-disable-next-line no-param-reassign
options.body = await libloki.crypto.snodeCipher.encrypt(
address,
options.body
);
// eslint-disable-next-line no-param-reassign
options.headers = {
...options.headers,
'Content-Type': 'text/plain',
[LOKI_EPHEMKEY_HEADER]: libloki.crypto.snodeCipher.getChannelPublicKeyHex(),
};
} catch (e) {
log.warn(`Could not encrypt channel for ${address}: `, e);
}
}
try {
const response = await nodeFetch(url, {
...options,
timeout,
method,
});
if (!response.ok) {
throw new textsecure.HTTPError(response);
}
let result;
if (response.headers.get('Content-Type') === 'application/json') {
result = await response.json();
} else if (options.responseType === 'arraybuffer') {
result = await response.buffer();
} else {
result = await response.text();
if (doEncryptChannel) {
try {
result = await libloki.crypto.snodeCipher.decrypt(address, result);
} catch (e) {
log.warn(`Could not decrypt response from ${address}`, e);
}
try {
result = result === '' ? {} : JSON.parse(result);
} catch (e) {
log.warn(`Could not parse string to json ${result}`, e);
}
}
}
return result;
} catch (e) {
throw e;
}
};
// Wrapper for a JSON RPC request
const rpc = (address, port, method, params, options = {}) => {
const headers = options.headers || {};
const url = `${address}${port}${endpointBase}`;
const body = {
method,
params,
};
const fetchOptions = {
method: 'POST',
...options,
body: JSON.stringify(body),
headers,
};
return fetch(url, fetchOptions);
};
module.exports = {
rpc,
};

127
js/modules/loki_message_api.js
Unescape Escape View File

@ -1,21 +1,9 @@
/* eslint-disable no-await-in-loop */ /* eslint-disable no-await-in-loop */
/* eslint-disable no-loop-func */ /* eslint-disable no-loop-func */
/* global log, dcodeIO, window, callWorker, lokiP2pAPI, lokiSnodeAPI, libloki */ /* global log, dcodeIO, window, callWorker, lokiP2pAPI, lokiSnodeAPI, textsecure */
const nodeFetch = require('node-fetch');
const _ = require('lodash'); const _ = require('lodash');
const { parse } = require('url'); const { rpc } = require('./loki_fetch');
const endpointBase = '/v1/storage_rpc';
const LOKI_EPHEMKEY_HEADER = 'X-Loki-EphemKey';
class HTTPError extends Error {
constructor(response) {
super(response.statusText);
this.name = 'HTTPError';
this.response = response;
}
}
class NotFoundError extends Error { class NotFoundError extends Error {
constructor() { constructor() {
@ -24,98 +12,12 @@ class NotFoundError extends Error {
} }
} }
// A small wrapper around node-fetch which deserializes response
const fetch = async (url, options = {}) => {
const timeout = options.timeout || 10000;
const method = options.method || 'GET';
const address = parse(url).hostname;
const doEncryptChannel = address.endsWith('.snode');
if (doEncryptChannel) {
try {
// eslint-disable-next-line no-param-reassign
options.body = await libloki.crypto.snodeCipher.encrypt(
address,
options.body
);
// eslint-disable-next-line no-param-reassign
options.headers = {
...options.headers,
'Content-Type': 'text/plain',
[LOKI_EPHEMKEY_HEADER]: libloki.crypto.snodeCipher.getChannelPublicKeyHex(),
};
} catch (e) {
log.warn(`Could not encrypt channel for ${address}: `, e);
}
}
try {
const response = await nodeFetch(url, {
...options,
timeout,
method,
});
if (!response.ok) {
throw new HTTPError(response);
}
let result;
if (response.headers.get('Content-Type') === 'application/json') {
result = await response.json();
} else if (options.responseType === 'arraybuffer') {
result = await response.buffer();
} else {
result = await response.text();
if (doEncryptChannel) {
try {
result = await libloki.crypto.snodeCipher.decrypt(address, result);
} catch (e) {
log.warn(`Could not decrypt response from ${address}`, e);
}
try {
result = JSON.parse(result);
} catch (e) {
log.warn(`Could not parse string to json ${result}`, e);
}
}
}
return result;
} catch (e) {
if (e.code === 'ENOTFOUND') {
throw new NotFoundError();
}
throw e;
}
};
// Wrapper for a JSON RPC request
const rpc = (address, port, method, params, options = {}) => {
const headers = options.headers || {};
const url = `${address}${port}${endpointBase}`;
const body = {
method,
params,
};
const fetchOptions = {
method: 'POST',
...options,
body: JSON.stringify(body),
headers,
};
return fetch(url, fetchOptions);
};
// Will be raised (to 3?) when we get more nodes // Will be raised (to 3?) when we get more nodes
const MINIMUM_SUCCESSFUL_REQUESTS = 2; const MINIMUM_SUCCESSFUL_REQUESTS = 2;
class LokiMessageAPI { class LokiMessageAPI {
constructor({ messageServerPort }) { constructor({ snodeServerPort }) {
this.messageServerPort = messageServerPort ? `:${messageServerPort}` : ''; this.snodeServerPort = snodeServerPort ? `:${snodeServerPort}` : '';
} }
async sendMessage(pubKey, data, messageTimeStamp, ttl, isPing = false) { async sendMessage(pubKey, data, messageTimeStamp, ttl, isPing = false) {
@ -195,7 +97,7 @@ class LokiMessageAPI {
}; };
try { try {
await rpc(nodeUrl, this.messageServerPort, 'store', params); await rpc(nodeUrl, this.snodeServerPort, 'store', params);
nodeComplete(nodeUrl); nodeComplete(nodeUrl);
successfulRequests += 1; successfulRequests += 1;
@ -203,7 +105,7 @@ class LokiMessageAPI {
log.warn('Loki send message:', e); log.warn('Loki send message:', e);
if (e instanceof NotFoundError) { if (e instanceof NotFoundError) {
canResolve = false; canResolve = false;
} else if (e instanceof HTTPError) { } else if (e instanceof textsecure.HTTPError) {
// We mark the node as complete as we could still reach it // We mark the node as complete as we could still reach it
nodeComplete(nodeUrl); nodeComplete(nodeUrl);
} else { } else {
@ -248,7 +150,7 @@ class LokiMessageAPI {
await Promise.all( await Promise.all(
swarmNodes swarmNodes
.splice(0, remainingRequests) .splice(0, remainingRequests)
.map(nodeUrl => doRequest(nodeUrl)) .map(nodeUrl => doRequest(`http://${nodeUrl}`))
); );
} }
log.info(`Successful storage message to ${pubKey}`); log.info(`Successful storage message to ${pubKey}`);
@ -270,21 +172,22 @@ class LokiMessageAPI {
const doRequest = async (nodeUrl, nodeData) => { const doRequest = async (nodeUrl, nodeData) => {
const params = { const params = {
pubKey: ourKey, pubKey: ourKey,
lastHash: nodeData.lastHash, lastHash: nodeData.lastHash || '',
}; };
try { try {
const result = await rpc( const result = await rpc(
nodeUrl, nodeUrl,
this.messageServerPort, this.snodeServerPort,
'retrieve', 'retrieve',
params params
); );
nodeComplete(nodeUrl); nodeComplete(nodeUrl);
if (result.lastHash) { if (Array.isArray(result.messages) && result.messages.length) {
lokiSnodeAPI.updateLastHash(nodeUrl, result.lastHash); const lastHash = [...result.messages].pop();
lokiSnodeAPI.updateLastHash(nodeUrl, lastHash);
callback(result.messages); callback(result.messages);
} }
successfulRequests += 1; successfulRequests += 1;
@ -292,7 +195,7 @@ class LokiMessageAPI {
log.warn('Loki retrieve messages:', e); log.warn('Loki retrieve messages:', e);
if (e instanceof NotFoundError) { if (e instanceof NotFoundError) {
canResolve = false; canResolve = false;
} else if (e instanceof HTTPError) { } else if (e instanceof textsecure.HTTPError) {
// We mark the node as complete as we could still reach it // We mark the node as complete as we could still reach it
nodeComplete(nodeUrl); nodeComplete(nodeUrl);
} else { } else {
@ -335,7 +238,9 @@ class LokiMessageAPI {
await Promise.all( await Promise.all(
Object.entries(ourSwarmNodes) Object.entries(ourSwarmNodes)
.splice(0, remainingRequests) .splice(0, remainingRequests)
.map(([nodeUrl, nodeData]) => doRequest(nodeUrl, nodeData)) .map(([nodeUrl, nodeData]) =>
doRequest(`http://${nodeUrl}`, nodeData)
)
); );
} }
} }

72
js/modules/loki_snode_api.js
Unescape Escape View File

@ -1,10 +1,10 @@
/* eslint-disable class-methods-use-this */ /* eslint-disable class-methods-use-this */
/* global window, ConversationController */ /* global window, ConversationController */
const fetch = require('node-fetch');
const is = require('@sindresorhus/is'); const is = require('@sindresorhus/is');
const dns = require('dns'); const dns = require('dns');
const process = require('process'); const process = require('process');
const { rpc } = require('./loki_fetch');
// Will be raised (to 3?) when we get more nodes // Will be raised (to 3?) when we get more nodes
const MINIMUM_SWARM_NODES = 1; const MINIMUM_SWARM_NODES = 1;
@ -33,13 +33,13 @@ const resolveCname = url =>
}); });
class LokiSnodeAPI { class LokiSnodeAPI {
constructor({ serverUrl, localUrl, swarmServerPort }) { constructor({ serverUrl, localUrl, snodeServerPort }) {
if (!is.string(serverUrl)) { if (!is.string(serverUrl)) {
throw new Error('WebAPI.initialize: Invalid server url'); throw new Error('WebAPI.initialize: Invalid server url');
} }
this.serverUrl = serverUrl; this.serverUrl = serverUrl;
this.localUrl = localUrl; this.localUrl = localUrl;
this.swarmServerPort = swarmServerPort ? `:${swarmServerPort}` : ''; this.snodeServerPort = snodeServerPort ? `:${snodeServerPort}` : '';
this.swarmsPendingReplenish = {}; this.swarmsPendingReplenish = {};
this.ourSwarmNodes = {}; this.ourSwarmNodes = {};
this.contactSwarmNodes = {}; this.contactSwarmNodes = {};
@ -183,65 +183,17 @@ class LokiSnodeAPI {
async getSwarmNodes(pubKey) { async getSwarmNodes(pubKey) {
// TODO: Hit multiple random nodes and merge lists? // TODO: Hit multiple random nodes and merge lists?
const node = await this.getRandomSnodeAddress(); const nodeUrl = await this.getRandomSnodeAddress();
// TODO: Confirm final API URL and sensible timeout
const options = {
url: `http://${node}${this.swarmServerPort}/json_rpc`,
type: 'POST',
responseType: 'json',
timeout: 10000,
};
const body = {
jsonrpc: '2.0',
id: '0',
method: 'get_swarm_list_for_messenger_pubkey',
params: {
pubkey: pubKey,
},
};
const fetchOptions = {
method: options.type,
body: JSON.stringify(body),
headers: {
'Content-Type': 'application/json',
},
timeout: options.timeout,
};
let response;
try {
response = await fetch(options.url, fetchOptions);
} catch (e) {
throw new window.textsecure.EmptySwarmError(
pubKey,
'Could not retrieve swarm nodes'
);
}
let result; const result = await rpc(
if ( `http://${nodeUrl}`,
options.responseType === 'json' && this.snodeServerPort,
response.headers.get('Content-Type') === 'application/json' 'get_snodes_for_pubkey',
) { {
result = await response.json();
} else if (options.responseType === 'arraybuffer') {
result = await response.buffer();
} else {
result = await response.text();
}
// TODO: Handle wrong swarm error from snode
if (!response.ok || !result.nodes || result.nodes === []) {
throw new window.textsecure.EmptySwarmError(
pubKey, pubKey,
'Could not retrieve swarm nodes' }
); );
} return result.snodes;
return result.nodes;
} }
} }

15
libtextsecure/errors.js
Unescape Escape View File

@ -179,6 +179,20 @@
appendStack(this, resolutionError); appendStack(this, resolutionError);
} }
function HTTPError(message, response) {
this.name = 'HTTPError';
this.message = `${response.status} Error: ${message}`;
this.response = response;
Error.call(this, message);
// Maintains proper stack trace, where our error was thrown (only available on V8)
// via https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
if (Error.captureStackTrace) {
Error.captureStackTrace(this);
}
}
window.textsecure.UnregisteredUserError = UnregisteredUserError; window.textsecure.UnregisteredUserError = UnregisteredUserError;
window.textsecure.SendMessageNetworkError = SendMessageNetworkError; window.textsecure.SendMessageNetworkError = SendMessageNetworkError;
window.textsecure.IncomingIdentityKeyError = IncomingIdentityKeyError; window.textsecure.IncomingIdentityKeyError = IncomingIdentityKeyError;
@ -191,4 +205,5 @@
window.textsecure.EmptySwarmError = EmptySwarmError; window.textsecure.EmptySwarmError = EmptySwarmError;
window.textsecure.DNSResolutionError = DNSResolutionError; window.textsecure.DNSResolutionError = DNSResolutionError;
window.textsecure.LokiIpError = LokiIpError; window.textsecure.LokiIpError = LokiIpError;
window.textsecure.HTTPError = HTTPError;
})(); })();

3
main.js
Unescape Escape View File

@ -147,8 +147,7 @@ function prepareURL(pathSegments, moreKeys) {
serverUrl: config.get('serverUrl'), serverUrl: config.get('serverUrl'),
localUrl: config.get('localUrl'), localUrl: config.get('localUrl'),
cdnUrl: config.get('cdnUrl'), cdnUrl: config.get('cdnUrl'),
messageServerPort: config.get('messageServerPort'), snodeServerPort: config.get('snodeServerPort'),
swarmServerPort: config.get('swarmServerPort'),
localServerPort: config.get('localServerPort'), localServerPort: config.get('localServerPort'),
certificateAuthority: config.get('certificateAuthority'), certificateAuthority: config.get('certificateAuthority'),
environment: config.environment, environment: config.environment,

4
preload.js
Unescape Escape View File

@ -292,7 +292,7 @@ const LokiSnodeAPI = require('./js/modules/loki_snode_api');
window.lokiSnodeAPI = new LokiSnodeAPI({ window.lokiSnodeAPI = new LokiSnodeAPI({
serverUrl: config.serverUrl, serverUrl: config.serverUrl,
localUrl: config.localUrl, localUrl: config.localUrl,
swarmServerPort: config.swarmServerPort, snodeServerPort: config.snodeServerPort,
}); });
window.LokiP2pAPI = require('./js/modules/loki_p2p_api'); window.LokiP2pAPI = require('./js/modules/loki_p2p_api');
@ -301,7 +301,7 @@ const LokiMessageAPI = require('./js/modules/loki_message_api');
window.lokiMessageAPI = new LokiMessageAPI({ window.lokiMessageAPI = new LokiMessageAPI({
url: config.serverUrl, url: config.serverUrl,
messageServerPort: config.messageServerPort, snodeServerPort: config.snodeServerPort,
}); });
const LocalLokiServer = require('./libloki/modules/local_loki_server'); const LocalLokiServer = require('./libloki/modules/local_loki_server');

Write Preview
Loading…
Cancel
Save