cryptpad-server 0.0.1 → 0.0.2

package/build/core.js

@@ -823,60 +823,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$$0$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;
@@ -934,13 +943,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");
@@ -1015,13 +1024,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
         } ]);
     };
@@ -7687,7 +7696,7 @@ function requireHttpCommands() {
     return httpCommands;
 }
 
-var version = "0.0.1";
+var version = "0.0.2";
 
 var require$$2 = {
     version

package/build/core.worker.js

@@ -813,60 +813,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$$0$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/build/front.js

@@ -829,60 +829,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$$0$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;
@@ -940,13 +949,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");
@@ -1021,13 +1030,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
         } ]);
     };
@@ -4044,7 +4053,7 @@ function requireLogger() {
     return logger;
 }
 
-var version = "0.0.1";
+var version = "0.0.2";
 
 var require$$2 = {
     version

package/build/http.js

@@ -3479,7 +3479,7 @@ function requireLogger() {
     return logger;
 }
 
-var version = "0.0.1";
+var version = "0.0.2";
 
 var require$$2 = {
     version
@@ -4649,60 +4649,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$$0$2;
-            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;
@@ -4754,13 +4763,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");
@@ -4835,13 +4844,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
         } ]);
     };

package/build/http.worker.js

@@ -3529,7 +3529,7 @@ function requireDefaults() {
     return defaults.exports;
 }
 
-var version = "0.0.1";
+var version = "0.0.2";
 
 var require$$2 = {
     version