@protontech/openpgp 6.0.0-beta.3.patch.0 → 6.0.0-beta.3.patch.1

package/dist/node/openpgp.mjs

@@ -1,4 +1,4 @@
-/*! OpenPGP.js v6.0.0-beta.3.patch.0 - 2024-09-09 - this is LGPL licensed code, see LICENSE/our website https://openpgpjs.org/ for more information. */
+/*! OpenPGP.js v6.0.0-beta.3.patch.1 - 2024-09-11 - this is LGPL licensed code, see LICENSE/our website https://openpgpjs.org/ for more information. */
 const globalThis = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 import { createRequire } from 'module';
@@ -1686,7 +1686,7 @@ var config = {
    * @memberof module:config
    * @property {String} versionString A version string to be included in armored messages
    */
-  versionString: 'OpenPGP.js 6.0.0-beta.3.patch.0',
+  versionString: 'OpenPGP.js 6.0.0-beta.3.patch.1',
   /**
    * @memberof module:config
    * @property {String} commentString A comment string to be included in armored messages
@@ -9302,7 +9302,7 @@ async function sign$6(algo, hashAlgo, message, publicKey, privateKey, hashed) {
     case enums.publicKey.ed25519:
       try {
         const webCrypto = util.getWebCrypto();
-        const jwk = privateKeyToJWK$1(algo, publicKey, privateKey);
+        const jwk = privateKeyToJWK(algo, publicKey, privateKey);
         const key = await webCrypto.importKey('jwk', jwk, 'Ed25519', false, ['sign']);
 
         const signature = new Uint8Array(
@@ -9349,7 +9349,7 @@ async function verify$6(algo, hashAlgo, { RS }, m, publicKey, hashed) {
     case enums.publicKey.ed25519:
       try {
         const webCrypto = util.getWebCrypto();
-        const jwk = publicKeyToJWK$1(algo, publicKey);
+        const jwk = publicKeyToJWK(algo, publicKey);
         const key = await webCrypto.importKey('jwk', jwk, 'Ed25519', false, ['verify']);
         const verified = await webCrypto.verify('Ed25519', key, RS, hashed);
         return verified;
@@ -9424,7 +9424,7 @@ function getPreferredHashAlgo$2(algo) {
   }
 }
 
-const publicKeyToJWK$1 = (algo, publicKey) => {
+const publicKeyToJWK = (algo, publicKey) => {
   switch (algo) {
     case enums.publicKey.ed25519: {
       const jwk = {
@@ -9440,10 +9440,10 @@ const publicKeyToJWK$1 = (algo, publicKey) => {
   }
 };
 
-const privateKeyToJWK$1 = (algo, publicKey, privateKey) => {
+const privateKeyToJWK = (algo, publicKey, privateKey) => {
   switch (algo) {
     case enums.publicKey.ed25519: {
-      const jwk = publicKeyToJWK$1(algo, publicKey);
+      const jwk = publicKeyToJWK(algo, publicKey);
       jwk.d = uint8ArrayToB64(privateKey);
       return jwk;
     }
@@ -9592,27 +9592,12 @@ const HKDF_INFO = {
  */
 async function generate$3(algo) {
   switch (algo) {
-    case enums.publicKey.x25519:
-      try {
-        const webCrypto = util.getWebCrypto();
-        const webCryptoKey = await webCrypto.generateKey('X25519', true, ['deriveKey', 'deriveBits']);
-
-        const privateKey = await webCrypto.exportKey('jwk', webCryptoKey.privateKey);
-        const publicKey = await webCrypto.exportKey('jwk', webCryptoKey.publicKey);
-
-        return {
-          A: new Uint8Array(b64ToUint8Array(publicKey.x)),
-          k: b64ToUint8Array(privateKey.d, true)
-        };
-      } catch (err) {
-        if (err.name !== 'NotSupportedError') {
-          throw err;
-        }
-        // k stays in little-endian, unlike legacy ECDH over curve25519
-        const k = getRandomBytes(32);
-        const { publicKey: A } = nacl.box.keyPair.fromSecretKey(k);
-        return { A, k };
-      }
+    case enums.publicKey.x25519: {
+      // k stays in little-endian, unlike legacy ECDH over curve25519
+      const k = getRandomBytes(32);
+      const { publicKey: A } = nacl.box.keyPair.fromSecretKey(k);
+      return { A, k };
+    }
 
     case enums.publicKey.x448: {
       const x448 = await util.getNobleCurve(enums.publicKey.x448);
@@ -9754,32 +9739,13 @@ function getPayloadSize(algo) {
  */
 async function generateEphemeralEncryptionMaterial(algo, recipientA) {
   switch (algo) {
-    case enums.publicKey.x25519:
-      try {
-        const webCrypto = util.getWebCrypto();
-        const jwk = publicKeyToJWK(algo, recipientA);
-        const ephemeralKeyPair = await webCrypto.generateKey('X25519', true, ['deriveKey', 'deriveBits']);
-        const recipientPublicKey = await webCrypto.importKey('jwk', jwk, 'X25519', false, []);
-        const sharedSecretBuffer = await webCrypto.deriveBits(
-          { name: 'X25519', public: recipientPublicKey },
-          ephemeralKeyPair.privateKey,
-          getPayloadSize(algo) * 8 // in bits
-        );
-        const ephemeralPublicKeyJwt = await webCrypto.exportKey('jwk', ephemeralKeyPair.publicKey);
-        return {
-          sharedSecret: new Uint8Array(sharedSecretBuffer),
-          ephemeralPublicKey: new Uint8Array(b64ToUint8Array(ephemeralPublicKeyJwt.x))
-        };
-      } catch (err) {
-        if (err.name !== 'NotSupportedError') {
-          throw err;
-        }
-        const ephemeralSecretKey = getRandomBytes(getPayloadSize(algo));
-        const sharedSecret = nacl.scalarMult(ephemeralSecretKey, recipientA);
-        const { publicKey: ephemeralPublicKey } = nacl.box.keyPair.fromSecretKey(ephemeralSecretKey);
+    case enums.publicKey.x25519: {
+      const ephemeralSecretKey = getRandomBytes(getPayloadSize(algo));
+      const sharedSecret = nacl.scalarMult(ephemeralSecretKey, recipientA);
+      const { publicKey: ephemeralPublicKey } = nacl.box.keyPair.fromSecretKey(ephemeralSecretKey);
 
-        return { ephemeralPublicKey, sharedSecret };
-      }
+      return { ephemeralPublicKey, sharedSecret };
+    }
     case enums.publicKey.x448: {
       const x448 = await util.getNobleCurve(enums.publicKey.x448);
       const ephemeralSecretKey = x448.utils.randomPrivateKey();
@@ -9795,24 +9761,7 @@ async function generateEphemeralEncryptionMaterial(algo, recipientA) {
 async function recomputeSharedSecret(algo, ephemeralPublicKey, A, k) {
   switch (algo) {
     case enums.publicKey.x25519:
-      try {
-        const webCrypto = util.getWebCrypto();
-        const privateKeyJWK = privateKeyToJWK(algo, A, k);
-        const ephemeralPublicKeyJWK = publicKeyToJWK(algo, ephemeralPublicKey);
-        const privateKey = await webCrypto.importKey('jwk', privateKeyJWK, 'X25519', false, ['deriveKey', 'deriveBits']);
-        const ephemeralPublicKeyReference = await webCrypto.importKey('jwk', ephemeralPublicKeyJWK, 'X25519', false, []);
-        const sharedSecretBuffer = await webCrypto.deriveBits(
-          { name: 'X25519', public: ephemeralPublicKeyReference },
-          privateKey,
-          getPayloadSize(algo) * 8 // in bits
-        );
-        return new Uint8Array(sharedSecretBuffer);
-      } catch (err) {
-        if (err.name !== 'NotSupportedError') {
-          throw err;
-        }
-        return nacl.scalarMult(k, ephemeralPublicKey);
-      }
+      return nacl.scalarMult(k, ephemeralPublicKey);
     case enums.publicKey.x448: {
       const x448 = await util.getNobleCurve(enums.publicKey.x448);
       const sharedSecret = x448.getSharedSecret(k, ephemeralPublicKey);
@@ -9823,35 +9772,6 @@ async function recomputeSharedSecret(algo, ephemeralPublicKey, A, k) {
   }
 }
 
-
-function publicKeyToJWK(algo, publicKey) {
-  switch (algo) {
-    case enums.publicKey.x25519: {
-      const jwk = {
-        kty: 'OKP',
-        crv: 'X25519',
-        x: uint8ArrayToB64(publicKey),
-        ext: true
-      };
-      return jwk;
-    }
-    default:
-      throw new Error('Unsupported ECDH algorithm');
-  }
-}
-
-function privateKeyToJWK(algo, publicKey, privateKey) {
-  switch (algo) {
-    case enums.publicKey.x25519: {
-      const jwk = publicKeyToJWK(algo, publicKey);
-      jwk.d = uint8ArrayToB64(privateKey);
-      return jwk;
-    }
-    default:
-      throw new Error('Unsupported ECDH algorithm');
-  }
-}
-
 var ecdh_x = /*#__PURE__*/Object.freeze({
   __proto__: null,
   decrypt: decrypt$2,
@@ -12552,13 +12472,25 @@ class Argon2S2K {
     const { passes, parallelism, memoryExponent } = config$1.s2kArgon2Params;
 
     this.type = 'argon2';
-    /**  @type {Uint8Array} 16 bytes of salt */
+    /**
+     * 16 bytes of salt
+     * @type {Uint8Array}
+     */
     this.salt = null;
-    /** @type {Integer} number of passes */
+    /**
+     * number of passes
+     * @type {Integer}
+     */
     this.t = passes;
-    /** @type {Integer} degree of parallelism (lanes) */
+    /**
+     * degree of parallelism (lanes)
+     * @type {Integer}
+     */
     this.p = parallelism;
-    /** @type {Integer} exponent indicating memory size */
+    /**
+     * exponent indicating memory size
+     * @type {Integer}
+     */
     this.encodedM = memoryExponent;
   }
 

package/dist/openpgp.js

@@ -1,4 +1,4 @@
-/*! OpenPGP.js v6.0.0-beta.3.patch.0 - 2024-09-09 - this is LGPL licensed code, see LICENSE/our website https://openpgpjs.org/ for more information. */
+/*! OpenPGP.js v6.0.0-beta.3.patch.1 - 2024-09-11 - this is LGPL licensed code, see LICENSE/our website https://openpgpjs.org/ for more information. */
 var openpgp = (function (exports) {
   'use strict';
 
@@ -1685,7 +1685,7 @@ var openpgp = (function (exports) {
      * @memberof module:config
      * @property {String} versionString A version string to be included in armored messages
      */
-    versionString: 'OpenPGP.js 6.0.0-beta.3.patch.0',
+    versionString: 'OpenPGP.js 6.0.0-beta.3.patch.1',
     /**
      * @memberof module:config
      * @property {String} commentString A comment string to be included in armored messages
@@ -9295,7 +9295,7 @@ var openpgp = (function (exports) {
       case enums.publicKey.ed25519:
         try {
           const webCrypto = util.getWebCrypto();
-          const jwk = privateKeyToJWK$1(algo, publicKey, privateKey);
+          const jwk = privateKeyToJWK(algo, publicKey, privateKey);
           const key = await webCrypto.importKey('jwk', jwk, 'Ed25519', false, ['sign']);
 
           const signature = new Uint8Array(
@@ -9342,7 +9342,7 @@ var openpgp = (function (exports) {
       case enums.publicKey.ed25519:
         try {
           const webCrypto = util.getWebCrypto();
-          const jwk = publicKeyToJWK$1(algo, publicKey);
+          const jwk = publicKeyToJWK(algo, publicKey);
           const key = await webCrypto.importKey('jwk', jwk, 'Ed25519', false, ['verify']);
           const verified = await webCrypto.verify('Ed25519', key, RS, hashed);
           return verified;
@@ -9417,7 +9417,7 @@ var openpgp = (function (exports) {
     }
   }
 
-  const publicKeyToJWK$1 = (algo, publicKey) => {
+  const publicKeyToJWK = (algo, publicKey) => {
     switch (algo) {
       case enums.publicKey.ed25519: {
         const jwk = {
@@ -9433,10 +9433,10 @@ var openpgp = (function (exports) {
     }
   };
 
-  const privateKeyToJWK$1 = (algo, publicKey, privateKey) => {
+  const privateKeyToJWK = (algo, publicKey, privateKey) => {
     switch (algo) {
       case enums.publicKey.ed25519: {
-        const jwk = publicKeyToJWK$1(algo, publicKey);
+        const jwk = publicKeyToJWK(algo, publicKey);
         jwk.d = uint8ArrayToB64(privateKey);
         return jwk;
       }
@@ -9585,27 +9585,12 @@ var openpgp = (function (exports) {
    */
   async function generate$3(algo) {
     switch (algo) {
-      case enums.publicKey.x25519:
-        try {
-          const webCrypto = util.getWebCrypto();
-          const webCryptoKey = await webCrypto.generateKey('X25519', true, ['deriveKey', 'deriveBits']);
-
-          const privateKey = await webCrypto.exportKey('jwk', webCryptoKey.privateKey);
-          const publicKey = await webCrypto.exportKey('jwk', webCryptoKey.publicKey);
-
-          return {
-            A: new Uint8Array(b64ToUint8Array(publicKey.x)),
-            k: b64ToUint8Array(privateKey.d, true)
-          };
-        } catch (err) {
-          if (err.name !== 'NotSupportedError') {
-            throw err;
-          }
-          // k stays in little-endian, unlike legacy ECDH over curve25519
-          const k = getRandomBytes(32);
-          const { publicKey: A } = nacl.box.keyPair.fromSecretKey(k);
-          return { A, k };
-        }
+      case enums.publicKey.x25519: {
+        // k stays in little-endian, unlike legacy ECDH over curve25519
+        const k = getRandomBytes(32);
+        const { publicKey: A } = nacl.box.keyPair.fromSecretKey(k);
+        return { A, k };
+      }
 
       case enums.publicKey.x448: {
         const x448 = await util.getNobleCurve(enums.publicKey.x448);
@@ -9747,32 +9732,13 @@ var openpgp = (function (exports) {
    */
   async function generateEphemeralEncryptionMaterial(algo, recipientA) {
     switch (algo) {
-      case enums.publicKey.x25519:
-        try {
-          const webCrypto = util.getWebCrypto();
-          const jwk = publicKeyToJWK(algo, recipientA);
-          const ephemeralKeyPair = await webCrypto.generateKey('X25519', true, ['deriveKey', 'deriveBits']);
-          const recipientPublicKey = await webCrypto.importKey('jwk', jwk, 'X25519', false, []);
-          const sharedSecretBuffer = await webCrypto.deriveBits(
-            { name: 'X25519', public: recipientPublicKey },
-            ephemeralKeyPair.privateKey,
-            getPayloadSize(algo) * 8 // in bits
-          );
-          const ephemeralPublicKeyJwt = await webCrypto.exportKey('jwk', ephemeralKeyPair.publicKey);
-          return {
-            sharedSecret: new Uint8Array(sharedSecretBuffer),
-            ephemeralPublicKey: new Uint8Array(b64ToUint8Array(ephemeralPublicKeyJwt.x))
-          };
-        } catch (err) {
-          if (err.name !== 'NotSupportedError') {
-            throw err;
-          }
-          const ephemeralSecretKey = getRandomBytes(getPayloadSize(algo));
-          const sharedSecret = nacl.scalarMult(ephemeralSecretKey, recipientA);
-          const { publicKey: ephemeralPublicKey } = nacl.box.keyPair.fromSecretKey(ephemeralSecretKey);
+      case enums.publicKey.x25519: {
+        const ephemeralSecretKey = getRandomBytes(getPayloadSize(algo));
+        const sharedSecret = nacl.scalarMult(ephemeralSecretKey, recipientA);
+        const { publicKey: ephemeralPublicKey } = nacl.box.keyPair.fromSecretKey(ephemeralSecretKey);
 
-          return { ephemeralPublicKey, sharedSecret };
-        }
+        return { ephemeralPublicKey, sharedSecret };
+      }
       case enums.publicKey.x448: {
         const x448 = await util.getNobleCurve(enums.publicKey.x448);
         const ephemeralSecretKey = x448.utils.randomPrivateKey();
@@ -9788,24 +9754,7 @@ var openpgp = (function (exports) {
   async function recomputeSharedSecret(algo, ephemeralPublicKey, A, k) {
     switch (algo) {
       case enums.publicKey.x25519:
-        try {
-          const webCrypto = util.getWebCrypto();
-          const privateKeyJWK = privateKeyToJWK(algo, A, k);
-          const ephemeralPublicKeyJWK = publicKeyToJWK(algo, ephemeralPublicKey);
-          const privateKey = await webCrypto.importKey('jwk', privateKeyJWK, 'X25519', false, ['deriveKey', 'deriveBits']);
-          const ephemeralPublicKeyReference = await webCrypto.importKey('jwk', ephemeralPublicKeyJWK, 'X25519', false, []);
-          const sharedSecretBuffer = await webCrypto.deriveBits(
-            { name: 'X25519', public: ephemeralPublicKeyReference },
-            privateKey,
-            getPayloadSize(algo) * 8 // in bits
-          );
-          return new Uint8Array(sharedSecretBuffer);
-        } catch (err) {
-          if (err.name !== 'NotSupportedError') {
-            throw err;
-          }
-          return nacl.scalarMult(k, ephemeralPublicKey);
-        }
+        return nacl.scalarMult(k, ephemeralPublicKey);
       case enums.publicKey.x448: {
         const x448 = await util.getNobleCurve(enums.publicKey.x448);
         const sharedSecret = x448.getSharedSecret(k, ephemeralPublicKey);
@@ -9816,35 +9765,6 @@ var openpgp = (function (exports) {
     }
   }
 
-
-  function publicKeyToJWK(algo, publicKey) {
-    switch (algo) {
-      case enums.publicKey.x25519: {
-        const jwk = {
-          kty: 'OKP',
-          crv: 'X25519',
-          x: uint8ArrayToB64(publicKey),
-          ext: true
-        };
-        return jwk;
-      }
-      default:
-        throw new Error('Unsupported ECDH algorithm');
-    }
-  }
-
-  function privateKeyToJWK(algo, publicKey, privateKey) {
-    switch (algo) {
-      case enums.publicKey.x25519: {
-        const jwk = publicKeyToJWK(algo, publicKey);
-        jwk.d = uint8ArrayToB64(privateKey);
-        return jwk;
-      }
-      default:
-        throw new Error('Unsupported ECDH algorithm');
-    }
-  }
-
   var ecdh_x = /*#__PURE__*/Object.freeze({
     __proto__: null,
     decrypt: decrypt$2,
@@ -12545,13 +12465,25 @@ var openpgp = (function (exports) {
       const { passes, parallelism, memoryExponent } = config$1.s2kArgon2Params;
 
       this.type = 'argon2';
-      /**  @type {Uint8Array} 16 bytes of salt */
+      /**
+       * 16 bytes of salt
+       * @type {Uint8Array}
+       */
       this.salt = null;
-      /** @type {Integer} number of passes */
+      /**
+       * number of passes
+       * @type {Integer}
+       */
       this.t = passes;
-      /** @type {Integer} degree of parallelism (lanes) */
+      /**
+       * degree of parallelism (lanes)
+       * @type {Integer}
+       */
       this.p = parallelism;
-      /** @type {Integer} exponent indicating memory size */
+      /**
+       * exponent indicating memory size
+       * @type {Integer}
+       */
       this.encodedM = memoryExponent;
     }