dignity.js 0.2.0 → 0.3.0

package/dist/dignity.esm.js

@@ -2454,7 +2454,8 @@ var require_message_security_service = __commonJS({
       broadcastPasswords: {},
       resolveBroadcastPassword: null,
       powSteps: 22,
-      trustedPeerKeys: {}
+      trustedPeerKeys: {},
+      kdfIterations: 1e5
     };
     function stableStringify(value) {
       if (value === null || typeof value !== "object") {
@@ -2481,6 +2482,33 @@ var require_message_security_service = __commonJS({
     function utf8ToBytes(value) {
       return naclUtil.decodeUTF8(value);
     }
+    async function deriveBroadcastKey(password, salt, iterations) {
+      const subtle = globalThis.crypto && globalThis.crypto.subtle;
+      if (subtle) {
+        const keyMaterial = await subtle.importKey(
+          "raw",
+          utf8ToBytes(password),
+          "PBKDF2",
+          false,
+          ["deriveBits"]
+        );
+        const bits = await subtle.deriveBits(
+          { name: "PBKDF2", salt, iterations, hash: "SHA-256" },
+          keyMaterial,
+          256
+        );
+        return new Uint8Array(bits);
+      }
+      try {
+        const { pbkdf2Sync } = __require("crypto");
+        return new Uint8Array(pbkdf2Sync(password, Buffer.from(salt), iterations, 32, "sha256"));
+      } catch (_ignored) {
+        return hash32(concatBytes(utf8ToBytes(password), salt));
+      }
+    }
+    function legacyBroadcastKey(password, salt) {
+      return hash32(concatBytes(utf8ToBytes(password), salt));
+    }
     function normalizePeerPublicKey(publicKey) {
       if (!publicKey || typeof publicKey !== "object") {
         throw new Error("Public key must be an object with signingPublicKey and encryptionPublicKey");
@@ -2641,7 +2669,7 @@ var require_message_security_service = __commonJS({
         if (envelope.security && envelope.security.signing && envelope.security.signing.enabled && this.options.signingEnabled) {
           this.verifySignature(envelope);
         }
-        const payload = this.decryptPayload(envelope);
+        const payload = await this.decryptPayload(envelope);
         return {
           ignored: false,
           messageType: envelope.messageType,
@@ -2706,7 +2734,8 @@ var require_message_security_service = __commonJS({
         const nonce = nacl.randomBytes(nacl.secretbox.nonceLength);
         const salt = nacl.randomBytes(16);
         const password = this.resolveBroadcastPassword(scope);
-        const key = hash32(concatBytes(utf8ToBytes(password), salt));
+        const iterations = this.options.kdfIterations || DEFAULT_SECURITY_OPTIONS.kdfIterations;
+        const key = await deriveBroadcastKey(password, salt, iterations);
         const encrypted = nacl.secretbox(plainText, nonce, key);
         return {
           payload: naclUtil.encodeBase64(encrypted),
@@ -2715,11 +2744,13 @@ var require_message_security_service = __commonJS({
             mode: "broadcast",
             scope,
             nonce: naclUtil.encodeBase64(nonce),
-            salt: naclUtil.encodeBase64(salt)
+            salt: naclUtil.encodeBase64(salt),
+            kdf: "pbkdf2",
+            kdfIterations: iterations
           }
         };
       }
-      decryptPayload(envelope) {
+      async decryptPayload(envelope) {
         const encryption = envelope.security ? envelope.security.encryption : null;
         if (!encryption || !encryption.enabled || !this.options.encryptionEnabled) {
           return envelope.payload;
@@ -2730,7 +2761,13 @@ var require_message_security_service = __commonJS({
           const password = this.resolveBroadcastPassword(scope);
           const salt = naclUtil.decodeBase64(encryption.salt);
           const nonce = naclUtil.decodeBase64(encryption.nonce);
-          const key = hash32(concatBytes(utf8ToBytes(password), salt));
+          let key;
+          if (encryption.kdf === "pbkdf2") {
+            const iterations = encryption.kdfIterations || DEFAULT_SECURITY_OPTIONS.kdfIterations;
+            key = await deriveBroadcastKey(password, salt, iterations);
+          } else {
+            key = legacyBroadcastKey(password, salt);
+          }
           const decrypted = nacl.secretbox.open(encryptedBuffer, nonce, key);
           if (!decrypted) {
             throw new Error("Unable to decrypt broadcast payload");
@@ -2824,6 +2861,8 @@ var require_message_security_service = __commonJS({
     module.exports = {
       MessageSecurityService,
       stableStringify,
+      deriveBroadcastKey,
+      legacyBroadcastKey,
       DEFAULT_SECURITY_OPTIONS
     };
   }