move more rpc functionality into modules

lib/commands/core.js

@@ -1,8 +1,13 @@
 /*jshint esversion: 6 */
+/* globals process */
 const Core = module.exports;
 const Util = require("../common-util");
 const escapeKeyCharacters = Util.escapeKeyCharacters;
 
+/*  Use Nacl for checking signatures of messages */
+const Nacl = require("tweetnacl/nacl-fast");
+
+
 Core.DEFAULT_LIMIT = 50 * 1024 * 1024;
 Core.SESSION_EXPIRATION_TIME = 60 * 1000;
 
@@ -16,6 +21,30 @@ var makeToken = Core.makeToken = function () {
         .toString(16);
 };
 
+Core.makeCookie = function (token) {
+    var time = (+new Date());
+    time -= time % 5000;
+
+    return [
+        time,
+        process.pid,
+        token
+    ];
+};
+
+var parseCookie = function (cookie) {
+    if (!(cookie && cookie.split)) { return null; }
+
+    var parts = cookie.split('|');
+    if (parts.length !== 3) { return null; }
+
+    var c = {};
+    c.time = new Date(parts[0]);
+    c.pid = Number(parts[1]);
+    c.seq = parts[2];
+    return c;
+};
+
 Core.getSession = function (Sessions, key) {
     var safeKey = escapeKeyCharacters(key);
     if (Sessions[safeKey]) {
@@ -30,13 +59,123 @@ Core.getSession = function (Sessions, key) {
     return user;
 };
 
+Core.expireSession = function (Sessions, key) {
+    var session = Sessions[key];
+    if (!session) { return; }
+    if (session.blobstage) {
+        session.blobstage.close();
+    }
+    delete Sessions[key];
+};
+
+var isTooOld = function (time, now) {
+    return (now - time) > 300000;
+};
+
+Core.expireSessions = function (Sessions) {
+    var now = +new Date();
+    Object.keys(Sessions).forEach(function (key) {
+        var session = Sessions[key];
+        if (session && isTooOld(session.atime, now)) {
+            Core.expireSession(Sessions, key);
+        }
+    });
+};
+
+var addTokenForKey = function (Sessions, publicKey, token) {
+    if (!Sessions[publicKey]) { throw new Error('undefined user'); }
+
+    var user = Core.getSession(Sessions, publicKey);
+    user.tokens.push(token);
+    user.atime = +new Date();
+    if (user.tokens.length > 2) { user.tokens.shift(); }
+};
+
+Core.isValidCookie = function (Sessions, publicKey, cookie) {
+    var parsed = parseCookie(cookie);
+    if (!parsed) { return false; }
+
+    var now = +new Date();
+
+    if (!parsed.time) { return false; }
+    if (isTooOld(parsed.time, now)) {
+        return false;
+    }
+
+    // different process. try harder
+    if (process.pid !== parsed.pid) {
+        return false;
+    }
+
+    var user = Core.getSession(Sessions, publicKey);
+    if (!user) { return false; }
+
+    var idx = user.tokens.indexOf(parsed.seq);
+    if (idx === -1) { return false; }
+
+    if (idx > 0) {
+        // make a new token
+        addTokenForKey(Sessions, publicKey, Core.makeToken());
+    }
+
+    return true;
+};
+
+Core.checkSignature = function (Env, signedMsg, signature, publicKey) {
+    if (!(signedMsg && publicKey)) { return false; }
+
+    var signedBuffer;
+    var pubBuffer;
+    var signatureBuffer;
+
+    try {
+        signedBuffer = Nacl.util.decodeUTF8(signedMsg);
+    } catch (e) {
+        Env.Log.error('INVALID_SIGNED_BUFFER', signedMsg);
+        return null;
+    }
+
+    try {
+        pubBuffer = Nacl.util.decodeBase64(publicKey);
+    } catch (e) {
+        return false;
+    }
+
+    try {
+        signatureBuffer = Nacl.util.decodeBase64(signature);
+    } catch (e) {
+        return false;
+    }
+
+    if (pubBuffer.length !== 32) {
+        Env.Log.error('PUBLIC_KEY_LENGTH', publicKey);
+        return false;
+    }
+
+    if (signatureBuffer.length !== 64) {
+        return false;
+    }
+
+    return Nacl.sign.detached.verify(signedBuffer, signatureBuffer, pubBuffer);
+};
+
+// E_NO_OWNERS
+Core.hasOwners = function (metadata) {
+    return Boolean(metadata && Array.isArray(metadata.owners));
+};
+
+Core.hasPendingOwners = function (metadata) {
+    return Boolean(metadata && Array.isArray(metadata.pending_owners));
+};
+
+// INSUFFICIENT_PERMISSIONS
+Core.isOwner = function (metadata, unsafeKey) {
+    return metadata.owners.indexOf(unsafeKey) !== -1;
+};
+
+Core.isPendingOwner = function (metadata, unsafeKey) {
+    return metadata.pending_owners.indexOf(unsafeKey) !== -1;
+};
 
 
-// getChannelList
-// getSession
-// getHash
-// getMultipleFileSize
-// sumChannelSizes
-// getFreeSpace
-// getLimit
 

lib/commands/pin-rpc.js

@@ -8,6 +8,8 @@ const Pinning = module.exports;
 const Nacl = require("tweetnacl/nacl-fast");
 const Util = require("../common-util");
 const nThen = require("nthen");
+const Saferphore = require("saferphore");
+const Pinned = require('../../scripts/pinned');
 
 //const escapeKeyCharacters = Util.escapeKeyCharacters;
 const unescapeKeyCharacters = Util.unescapeKeyCharacters;
@@ -397,3 +399,66 @@ Pinning.getFileSize = function (Env, channel, _cb) {
     });
 };
 
+/*  accepts a list, and returns a sublist of channel or file ids which seem
+    to have been deleted from the server (file size 0)
+
+    we might consider that we should only say a file is gone if fs.stat returns
+    ENOENT, but for now it's simplest to just rely on getFileSize...
+*/
+Pinning.getDeletedPads = function (Env, channels, cb) {
+    if (!Array.isArray(channels)) { return cb('INVALID_LIST'); }
+    var L = channels.length;
+
+    var sem = Saferphore.create(10);
+    var absentees = [];
+
+    var job = function (channel, wait) {
+        return function (give) {
+            Pinning.getFileSize(Env, channel, wait(give(function (e, size) {
+                if (e) { return; }
+                if (size === 0) { absentees.push(channel); }
+            })));
+        };
+    };
+
+    nThen(function (w) {
+        for (var i = 0; i < L; i++) {
+            sem.take(job(channels[i], w));
+        }
+    }).nThen(function () {
+        cb(void 0, absentees);
+    });
+};
+
+// inform that the
+Pinning.loadChannelPins = function (Env) {
+    Pinned.load(function (err, data) {
+        if (err) {
+            Env.Log.error("LOAD_CHANNEL_PINS", err);
+
+            // FIXME not sure what should be done here instead
+            Env.pinnedPads = {};
+            Env.evPinnedPadsReady.fire();
+            return;
+        }
+
+
+        Env.pinnedPads = data;
+        Env.evPinnedPadsReady.fire();
+    }, {
+        pinPath: Env.paths.pin,
+    });
+};
+
+Pinning.isChannelPinned = function (Env, channel, cb) {
+    Env.evPinnedPadsReady.reg(() => {
+        if (Env.pinnedPads[channel] && Object.keys(Env.pinnedPads[channel]).length) {
+            cb(true);
+        } else {
+            delete Env.pinnedPads[channel];
+            cb(false);
+        }
+    });
+};
+
+

lib/commands/quota.js

@@ -0,0 +1,111 @@
+/*jshint esversion: 6 */
+/* globals Buffer*/
+const Quota = module.exports;
+
+const Core = require("./commands/core");
+const Util = require("../common-util");
+const Package = require('../../package.json');
+const Https = require("https");
+
+Quota.applyCustomLimits = function (Env, config) {
+    var isLimit = function (o) {
+        var valid = o && typeof(o) === 'object' &&
+            typeof(o.limit) === 'number' &&
+            typeof(o.plan) === 'string' &&
+            typeof(o.note) === 'string';
+        return valid;
+    };
+
+    // read custom limits from the config
+    var customLimits = (function (custom) {
+        var limits = {};
+        Object.keys(custom).forEach(function (k) {
+            k.replace(/\/([^\/]+)$/, function (all, safeKey) {
+                var id = Util.unescapeKeyCharacters(safeKey || '');
+                limits[id] = custom[k];
+                return '';
+            });
+        });
+        return limits;
+    }(config.customLimits || {}));
+
+    Object.keys(customLimits).forEach(function (k) {
+        if (!isLimit(customLimits[k])) { return; }
+        Env.limits[k] = customLimits[k];
+    });
+};
+
+// The limits object contains storage limits for all the publicKey that have paid
+// To each key is associated an object containing the 'limit' value and a 'note' explaining that limit
+Quota.updateLimits = function (Env, config, publicKey, cb) { // FIXME BATCH?S
+
+    if (config.adminEmail === false) {
+        Quota.applyCustomLimits(Env, config);
+        if (config.allowSubscriptions === false) { return; }
+        throw new Error("allowSubscriptions must be false if adminEmail is false");
+    }
+    if (typeof cb !== "function") { cb = function () {}; }
+
+    var defaultLimit = typeof(config.defaultStorageLimit) === 'number'?
+        config.defaultStorageLimit: Core.DEFAULT_LIMIT;
+
+    var userId;
+    if (publicKey) {
+        userId = Util.unescapeKeyCharacters(publicKey);
+    }
+
+    var body = JSON.stringify({
+        domain: config.myDomain,
+        subdomain: config.mySubdomain || null,
+        adminEmail: config.adminEmail,
+        version: Package.version
+    });
+    var options = {
+        host: 'accounts.cryptpad.fr',
+        path: '/api/getauthorized',
+        method: 'POST',
+        headers: {
+            "Content-Type": "application/json",
+            "Content-Length": Buffer.byteLength(body)
+        }
+    };
+
+    var req = Https.request(options, function (response) {
+        if (!('' + response.statusCode).match(/^2\d\d$/)) {
+            return void cb('SERVER ERROR ' + response.statusCode);
+        }
+        var str = '';
+
+        response.on('data', function (chunk) {
+            str += chunk;
+        });
+
+        response.on('end', function () {
+            try {
+                var json = JSON.parse(str);
+                Env.limits = json;
+                Quota.applyCustomLimits(Env, config);
+
+                var l;
+                if (userId) {
+                    var limit = Env.limits[userId];
+                    l = limit && typeof limit.limit === "number" ?
+                            [limit.limit, limit.plan, limit.note] : [defaultLimit, '', ''];
+                }
+                cb(void 0, l);
+            } catch (e) {
+                cb(e);
+            }
+        });
+    });
+
+    req.on('error', function (e) {
+        Quota.applyCustomLimits(Env, config);
+        if (!config.domain) { return cb(); }
+        cb(e);
+    });
+
+    req.end(body);
+};
+
+