cryptpad-server 0.0.1 → 0.0.3

package/build/storage.js

@@ -998,7 +998,6 @@ function requireCore() {
         const Util = requireCommonUtil$1();
         const Constants = requireConstants();
         const escapeKeyCharacters = Util.escapeKeyCharacters;
-        __require$5();
         const Crypto = __require$6();
         const Keys = requireKeys();
         Core.DEFAULT_LIMIT = 50 * 1024 * 1024;
@@ -1118,8 +1117,7 @@ function requireCore() {
             cb();
         };
         Core.getPaths = (mainConfig, isEnv) => {
-            const {index, config} = mainConfig;
-            Constants.paths;
+            const {config} = mainConfig;
             const all = {
                 basePath: config.basePath || config.base || "./data",
                 filePath: config.filePath || "./datastore",
@@ -5475,6 +5473,27 @@ function requireBlock$1() {
                 }, cb);
             });
         };
+        Block.rootPlaceholderCreate = (Env, _cb) => {
+            const cb = Util.once(Util.mkAsync(_cb));
+            nThen(w => {
+                Fse.mkdirp(Env.paths.block, w(err => {
+                    if (err) {
+                        Env.Log.error("BLOCK_FOLDER_CREATE_FAILED", err);
+                        w.abort();
+                        return cb(err);
+                    }
+                }));
+            }).nThen(w => {
+                const fullPath = Path.join(Env.paths.block, "placeholder.txt");
+                Fs.writeFile(fullPath, "PLACEHOLDER\n", w(err => {
+                    if (err) {
+                        Env.Log.error("BLOCK_PLACEHOLDER_CREATE_FAILED", err);
+                        w.abort();
+                        return cb(err);
+                    }
+                }));
+            }).nThen(() => cb());
+        };
     })(block$1);
     return block$1.exports;
 }
@@ -5926,60 +5945,69 @@ var hasRequiredCrypto;
 function requireCrypto() {
     if (hasRequiredCrypto) return crypto;
     hasRequiredCrypto = 1;
-    crypto = cryptoLib => {
-        let exports = {};
-        exports.decodeBase64 = msg => Buffer.from(msg, "base64");
-        exports.encodeBase64 = msg => Buffer.from(msg).toString("base64");
-        exports.decodeUTF8 = msg => Buffer.from(msg, "utf8");
-        exports.encodeUTF8 = msg => Buffer.from(msg).toString("utf8");
+    const loadSodium = cryptoLib => {
+        let sodiumLib = {};
         let SodiumNative, NaCl;
         switch (cryptoLib) {
           case "sodiumnative":
-            SodiumNative = require("sodium-native");
-            exports.sigVerify = (signedMessage, validateKey) => {
-                let msg = signedMessage.subarray(64);
-                let ok = SodiumNative.crypto_sign_open(msg, signedMessage, validateKey);
-                if (!ok) {
-                    return false;
-                }
-                return msg;
-            };
-            exports.detachedVerify = (signedBuffer, signatureBuffer, validateKey) => SodiumNative.crypto_sign_verify_detached(signatureBuffer, signedBuffer, validateKey);
-            exports.secretbox = (message, nonce, secretKey) => {
-                let secretBox = Buffer.alloc(message.length + SodiumNative.crypto_box_MACBYTES);
-                SodiumNative.crypto_secretbox_easy(secretBox, message, nonce, secretKey);
-                return secretBox;
-            };
-            exports.secretboxOpen = (secretBox, nonce, secretKey) => {
-                let msg = Buffer.alloc(secretBox.length - SodiumNative.crypto_secretbox_MACBYTES);
-                if (SodiumNative.crypto_secretbox_open_easy(msg, secretBox, nonce, secretKey)) {
+            try {
+                SodiumNative = require("sodium-native");
+                sodiumLib.sigVerify = (signedMessage, validateKey) => {
+                    let msg = signedMessage.subarray(64);
+                    let ok = SodiumNative.crypto_sign_open(msg, signedMessage, validateKey);
+                    if (!ok) {
+                        return false;
+                    }
                     return msg;
-                } else {
-                    return void 0;
-                }
-            };
-            exports.publicKeyFromSecretKey = secretKey => {
-                let pk = new Uint8Array(SodiumNative.crypto_sign_PUBLICKEYBYTES);
-                SodiumNative.crypto_sign_ed25519_sk_to_pk(pk, secretKey);
-                return pk;
-            };
-            exports.hash = message => {
-                let out = Buffer.alloc(SodiumNative.crypto_hash_sha512_BYTES);
-                SodiumNative.crypto_hash_sha512(out, message);
-                return out;
-            };
+                };
+                sodiumLib.detachedVerify = (signedBuffer, signatureBuffer, validateKey) => SodiumNative.crypto_sign_verify_detached(signatureBuffer, signedBuffer, validateKey);
+                sodiumLib.secretbox = (message, nonce, secretKey) => {
+                    let secretBox = Buffer.alloc(message.length + SodiumNative.crypto_box_MACBYTES);
+                    SodiumNative.crypto_secretbox_easy(secretBox, message, nonce, secretKey);
+                    return secretBox;
+                };
+                sodiumLib.secretboxOpen = (secretBox, nonce, secretKey) => {
+                    let msg = Buffer.alloc(secretBox.length - SodiumNative.crypto_secretbox_MACBYTES);
+                    if (SodiumNative.crypto_secretbox_open_easy(msg, secretBox, nonce, secretKey)) {
+                        return msg;
+                    } else {
+                        return void 0;
+                    }
+                };
+                sodiumLib.publicKeyFromSecretKey = secretKey => {
+                    let pk = new Uint8Array(SodiumNative.crypto_sign_PUBLICKEYBYTES);
+                    SodiumNative.crypto_sign_ed25519_sk_to_pk(pk, secretKey);
+                    return pk;
+                };
+                sodiumLib.hash = message => {
+                    let out = Buffer.alloc(SodiumNative.crypto_hash_sha512_BYTES);
+                    SodiumNative.crypto_hash_sha512(out, message);
+                    return out;
+                };
+            } catch (err) {
+                console.error("Error in loading sodium-native: fallback on tweetnacl");
+                return loadSodium("");
+            }
             break;
 
           default:
             NaCl = require$$6;
-            exports.sigVerify = NaCl.sign.open;
-            exports.detachedVerify = NaCl.sign.detached.verify;
-            exports.secretbox = NaCl.secretbox;
-            exports.secretboxOpen = (secretBox, nonce, secretKey) => Buffer.from(NaCl.secretbox.open(secretBox, nonce, secretKey));
-            exports.publicKeyFromSecretKey = secretKey => NaCl.sign?.keyPair?.fromSecretKey(secretKey)?.publicKey;
-            exports.hash = msg => Buffer.from(NaCl.hash(msg));
+            sodiumLib.sigVerify = NaCl.sign.open;
+            sodiumLib.detachedVerify = NaCl.sign.detached.verify;
+            sodiumLib.secretbox = NaCl.secretbox;
+            sodiumLib.secretboxOpen = (secretBox, nonce, secretKey) => Buffer.from(NaCl.secretbox.open(secretBox, nonce, secretKey));
+            sodiumLib.publicKeyFromSecretKey = secretKey => NaCl.sign?.keyPair?.fromSecretKey(secretKey)?.publicKey;
+            sodiumLib.hash = msg => Buffer.from(NaCl.hash(msg));
             break;
         }
+        return sodiumLib;
+    };
+    crypto = cryptoLib => {
+        const exports = loadSodium(cryptoLib);
+        exports.decodeBase64 = msg => Buffer.from(msg, "base64");
+        exports.encodeBase64 = msg => Buffer.from(msg).toString("base64");
+        exports.decodeUTF8 = msg => Buffer.from(msg, "utf8");
+        exports.encodeUTF8 = msg => Buffer.from(msg).toString("utf8");
         return exports;
     };
     return crypto;
@@ -6667,7 +6695,7 @@ function requireMfaManager() {
     return mfaManager;
 }
 
-var version = "0.0.1";
+var version = "0.0.3";
 
 var require$$2 = {
     version
@@ -7485,13 +7513,13 @@ function require_interface() {
             return;
         }
         const {type: rcvType, idx, challenge: challengeBase64, nonce: nonceBase64} = data;
-        const challenge = new Uint8Array(Buffer.from(challengeBase64, "base64"));
-        const nonce = new Uint8Array(Buffer.from(nonceBase64, "base64"));
+        const challenge = new Uint8Array(Crypto.decodeBase64(challengeBase64));
+        const nonce = new Uint8Array(Crypto.decodeBase64(nonceBase64));
         if (ctx.ChallengesCache[challengeBase64]) {
             other.disconnect();
             return ctx.Log.error("INTERFACE_CHALLENGE_ERROR", "Reused challenge");
         }
-        const msg = Buffer.from(Crypto.secretboxOpen(challenge, nonce, ctx.nodes_key));
+        const msg = Crypto.secretboxOpen(challenge, nonce, ctx.nodes_key);
         if (!msg) {
             other.disconnect();
             return ctx.Log.error("INTERFACE_CHALLENGE_ERROR", "Bad challenge answer");
@@ -7566,13 +7594,13 @@ function require_interface() {
         let uid = Util.guid(ctx.pendingConnections);
         ctx.pendingConnections[uid] = coreId;
         const nonce = NodeCrypto.randomBytes(24);
-        const msg = Buffer.from(`${ctx.myType}:${ctx.myNumber}:${String(Date.now())}`, "utf-8");
-        const challenge = Crypto.secretbox(msg, nonce, ctx.nodes_key).toString("base64");
+        const msg = Crypto.decodeUTF8(`${ctx.myType}:${ctx.myNumber}:${String(Date.now())}`);
+        const challenge = Crypto.encodeBase64(Crypto.secretbox(msg, nonce, ctx.nodes_key));
         createHandlers(ctx, other);
         other.send([ uid, "IDENTITY", {
             type: ctx.myType,
             idx: ctx.myNumber,
-            nonce: nonce.toString("base64"),
+            nonce: Crypto.encodeBase64(nonce),
             challenge
         } ]);
     };
@@ -10615,6 +10643,17 @@ function requireAdmin() {
         const {key} = data;
         MFA.revoke(Env, key, cb);
     };
+    const onGetCachedChannelMetadata = (Env, id, cb) => {
+        const index = Env.metadata_cache?.[id];
+        if (!index) {
+            return void cb("ENOENT");
+        }
+        cb(void 0, index);
+    };
+    const onClearCachedChannelMetadata = (Env, id, cb) => {
+        delete Env.metadata_cache[id];
+        cb();
+    };
     const onArchiveBlock = (Env, data, cb) => {
         const {key, reason} = data;
         const archiveReason = {
@@ -11004,17 +11043,6 @@ function requireAdmin() {
         }
         cb(void 0, index);
     };
-    const onGetCachedChannelMetadata = (Env, id, cb) => {
-        const index = Env.metadata_cache?.[id];
-        if (!index) {
-            return void cb("ENOENT");
-        }
-        cb(void 0, index);
-    };
-    const onClearCachedChannelMetadata = (Env, id, cb) => {
-        delete Env.metadata_cache[id];
-        cb();
-    };
     const onGetActiveChannelCount = (Env, _id, cb) => {
         if (!Env.channel_cache) {
             return void cb("ENOENT");
@@ -12050,6 +12078,12 @@ function requireStorage() {
             const bearerSecret = Util.encodeBase64(Crypto.randomBytes(32));
             const decree = [ "SET_BEARER_SECRET", [ bearerSecret ], "INTERNAL", +new Date ];
             Decrees.onNewDecree(Env, decree, "", waitFor());
+        }).nThen(w => {
+            BlockStore.rootPlaceholderCreate(Env, w(err => {
+                if (err) {
+                    console.warn(`${myId}: Impossible to create block's placeholder. Please check the value of blockPath in your config.js file and if you have write access on it.`);
+                }
+            }));
         }).nThen(() => {
             if (index !== 0) {
                 return;

package/build/storage.worker.js

@@ -1000,7 +1000,6 @@ function requireCore() {
         const Util = requireCommonUtil$1();
         const Constants = requireConstants();
         const escapeKeyCharacters = Util.escapeKeyCharacters;
-        __require$1();
         const Crypto = __require();
         const Keys = requireKeys();
         Core.DEFAULT_LIMIT = 50 * 1024 * 1024;
@@ -1120,8 +1119,7 @@ function requireCore() {
             cb();
         };
         Core.getPaths = (mainConfig, isEnv) => {
-            const {index, config} = mainConfig;
-            Constants.paths;
+            const {config} = mainConfig;
             const all = {
                 basePath: config.basePath || config.base || "./data",
                 filePath: config.filePath || "./datastore",
@@ -4733,7 +4731,7 @@ function requireTasks() {
     return tasks.exports;
 }
 
-var version = "0.0.1";
+var version = "0.0.3";
 
 var require$$2 = {
     version
@@ -5512,60 +5510,69 @@ var hasRequiredCrypto;
 function requireCrypto() {
     if (hasRequiredCrypto) return crypto;
     hasRequiredCrypto = 1;
-    crypto = cryptoLib => {
-        let exports = {};
-        exports.decodeBase64 = msg => Buffer.from(msg, "base64");
-        exports.encodeBase64 = msg => Buffer.from(msg).toString("base64");
-        exports.decodeUTF8 = msg => Buffer.from(msg, "utf8");
-        exports.encodeUTF8 = msg => Buffer.from(msg).toString("utf8");
+    const loadSodium = cryptoLib => {
+        let sodiumLib = {};
         let SodiumNative, NaCl;
         switch (cryptoLib) {
           case "sodiumnative":
-            SodiumNative = require("sodium-native");
-            exports.sigVerify = (signedMessage, validateKey) => {
-                let msg = signedMessage.subarray(64);
-                let ok = SodiumNative.crypto_sign_open(msg, signedMessage, validateKey);
-                if (!ok) {
-                    return false;
-                }
-                return msg;
-            };
-            exports.detachedVerify = (signedBuffer, signatureBuffer, validateKey) => SodiumNative.crypto_sign_verify_detached(signatureBuffer, signedBuffer, validateKey);
-            exports.secretbox = (message, nonce, secretKey) => {
-                let secretBox = Buffer.alloc(message.length + SodiumNative.crypto_box_MACBYTES);
-                SodiumNative.crypto_secretbox_easy(secretBox, message, nonce, secretKey);
-                return secretBox;
-            };
-            exports.secretboxOpen = (secretBox, nonce, secretKey) => {
-                let msg = Buffer.alloc(secretBox.length - SodiumNative.crypto_secretbox_MACBYTES);
-                if (SodiumNative.crypto_secretbox_open_easy(msg, secretBox, nonce, secretKey)) {
+            try {
+                SodiumNative = require("sodium-native");
+                sodiumLib.sigVerify = (signedMessage, validateKey) => {
+                    let msg = signedMessage.subarray(64);
+                    let ok = SodiumNative.crypto_sign_open(msg, signedMessage, validateKey);
+                    if (!ok) {
+                        return false;
+                    }
                     return msg;
-                } else {
-                    return void 0;
-                }
-            };
-            exports.publicKeyFromSecretKey = secretKey => {
-                let pk = new Uint8Array(SodiumNative.crypto_sign_PUBLICKEYBYTES);
-                SodiumNative.crypto_sign_ed25519_sk_to_pk(pk, secretKey);
-                return pk;
-            };
-            exports.hash = message => {
-                let out = Buffer.alloc(SodiumNative.crypto_hash_sha512_BYTES);
-                SodiumNative.crypto_hash_sha512(out, message);
-                return out;
-            };
+                };
+                sodiumLib.detachedVerify = (signedBuffer, signatureBuffer, validateKey) => SodiumNative.crypto_sign_verify_detached(signatureBuffer, signedBuffer, validateKey);
+                sodiumLib.secretbox = (message, nonce, secretKey) => {
+                    let secretBox = Buffer.alloc(message.length + SodiumNative.crypto_box_MACBYTES);
+                    SodiumNative.crypto_secretbox_easy(secretBox, message, nonce, secretKey);
+                    return secretBox;
+                };
+                sodiumLib.secretboxOpen = (secretBox, nonce, secretKey) => {
+                    let msg = Buffer.alloc(secretBox.length - SodiumNative.crypto_secretbox_MACBYTES);
+                    if (SodiumNative.crypto_secretbox_open_easy(msg, secretBox, nonce, secretKey)) {
+                        return msg;
+                    } else {
+                        return void 0;
+                    }
+                };
+                sodiumLib.publicKeyFromSecretKey = secretKey => {
+                    let pk = new Uint8Array(SodiumNative.crypto_sign_PUBLICKEYBYTES);
+                    SodiumNative.crypto_sign_ed25519_sk_to_pk(pk, secretKey);
+                    return pk;
+                };
+                sodiumLib.hash = message => {
+                    let out = Buffer.alloc(SodiumNative.crypto_hash_sha512_BYTES);
+                    SodiumNative.crypto_hash_sha512(out, message);
+                    return out;
+                };
+            } catch (err) {
+                console.error("Error in loading sodium-native: fallback on tweetnacl");
+                return loadSodium("");
+            }
             break;
 
           default:
             NaCl = require$$3$1;
-            exports.sigVerify = NaCl.sign.open;
-            exports.detachedVerify = NaCl.sign.detached.verify;
-            exports.secretbox = NaCl.secretbox;
-            exports.secretboxOpen = (secretBox, nonce, secretKey) => Buffer.from(NaCl.secretbox.open(secretBox, nonce, secretKey));
-            exports.publicKeyFromSecretKey = secretKey => NaCl.sign?.keyPair?.fromSecretKey(secretKey)?.publicKey;
-            exports.hash = msg => Buffer.from(NaCl.hash(msg));
+            sodiumLib.sigVerify = NaCl.sign.open;
+            sodiumLib.detachedVerify = NaCl.sign.detached.verify;
+            sodiumLib.secretbox = NaCl.secretbox;
+            sodiumLib.secretboxOpen = (secretBox, nonce, secretKey) => Buffer.from(NaCl.secretbox.open(secretBox, nonce, secretKey));
+            sodiumLib.publicKeyFromSecretKey = secretKey => NaCl.sign?.keyPair?.fromSecretKey(secretKey)?.publicKey;
+            sodiumLib.hash = msg => Buffer.from(NaCl.hash(msg));
             break;
         }
+        return sodiumLib;
+    };
+    crypto = cryptoLib => {
+        const exports = loadSodium(cryptoLib);
+        exports.decodeBase64 = msg => Buffer.from(msg, "base64");
+        exports.encodeBase64 = msg => Buffer.from(msg).toString("base64");
+        exports.decodeUTF8 = msg => Buffer.from(msg, "utf8");
+        exports.encodeUTF8 = msg => Buffer.from(msg).toString("utf8");
         return exports;
     };
     return crypto;

package/index.js

@@ -8,8 +8,9 @@ const Path = require('node:path');
 const showHelp = () => {
     console.log(`Usage ${process.argv[1]}:`);
     console.log("\t--help, -h\tDisplay this help");
-    console.log("\t--type,-t\tSet the core type (if unset, starts every core)");
-    console.log("\t--index,-i\tSet the core node index (default: 0)");
+    console.log("\t--type,-t\tSet the node type (if unset, starts every node)");
+    console.log("\t--index,-i\tSet the node index (default: 0)");
+    console.log("\t--server,-s\tStart the set of nodes identified with serverId");
     process.exit(1);
 };
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cryptpad-server",
   "description": "CryptPad Server",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "license": "AGPL-3.0+",
   "repository": {
     "type": "git",
@@ -16,10 +16,10 @@
     "build"
   ],
   "dependencies": {
-    "body-parser": "^2.2.0",
     "connect-gzip-static": "^4.2.1",
     "cookie-parser": "^1.4.7",
-    "express": "~4.22.1",
+    "express": "~5.2.1",
+    "mime-types": "^3.0.2",
     "fs-extra": "^7.0.0",
     "http-proxy-middleware": "^3.0.3",
     "nthen": "0.1.8",
@@ -50,6 +50,7 @@
     "typescript": "^5.6.2"
   },
   "overrides": {
+    "qs": "^6.16.0",
     "http-proxy": "npm:http-proxy-3@^1.23.2",
     "serialize-javascript": "^7.0.4"
   },
@@ -63,6 +64,7 @@
     "tests": "node --test tests/",
     "test": "node tests/runAll.js",
     "start": "node index.js",
-    "dev": "DEV=1 node index.js"
+    "dev": "DEV=1 node index.js",
+    "windev": "set DEV=1& node index.js"
   }
 }

package/readme.md

@@ -2,10 +2,8 @@
 
 SPDX-License-Identifier: AGPL-3.0-or-later
 -->
-# Prototype: Scalable Server for CryptPad
 
-This repository contains a distributed server prototype for CryptPad. This is
-still in progress exploratory work.
+This repository contains the code for CryptPad server.
 
 ## Architecture
 
@@ -23,54 +21,32 @@ they can be done in place without too much pressure on them.
 
 ### Topology
 
-The core nodes are connected to both ws and storage nodes, but the latter two
-cannot communicate directly.
+The core nodes are connected to both front and storage nodes, but the latter two
+cannot communicate directly (only on the same layer).
 
 ## Configuration
 
-The configuration can be done using the `Config` argument, which will store the
-graph topology of the nodes.
-
-Using websockets for communication, this variable looks like this:
-
-```javascript
-let Config = {
-    infra: {
-        ws: [{
-            host: 'localhost',
-            port: 3010
-        }],
-        core: [{
-            host: 'localhost',
-            port: 3011
-        }, {
-                host: 'localhost',
-                port: 3012
-            }],
-        storage: [{
-            host: 'localhost',
-            port: 3014
-        }]
-    }
-};
-```
-
-The above configuration describes a network comprised of 4 nodes, having one
-front node on port `3010`, 2 core servers on port `3011` and `3012`
-and a storage node accessible via port `3014`.
+The configuration can be done in `config/infra.js`, which will store the graph
+topology of the nodes and how to connect to them.
 
-In addition, launching a server requires setting the field `myId` with your
-identifier, which will be of the form `type:id`. For instance, in the first core
-node (the node listening on port `3011`), it would be `Config.myId = 'core:0'`.
+Using websockets for communication, please look at `config/infra.example.js` for
+explanations.
 
 ## Usage
 
-Before first use, you may want to install the dependencies with:
+To be used in CryptPad, this repository releases are available on npm:
+https://www.npmjs.com/package/cryptpad-server
+
+You can also use it in standalone mode for development purpose. The client code
+should be present in `../cryptpad/` or in a `clientRoot` property as a string in
+`config/config.js`. Before first use, you may want to install the dependencies
+and build the code with:
 ```bash
 npm install
+npm run build
 ```
 
-To spawn the server topology described in `ws-config.js`, run the start script:
+To spawn the server topology described in `infra/config.js`, run the start script:
 ```bash
 npm run start
 ```
@@ -78,14 +54,35 @@ npm run start
 Alternatively, you can the new servers manually. You first need to start the
 `core` nodes with the following command.
 
+For that to work, you need to have a shared key between the different nodes to
+authenticate them, which can be generated with:
+
+```bash
+openssl rand -base64 32
+```
+
+Then add the resulting random bytes in `private.nodes_key` property in your
+`config/config.js`.
+
+```bash
+node index.js --type core --index 0
+```
+
+Then you can start a `front` and `storage` nodes in any order:
 ```bash
-node core/index.js
+node index.js --type front --index 0
+node index.js --type storage --index 0
+node index.js --type front --index 1
+node index.js --type storage --index 2
+node index.js --type storage --index 1
 ```
 
-Then you can start a `ws` and `storage` nodes in any order:
+Alternatively, you can identify different sets of nodes with the `serverId`
+property of their corresponding nodes in `config/infra.js`, and start a subset
+of them sharing the same `serverId` with:
+
 ```bash
-node storage/index.js
-node front/index.js
+node index.js --server [serverId value]
 ```
 
 ## Tests