@noble/curves 1.9.7 → 2.0.0-beta.2

package/src/abstract/montgomery.ts

@@ -6,23 +6,23 @@
  */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import {
-  _validateObject,
   abytes,
   aInRange,
   bytesToNumberLE,
-  ensureBytes,
+  copyBytes,
   numberToBytesLE,
   randomBytes,
+  validateObject,
+  type CryptoKeys,
 } from '../utils.ts';
-import type { CurveLengths } from './curve.ts';
+import { createKeygen, type CurveLengths } from './curve.ts';
 import { mod } from './modular.ts';
 
 const _0n = BigInt(0);
 const _1n = BigInt(1);
 const _2n = BigInt(2);
-type Hex = string | Uint8Array;
 
-export type CurveType = {
+export type MontgomeryOpts = {
   P: bigint; // finite field prime
   type: 'x25519' | 'x448';
   adjustScalarBytes: (bytes: Uint8Array) => Uint8Array;
@@ -31,30 +31,27 @@ export type CurveType = {
 };
 
 export type MontgomeryECDH = {
-  scalarMult: (scalar: Hex, u: Hex) => Uint8Array;
-  scalarMultBase: (scalar: Hex) => Uint8Array;
-  getSharedSecret: (secretKeyA: Hex, publicKeyB: Hex) => Uint8Array;
-  getPublicKey: (secretKey: Hex) => Uint8Array;
+  scalarMult: (scalar: Uint8Array, u: Uint8Array) => Uint8Array;
+  scalarMultBase: (scalar: Uint8Array) => Uint8Array;
+  getSharedSecret: (secretKeyA: Uint8Array, publicKeyB: Uint8Array) => Uint8Array;
+  getPublicKey: (secretKey: Uint8Array) => Uint8Array;
   utils: {
     randomSecretKey: () => Uint8Array;
-    /** @deprecated use `randomSecretKey` */
-    randomPrivateKey: () => Uint8Array;
   };
   GuBytes: Uint8Array;
   lengths: CurveLengths;
   keygen: (seed?: Uint8Array) => { secretKey: Uint8Array; publicKey: Uint8Array };
 };
-export type CurveFn = MontgomeryECDH;
 
-function validateOpts(curve: CurveType) {
-  _validateObject(curve, {
+function validateOpts(curve: MontgomeryOpts) {
+  validateObject(curve, {
     adjustScalarBytes: 'function',
     powPminus2: 'function',
   });
   return Object.freeze({ ...curve } as const);
 }
 
-export function montgomery(curveDef: CurveType): MontgomeryECDH {
+export function montgomery(curveDef: MontgomeryOpts): MontgomeryECDH {
   const CURVE = validateOpts(curveDef);
   const { P, type, adjustScalarBytes, powPminus2, randomBytes: rand } = CURVE;
   const is25519 = type === 'x25519';
@@ -82,8 +79,8 @@ export function montgomery(curveDef: CurveType): MontgomeryECDH {
   function encodeU(u: bigint): Uint8Array {
     return numberToBytesLE(modP(u), fieldLen);
   }
-  function decodeU(u: Hex): bigint {
-    const _u = ensureBytes('u coordinate', u, fieldLen);
+  function decodeU(u: Uint8Array): bigint {
+    const _u = copyBytes(abytes(u, fieldLen, 'uCoordinate'));
     // RFC: When receiving such an array, implementations of X25519
     // (but not X448) MUST mask the most significant bit in the final byte.
     if (is25519) _u[31] &= 127; // 0b0111_1111
@@ -93,10 +90,10 @@ export function montgomery(curveDef: CurveType): MontgomeryECDH {
     // - 1 through 2^448 - 1 for X448.
     return modP(bytesToNumberLE(_u));
   }
-  function decodeScalar(scalar: Hex): bigint {
-    return bytesToNumberLE(adjustScalarBytes(ensureBytes('scalar', scalar, fieldLen)));
+  function decodeScalar(scalar: Uint8Array): bigint {
+    return bytesToNumberLE(adjustScalarBytes(copyBytes(abytes(scalar, fieldLen, 'scalar'))));
   }
-  function scalarMult(scalar: Hex, u: Hex): Uint8Array {
+  function scalarMult(scalar: Uint8Array, u: Uint8Array): Uint8Array {
     const pu = montgomeryLadder(decodeU(u), decodeScalar(scalar));
     // Some public keys are useless, of low-order. Curve author doesn't think
     // it needs to be validated, but we do it nonetheless.
@@ -105,9 +102,11 @@ export function montgomery(curveDef: CurveType): MontgomeryECDH {
     return encodeU(pu);
   }
   // Computes public key from private. By doing scalar multiplication of base point.
-  function scalarMultBase(scalar: Hex): Uint8Array {
+  function scalarMultBase(scalar: Uint8Array): Uint8Array {
     return scalarMult(scalar, GuBytes);
   }
+  const getPublicKey = scalarMultBase;
+  const getSharedSecret = scalarMult;
 
   // cswap from RFC7748 "example code"
   function cswap(swap: bigint, x_2: bigint, x_3: bigint): { x_2: bigint; x_3: bigint } {
@@ -170,25 +169,19 @@ export function montgomery(curveDef: CurveType): MontgomeryECDH {
     seed: fieldLen,
   };
   const randomSecretKey = (seed = randomBytes_(fieldLen)) => {
-    abytes(seed, lengths.seed);
+    abytes(seed, lengths.seed, 'seed');
     return seed;
   };
-  function keygen(seed?: Uint8Array) {
-    const secretKey = randomSecretKey(seed);
-    return { secretKey, publicKey: scalarMultBase(secretKey) };
-  }
-  const utils = {
-    randomSecretKey,
-    randomPrivateKey: randomSecretKey,
-  };
-  return {
-    keygen,
-    getSharedSecret: (secretKey: Hex, publicKey: Hex) => scalarMult(secretKey, publicKey),
-    getPublicKey: (secretKey: Hex): Uint8Array => scalarMultBase(secretKey),
+  const utils = { randomSecretKey };
+
+  return Object.freeze({
+    keygen: createKeygen(randomSecretKey, getPublicKey),
+    getSharedSecret,
+    getPublicKey,
     scalarMult,
     scalarMultBase,
     utils,
     GuBytes: GuBytes.slice(),
     lengths,
-  };
+  }) satisfies CryptoKeys;
 }