@ohos-ports/crypto 0.0.0-stage → 0.3.1-beta.1

package/dist/noble/abstract/modular.js

@@ -0,0 +1,455 @@
+"use strict";
+/*
+THIS IMPLEMENTATION WAS TAKEN FROM `@noble/hashes`
+
+original source: https://github.com/paulmillr/noble-curves/blob/38a4ca1e6b0a80c60b11bbb6b3d71e3bfabd5bbb/src/abstract/modular.ts
+
+it was modified and adapted to this repository
+
+the main reason for copying over and not using as dependency is because of different target in the `tsconfig.json`
+
+`@noble/hashes` targets es2020, which tends to cause problems with some other (older) packages sometimes
+
+this repo targets ES5+
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapHashToField = exports.getMinHashLength = exports.getFieldBytesLength = exports.hashToPrivateScalar = exports.FpSqrtEven = exports.FpSqrtOdd = exports.Field = exports.nLength = exports.FpIsSquare = exports.FpDiv = exports.FpInvertBatch = exports.FpPow = exports.validateField = exports.isNegativeLE = exports.FpSqrt = exports.tonelliShanks = exports.invert = exports.pow2 = exports.pow = exports.mod = void 0;
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// Utilities for modular arithmetics and finite fields
+var utils_1 = require("./utils.js");
+// prettier-ignore
+var _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);
+// prettier-ignore
+var _4n = BigInt(4), _5n = BigInt(5), _8n = BigInt(8);
+// prettier-ignore
+var _9n = BigInt(9), _16n = BigInt(16);
+// Calculates a modulo b
+function mod(a, b) {
+    var result = a % b;
+    return result >= _0n ? result : b + result;
+}
+exports.mod = mod;
+/**
+ * Efficiently raise num to power and do modular division.
+ * Unsafe in some contexts: uses ladder, so can expose bigint bits.
+ * @example
+ * pow(2n, 6n, 11n) // 64n % 11n == 9n
+ */
+// TODO: use field version && remove
+function pow(num, power, modulo) {
+    if (modulo <= _0n || power < _0n)
+        throw new Error('Expected power/modulo > 0');
+    if (modulo === _1n)
+        return _0n;
+    var res = _1n;
+    while (power > _0n) {
+        if (power & _1n)
+            res = (res * num) % modulo;
+        num = (num * num) % modulo;
+        power >>= _1n;
+    }
+    return res;
+}
+exports.pow = pow;
+// Does x ^ (2 ^ power) mod p. pow2(30, 4) == 30 ^ (2 ^ 4)
+function pow2(x, power, modulo) {
+    var res = x;
+    while (power-- > _0n) {
+        res *= res;
+        res %= modulo;
+    }
+    return res;
+}
+exports.pow2 = pow2;
+// Inverses number over modulo
+function invert(number, modulo) {
+    if (number === _0n || modulo <= _0n) {
+        throw new Error("invert: expected positive integers, got n=".concat(number, " mod=").concat(modulo));
+    }
+    // Euclidean GCD https://brilliant.org/wiki/extended-euclidean-algorithm/
+    // Fermat's little theorem "CT-like" version inv(n) = n^(m-2) mod m is 30x slower.
+    var a = mod(number, modulo);
+    var b = modulo;
+    // prettier-ignore
+    var x = _0n, y = _1n, u = _1n, v = _0n;
+    while (a !== _0n) {
+        // JIT applies optimization if those two lines follow each other
+        var q = b / a;
+        var r = b % a;
+        var m = x - u * q;
+        var n = y - v * q;
+        // prettier-ignore
+        b = a, a = r, x = u, y = v, u = m, v = n;
+    }
+    var gcd = b;
+    if (gcd !== _1n)
+        throw new Error('invert: does not exist');
+    return mod(x, modulo);
+}
+exports.invert = invert;
+/**
+ * Tonelli-Shanks square root search algorithm.
+ * 1. https://eprint.iacr.org/2012/685.pdf (page 12)
+ * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks
+ * Will start an infinite loop if field order P is not prime.
+ * @param P field order
+ * @returns function that takes field Fp (created from P) and number n
+ */
+function tonelliShanks(P) {
+    // Legendre constant: used to calculate Legendre symbol (a | p),
+    // which denotes the value of a^((p-1)/2) (mod p).
+    // (a | p) ≡ 1    if a is a square (mod p)
+    // (a | p) ≡ -1   if a is not a square (mod p)
+    // (a | p) ≡ 0    if a ≡ 0 (mod p)
+    var legendreC = (P - _1n) / _2n;
+    var Q, S, Z;
+    // Step 1: By factoring out powers of 2 from p - 1,
+    // find q and s such that p - 1 = q*(2^s) with q odd
+    for (Q = P - _1n, S = 0; Q % _2n === _0n; Q /= _2n, S++)
+        ;
+    // Step 2: Select a non-square z such that (z | p) ≡ -1 and set c ≡ zq
+    for (Z = _2n; Z < P && pow(Z, legendreC, P) !== P - _1n; Z++)
+        ;
+    // Fast-path
+    if (S === 1) {
+        var p1div4_1 = (P + _1n) / _4n;
+        return function tonelliFast(Fp, n) {
+            var root = Fp.pow(n, p1div4_1);
+            if (!Fp.eql(Fp.sqr(root), n))
+                throw new Error('Cannot find square root');
+            return root;
+        };
+    }
+    // Slow-path
+    var Q1div2 = (Q + _1n) / _2n;
+    return function tonelliSlow(Fp, n) {
+        // Step 0: Check that n is indeed a square: (n | p) should not be ≡ -1
+        if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))
+            throw new Error('Cannot find square root');
+        var r = S;
+        // TODO: will fail at Fp2/etc
+        var g = Fp.pow(Fp.mul(Fp.ONE, Z), Q); // will update both x and b
+        var x = Fp.pow(n, Q1div2); // first guess at the square root
+        var b = Fp.pow(n, Q); // first guess at the fudge factor
+        while (!Fp.eql(b, Fp.ONE)) {
+            if (Fp.eql(b, Fp.ZERO))
+                return Fp.ZERO; // https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm (4. If t = 0, return r = 0)
+            // Find m such b^(2^m)==1
+            var m = 1;
+            for (var t2 = Fp.sqr(b); m < r; m++) {
+                if (Fp.eql(t2, Fp.ONE))
+                    break;
+                t2 = Fp.sqr(t2); // t2 *= t2
+            }
+            // NOTE: r-m-1 can be bigger than 32, need to convert to bigint before shift, otherwise there will be overflow
+            var ge = Fp.pow(g, _1n << BigInt(r - m - 1)); // ge = 2^(r-m-1)
+            g = Fp.sqr(ge); // g = ge * ge
+            x = Fp.mul(x, ge); // x *= ge
+            b = Fp.mul(b, g); // b *= g
+            r = m;
+        }
+        return x;
+    };
+}
+exports.tonelliShanks = tonelliShanks;
+function FpSqrt(P) {
+    // NOTE: different algorithms can give different roots, it is up to user to decide which one they want.
+    // For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).
+    // P ≡ 3 (mod 4)
+    // √n = n^((P+1)/4)
+    if (P % _4n === _3n) {
+        // Not all roots possible!
+        // const ORDER =
+        //   0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn;
+        // const NUM = 72057594037927816n;
+        var p1div4_2 = (P + _1n) / _4n;
+        return function sqrt3mod4(Fp, n) {
+            var root = Fp.pow(n, p1div4_2);
+            // Throw if root**2 != n
+            if (!Fp.eql(Fp.sqr(root), n))
+                throw new Error('Cannot find square root');
+            return root;
+        };
+    }
+    // Atkin algorithm for q ≡ 5 (mod 8), https://eprint.iacr.org/2012/685.pdf (page 10)
+    if (P % _8n === _5n) {
+        var c1_1 = (P - _5n) / _8n;
+        return function sqrt5mod8(Fp, n) {
+            var n2 = Fp.mul(n, _2n);
+            var v = Fp.pow(n2, c1_1);
+            var nv = Fp.mul(n, v);
+            var i = Fp.mul(Fp.mul(nv, _2n), v);
+            var root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
+            if (!Fp.eql(Fp.sqr(root), n))
+                throw new Error('Cannot find square root');
+            return root;
+        };
+    }
+    // P ≡ 9 (mod 16)
+    if (P % _16n === _9n) {
+        // NOTE: tonelli is too slow for bls-Fp2 calculations even on start
+        // Means we cannot use sqrt for constants at all!
+        //
+        // const c1 = Fp.sqrt(Fp.negate(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F
+        // const c2 = Fp.sqrt(c1);                //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F
+        // const c3 = Fp.sqrt(Fp.negate(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F
+        // const c4 = (P + _7n) / _16n;           //  4. c4 = (q + 7) / 16        # Integer arithmetic
+        // sqrt = (x) => {
+        //   let tv1 = Fp.pow(x, c4);             //  1. tv1 = x^c4
+        //   let tv2 = Fp.mul(c1, tv1);           //  2. tv2 = c1 * tv1
+        //   const tv3 = Fp.mul(c2, tv1);         //  3. tv3 = c2 * tv1
+        //   let tv4 = Fp.mul(c3, tv1);           //  4. tv4 = c3 * tv1
+        //   const e1 = Fp.equals(Fp.square(tv2), x); //  5.  e1 = (tv2^2) == x
+        //   const e2 = Fp.equals(Fp.square(tv3), x); //  6.  e2 = (tv3^2) == x
+        //   tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x
+        //   tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x
+        //   const e3 = Fp.equals(Fp.square(tv2), x); //  9.  e3 = (tv2^2) == x
+        //   return Fp.cmov(tv1, tv2, e3); //  10.  z = CMOV(tv1, tv2, e3)  # Select the sqrt from tv1 and tv2
+        // }
+    }
+    // Other cases: Tonelli-Shanks algorithm
+    return tonelliShanks(P);
+}
+exports.FpSqrt = FpSqrt;
+// Little-endian check for first LE bit (last BE bit);
+var isNegativeLE = function (num, modulo) { return (mod(num, modulo) & _1n) === _1n; };
+exports.isNegativeLE = isNegativeLE;
+// prettier-ignore
+var FIELD_FIELDS = [
+    'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',
+    'eql', 'add', 'sub', 'mul', 'pow', 'div',
+    'addN', 'subN', 'mulN', 'sqrN'
+];
+function validateField(field) {
+    var initial = {
+        ORDER: 'bigint',
+        MASK: 'bigint',
+        BYTES: 'isSafeInteger',
+        BITS: 'isSafeInteger',
+    };
+    var opts = FIELD_FIELDS.reduce(function (map, val) {
+        map[val] = 'function';
+        return map;
+    }, initial);
+    return (0, utils_1.validateObject)(field, opts);
+}
+exports.validateField = validateField;
+// Generic field functions
+/**
+ * Same as `pow` but for Fp: non-constant-time.
+ * Unsafe in some contexts: uses ladder, so can expose bigint bits.
+ */
+function FpPow(f, num, power) {
+    // Should have same speed as pow for bigints
+    // TODO: benchmark!
+    if (power < _0n)
+        throw new Error('Expected power > 0');
+    if (power === _0n)
+        return f.ONE;
+    if (power === _1n)
+        return num;
+    var p = f.ONE;
+    var d = num;
+    while (power > _0n) {
+        if (power & _1n)
+            p = f.mul(p, d);
+        d = f.sqr(d);
+        power >>= _1n;
+    }
+    return p;
+}
+exports.FpPow = FpPow;
+/**
+ * Efficiently invert an array of Field elements.
+ * `inv(0)` will return `undefined` here: make sure to throw an error.
+ */
+function FpInvertBatch(f, nums) {
+    var tmp = new Array(nums.length);
+    // Walk from first to last, multiply them by each other MOD p
+    var lastMultiplied = nums.reduce(function (acc, num, i) {
+        if (f.is0(num))
+            return acc;
+        tmp[i] = acc;
+        return f.mul(acc, num);
+    }, f.ONE);
+    // Invert last element
+    var inverted = f.inv(lastMultiplied);
+    // Walk from last to first, multiply them by inverted each other MOD p
+    nums.reduceRight(function (acc, num, i) {
+        if (f.is0(num))
+            return acc;
+        tmp[i] = f.mul(acc, tmp[i]);
+        return f.mul(acc, num);
+    }, inverted);
+    return tmp;
+}
+exports.FpInvertBatch = FpInvertBatch;
+function FpDiv(f, lhs, rhs) {
+    return f.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, f.ORDER) : f.inv(rhs));
+}
+exports.FpDiv = FpDiv;
+// This function returns True whenever the value x is a square in the field F.
+function FpIsSquare(f) {
+    var legendreConst = (f.ORDER - _1n) / _2n; // Integer arithmetic
+    return function (x) {
+        var p = f.pow(x, legendreConst);
+        return f.eql(p, f.ZERO) || f.eql(p, f.ONE);
+    };
+}
+exports.FpIsSquare = FpIsSquare;
+// CURVE.n lengths
+function nLength(n, nBitLength) {
+    // Bit size, byte size of CURVE.n
+    var _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;
+    var nByteLength = Math.ceil(_nBitLength / 8);
+    return { nBitLength: _nBitLength, nByteLength: nByteLength };
+}
+exports.nLength = nLength;
+/**
+ * Initializes a finite field over prime. **Non-primes are not supported.**
+ * Do not init in loop: slow. Very fragile: always run a benchmark on a change.
+ * Major performance optimizations:
+ * * a) denormalized operations like mulN instead of mul
+ * * b) same object shape: never add or remove keys
+ * * c) Object.freeze
+ * @param ORDER prime positive bigint
+ * @param bitLen how many bits the field consumes
+ * @param isLE (def: false) if encoding / decoding should be in little-endian
+ * @param redef optional faster redefinitions of sqrt and other methods
+ */
+function Field(ORDER, bitLen, isLE, redef) {
+    if (isLE === void 0) { isLE = false; }
+    if (redef === void 0) { redef = {}; }
+    if (ORDER <= _0n)
+        throw new Error("Expected Field ORDER > 0, got ".concat(ORDER));
+    var _a = nLength(ORDER, bitLen), BITS = _a.nBitLength, BYTES = _a.nByteLength;
+    if (BYTES > 2048)
+        throw new Error('Field lengths over 2048 bytes are not supported');
+    var sqrtP = FpSqrt(ORDER);
+    var f = Object.freeze({
+        ORDER: ORDER,
+        BITS: BITS,
+        BYTES: BYTES,
+        MASK: (0, utils_1.bitMask)(BITS),
+        ZERO: _0n,
+        ONE: _1n,
+        create: function (num) { return mod(num, ORDER); },
+        isValid: function (num) {
+            if (typeof num !== 'bigint')
+                throw new Error("Invalid field element: expected bigint, got ".concat(typeof num));
+            return _0n <= num && num < ORDER; // 0 is valid element, but it's not invertible
+        },
+        is0: function (num) { return num === _0n; },
+        isOdd: function (num) { return (num & _1n) === _1n; },
+        neg: function (num) { return mod(-num, ORDER); },
+        eql: function (lhs, rhs) { return lhs === rhs; },
+        sqr: function (num) { return mod(num * num, ORDER); },
+        add: function (lhs, rhs) { return mod(lhs + rhs, ORDER); },
+        sub: function (lhs, rhs) { return mod(lhs - rhs, ORDER); },
+        mul: function (lhs, rhs) { return mod(lhs * rhs, ORDER); },
+        pow: function (num, power) { return FpPow(f, num, power); },
+        div: function (lhs, rhs) { return mod(lhs * invert(rhs, ORDER), ORDER); },
+        // Same as above, but doesn't normalize
+        sqrN: function (num) { return num * num; },
+        addN: function (lhs, rhs) { return lhs + rhs; },
+        subN: function (lhs, rhs) { return lhs - rhs; },
+        mulN: function (lhs, rhs) { return lhs * rhs; },
+        inv: function (num) { return invert(num, ORDER); },
+        sqrt: redef.sqrt || (function (n) { return sqrtP(f, n); }),
+        invertBatch: function (lst) { return FpInvertBatch(f, lst); },
+        // TODO: do we really need constant cmov?
+        // We don't have const-time bigints anyway, so probably will be not very useful
+        cmov: function (a, b, c) { return (c ? b : a); },
+        toBytes: function (num) { return (isLE ? (0, utils_1.numberToBytesLE)(num, BYTES) : (0, utils_1.numberToBytesBE)(num, BYTES)); },
+        fromBytes: function (bytes) {
+            if (bytes.length !== BYTES)
+                throw new Error("Fp.fromBytes: expected ".concat(BYTES, ", got ").concat(bytes.length));
+            return isLE ? (0, utils_1.bytesToNumberLE)(bytes) : (0, utils_1.bytesToNumberBE)(bytes);
+        },
+    });
+    return Object.freeze(f);
+}
+exports.Field = Field;
+function FpSqrtOdd(Fp, elm) {
+    if (!Fp.isOdd)
+        throw new Error("Field doesn't have isOdd");
+    var root = Fp.sqrt(elm);
+    return Fp.isOdd(root) ? root : Fp.neg(root);
+}
+exports.FpSqrtOdd = FpSqrtOdd;
+function FpSqrtEven(Fp, elm) {
+    if (!Fp.isOdd)
+        throw new Error("Field doesn't have isOdd");
+    var root = Fp.sqrt(elm);
+    return Fp.isOdd(root) ? Fp.neg(root) : root;
+}
+exports.FpSqrtEven = FpSqrtEven;
+/**
+ * "Constant-time" private key generation utility.
+ * Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).
+ * Which makes it slightly more biased, less secure.
+ * @deprecated use mapKeyToField instead
+ */
+function hashToPrivateScalar(hash, groupOrder, isLE) {
+    if (isLE === void 0) { isLE = false; }
+    hash = (0, utils_1.ensureBytes)('privateHash', hash);
+    var hashLen = hash.length;
+    var minLen = nLength(groupOrder).nByteLength + 8;
+    if (minLen < 24 || hashLen < minLen || hashLen > 1024)
+        throw new Error("hashToPrivateScalar: expected ".concat(minLen, "-1024 bytes of input, got ").concat(hashLen));
+    var num = isLE ? (0, utils_1.bytesToNumberLE)(hash) : (0, utils_1.bytesToNumberBE)(hash);
+    return mod(num, groupOrder - _1n) + _1n;
+}
+exports.hashToPrivateScalar = hashToPrivateScalar;
+/**
+ * Returns total number of bytes consumed by the field element.
+ * For example, 32 bytes for usual 256-bit weierstrass curve.
+ * @param fieldOrder number of field elements, usually CURVE.n
+ * @returns byte length of field
+ */
+function getFieldBytesLength(fieldOrder) {
+    if (typeof fieldOrder !== 'bigint')
+        throw new Error('field order must be bigint');
+    var bitLength = fieldOrder.toString(2).length;
+    return Math.ceil(bitLength / 8);
+}
+exports.getFieldBytesLength = getFieldBytesLength;
+/**
+ * Returns minimal amount of bytes that can be safely reduced
+ * by field order.
+ * Should be 2^-128 for 128-bit curve such as P256.
+ * @param fieldOrder number of field elements, usually CURVE.n
+ * @returns byte length of target hash
+ */
+function getMinHashLength(fieldOrder) {
+    var length = getFieldBytesLength(fieldOrder);
+    return length + Math.ceil(length / 2);
+}
+exports.getMinHashLength = getMinHashLength;
+/**
+ * "Constant-time" private key generation utility.
+ * Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF
+ * and convert them into private scalar, with the modulo bias being negligible.
+ * Needs at least 48 bytes of input for 32-byte private key.
+ * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/
+ * FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final
+ * RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5
+ * @param hash hash output from SHA3 or a similar function
+ * @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)
+ * @param isLE interpret hash bytes as LE num
+ * @returns valid private scalar
+ */
+function mapHashToField(key, fieldOrder, isLE) {
+    if (isLE === void 0) { isLE = false; }
+    var len = key.length;
+    var fieldLen = getFieldBytesLength(fieldOrder);
+    var minLen = getMinHashLength(fieldOrder);
+    // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.
+    if (len < 16 || len < minLen || len > 1024)
+        throw new Error("expected ".concat(minLen, "-1024 bytes of input, got ").concat(len));
+    var num = isLE ? (0, utils_1.bytesToNumberBE)(key) : (0, utils_1.bytesToNumberLE)(key);
+    // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0
+    var reduced = mod(num, fieldOrder - _1n) + _1n;
+    return isLE ? (0, utils_1.numberToBytesLE)(reduced, fieldLen) : (0, utils_1.numberToBytesBE)(reduced, fieldLen);
+}
+exports.mapHashToField = mapHashToField;

package/dist/noble/abstract/montgomery.d.ts

@@ -0,0 +1,28 @@
+type Hex = string | Uint8Array;
+export type CurveType = {
+    P: bigint;
+    nByteLength: number;
+    adjustScalarBytes?: (bytes: Uint8Array) => Uint8Array;
+    domain?: (data: Uint8Array, ctx: Uint8Array, phflag: boolean) => Uint8Array;
+    a: bigint;
+    montgomeryBits: number;
+    powPminus2?: (x: bigint) => bigint;
+    xyToU?: (x: bigint, y: bigint) => bigint;
+    Gu: bigint;
+    randomBytes?: (bytesLength?: number) => Uint8Array;
+};
+export type CurveFn = {
+    scalarMult: (scalar: Hex, u: Hex) => Uint8Array;
+    scalarMultBase: (scalar: Hex) => Uint8Array;
+    getSharedSecret: (privateKeyA: Hex, publicKeyB: Hex) => Uint8Array;
+    getPublicKey: (privateKey: Hex) => Uint8Array;
+    utils: {
+        randomPrivateKey: () => Uint8Array;
+    };
+    GuBytes: Uint8Array;
+};
+export type InternalCurveFn = CurveFn & {
+    encodeUCoordinate: (u: bigint) => Uint8Array;
+};
+export declare function montgomery(curveDef: CurveType): InternalCurveFn;
+export {};

package/dist/noble/abstract/montgomery.js

@@ -0,0 +1,172 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.montgomery = void 0;
+/**
+ * Montgomery curve methods. It's not really whole montgomery curve,
+ * just bunch of very specific methods for X25519 / X448 from
+ * [RFC 7748](https://www.rfc-editor.org/rfc/rfc7748)
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var modular_js_1 = require("./modular.js");
+var utils_1 = require("./utils.js");
+var _0n = BigInt(0);
+var _1n = BigInt(1);
+function validateOpts(curve) {
+    (0, utils_1.validateObject)(curve, {
+        a: 'bigint',
+    }, {
+        montgomeryBits: 'isSafeInteger',
+        nByteLength: 'isSafeInteger',
+        adjustScalarBytes: 'function',
+        domain: 'function',
+        powPminus2: 'function',
+        Gu: 'bigint',
+    });
+    // Set defaults
+    return Object.freeze(__assign({}, curve));
+}
+// Uses only one coordinate instead of two
+function montgomery(curveDef) {
+    var CURVE = validateOpts(curveDef);
+    var P = CURVE.P;
+    var modP = function (n) { return (0, modular_js_1.mod)(n, P); };
+    var montgomeryBits = CURVE.montgomeryBits;
+    var montgomeryBytes = Math.ceil(montgomeryBits / 8);
+    var fieldLen = CURVE.nByteLength;
+    var adjustScalarBytes = CURVE.adjustScalarBytes || (function (bytes) { return bytes; });
+    var powPminus2 = CURVE.powPminus2 || (function (x) { return (0, modular_js_1.pow)(x, P - BigInt(2), P); });
+    // cswap from RFC7748. But it is not from RFC7748!
+    /*
+      cswap(swap, x_2, x_3):
+           dummy = mask(swap) AND (x_2 XOR x_3)
+           x_2 = x_2 XOR dummy
+           x_3 = x_3 XOR dummy
+           Return (x_2, x_3)
+    Where mask(swap) is the all-1 or all-0 word of the same length as x_2
+     and x_3, computed, e.g., as mask(swap) = 0 - swap.
+    */
+    function cswap(swap, x_2, x_3) {
+        var dummy = modP(swap * (x_2 - x_3));
+        x_2 = modP(x_2 - dummy);
+        x_3 = modP(x_3 + dummy);
+        return [x_2, x_3];
+    }
+    // x25519 from 4
+    // The constant a24 is (486662 - 2) / 4 = 121665 for curve25519/X25519
+    var a24 = (CURVE.a - BigInt(2)) / BigInt(4);
+    /**
+     *
+     * @param pointU u coordinate (x) on Montgomery Curve 25519
+     * @param scalar by which the point would be multiplied
+     * @returns new Point on Montgomery curve
+     */
+    function montgomeryLadder(u, scalar) {
+        (0, utils_1.aInRange)('u', u, _0n, P);
+        (0, utils_1.aInRange)('scalar', scalar, _0n, P);
+        // Section 5: Implementations MUST accept non-canonical values and process them as
+        // if they had been reduced modulo the field prime.
+        var k = scalar;
+        var x_1 = u;
+        var x_2 = _1n;
+        var z_2 = _0n;
+        var x_3 = u;
+        var z_3 = _1n;
+        var swap = _0n;
+        var sw;
+        for (var t = BigInt(montgomeryBits - 1); t >= _0n; t--) {
+            var k_t = (k >> t) & _1n;
+            swap ^= k_t;
+            sw = cswap(swap, x_2, x_3);
+            x_2 = sw[0];
+            x_3 = sw[1];
+            sw = cswap(swap, z_2, z_3);
+            z_2 = sw[0];
+            z_3 = sw[1];
+            swap = k_t;
+            var A = x_2 + z_2;
+            var AA = modP(A * A);
+            var B = x_2 - z_2;
+            var BB = modP(B * B);
+            var E = AA - BB;
+            var C = x_3 + z_3;
+            var D = x_3 - z_3;
+            var DA = modP(D * A);
+            var CB = modP(C * B);
+            var dacb = DA + CB;
+            var da_cb = DA - CB;
+            x_3 = modP(dacb * dacb);
+            z_3 = modP(x_1 * modP(da_cb * da_cb));
+            x_2 = modP(AA * BB);
+            z_2 = modP(E * (AA + modP(a24 * E)));
+        }
+        // (x_2, x_3) = cswap(swap, x_2, x_3)
+        sw = cswap(swap, x_2, x_3);
+        x_2 = sw[0];
+        x_3 = sw[1];
+        // (z_2, z_3) = cswap(swap, z_2, z_3)
+        sw = cswap(swap, z_2, z_3);
+        z_2 = sw[0];
+        z_3 = sw[1];
+        // z_2^(p - 2)
+        var z2 = powPminus2(z_2);
+        // Return x_2 * (z_2^(p - 2))
+        return modP(x_2 * z2);
+    }
+    function encodeUCoordinate(u) {
+        return (0, utils_1.numberToBytesLE)(modP(u), montgomeryBytes);
+    }
+    function decodeUCoordinate(uEnc) {
+        // Section 5: When receiving such an array, implementations of X25519
+        // MUST mask the most significant bit in the final byte.
+        var u = (0, utils_1.ensureBytes)('u coordinate', uEnc, montgomeryBytes);
+        if (fieldLen === 32)
+            u[31] &= 127; // 0b0111_1111
+        return (0, utils_1.bytesToNumberLE)(u);
+    }
+    function decodeScalar(n) {
+        var bytes = (0, utils_1.ensureBytes)('scalar', n);
+        var len = bytes.length;
+        if (len !== montgomeryBytes && len !== fieldLen) {
+            var valid = '' + montgomeryBytes + ' or ' + fieldLen;
+            throw new Error('invalid scalar, expected ' + valid + ' bytes, got ' + len);
+        }
+        return (0, utils_1.bytesToNumberLE)(adjustScalarBytes(bytes));
+    }
+    function scalarMult(scalar, u) {
+        var pointU = decodeUCoordinate(u);
+        var _scalar = decodeScalar(scalar);
+        var pu = montgomeryLadder(pointU, _scalar);
+        // The result was not contributory
+        // https://cr.yp.to/ecdh.html#validate
+        if (pu === _0n)
+            throw new Error('invalid private or public key received');
+        return encodeUCoordinate(pu);
+    }
+    // Computes public key from private. By doing scalar multiplication of base point.
+    var GuBytes = encodeUCoordinate(CURVE.Gu);
+    function scalarMultBase(scalar) {
+        return scalarMult(scalar, GuBytes);
+    }
+    return {
+        scalarMult: scalarMult,
+        scalarMultBase: scalarMultBase,
+        getSharedSecret: function (privateKey, publicKey) { return scalarMult(privateKey, publicKey); },
+        getPublicKey: function (privateKey) { return scalarMultBase(privateKey); },
+        utils: { randomPrivateKey: function () { return CURVE.randomBytes(CURVE.nByteLength); } },
+        GuBytes: GuBytes,
+        encodeUCoordinate: encodeUCoordinate
+    };
+}
+exports.montgomery = montgomery;