@arithmetic-operations-for/integers-modulo-n-big-endian/dist/index.cjs.map

Modular arithmetic for JavaScript

{"version":3,"file":"index.cjs","sources":["../src/_redc.js","../src/_mul.js","../src/_iadd.js","../src/_isub.js","../src/_montgomery.js","../src/modR.js","../src/modN.js","../src/Montgomery.js"],"sourcesContent":["import assert from 'assert';\nimport {\n\t_zeros as n_zeros,\n\t_copy as n_copy,\n\t_reset as n_reset,\n\t_cmp_n as n_cmp_n,\n\t_mul as n_mul,\n\t_iadd as n_iadd,\n\t_isub as n_isub,\n} from '@arithmetic-operations-for/naturals-big-endian';\n\n/**\n * Function REDC is\n *\n *  input: Integers R = b^k > N with gcd(R, N) = 1,\n *         Integer M in [0, R − 1] such that NM ≡ −1 mod R,\n *         Integer T in the range [0, RN − 1]\n *\n *         All numbers are given in base b (big endian order).\n *  output: Integer S in the range [0, N − 1] such that S ≡ TR−1 mod N\n *\n *  m ← ((T mod R)M) mod R // Can be implemented by discarding limbs\n *  t ← (T + mN) / R // Can be implemented with a shift\n *  // /!\\ T + mN is potentially RN - 1 + (R-1) N = 2RN - N - 1 so need one\n *  // extra limb for carry ?\n *  if t ≥ N then\n *   return t − N\n *  else\n *   return t // Can add dummy - zero vector here in case we want to avoid side\n *            // channel attacks\n *  end if\n * end function\n *\n */\nexport default function _redc(b, k, N, Ni, Nj, M, Mi, Mj, T, Ti, Tj) {\n\tassert(Nj - Ni === k, '|N| !== k');\n\tassert(Mj - Mi === k, '|M| !== k'); // Can allow |M| <= k here.\n\tassert(Tj - Ti === 2 * k + 1, '|T| !== 2*k+1');\n\tassert(T[Ti] === 0, 'T[Ti] !== 0');\n\n\t// Reduce T mod R\n\tconst _Ti = Tj - k;\n\tconst _2k = k << 1; // eslint-disable-line no-bitwise\n\n\tconst m = n_zeros(_2k);\n\tconst mj = _2k;\n\n\t// M = ((T mod R) M) mod R\n\tn_mul(b, T, _Ti, Tj, M, Mi, Mj, m, 0, mj);\n\t// Could be even more efficient here\n\t// if we had a multiplication method that discards higher order\n\t// bits\n\n\tconst mi = k; // M = m mod R\n\n\t// X = m * N\n\tconst X = n_zeros(_2k); // TODO mutualize allocation with m\n\tconst Xj = _2k;\n\tn_mul(b, m, mi, mj, N, Ni, Nj, X, 0, Xj);\n\n\t// T = T + X = T + mN\n\tn_iadd(b, T, Ti, Tj, X, 0, Xj);\n\n\t// T = T / R\n\tassert(T[Ti] === 0, 'T[Ti] !== 0');\n\tn_copy(T, Ti + 1, _Ti, T, _Ti);\n\t// Assert T[Ti] === 0\n\tconst _Ti_1 = _Ti;\n\t// T[_Ti_1] = T[Ti];\n\tn_reset(T, Ti, _Ti_1);\n\n\t// If t ≥ N then\n\tif (n_cmp_n(T, _Ti_1, Tj, N, Ni) >= 0) {\n\t\tn_isub(b, T, _Ti_1, Tj, N, Ni, Nj); // Return t − N\n\t\treturn true;\n\t}\n\n\treturn false;\n\t// Else return t\n}\n","import assert from 'assert';\nimport {_mul as n_mul} from '@arithmetic-operations-for/naturals-big-endian';\n\nimport _redc from './_redc.js';\n\n// TODO\n// mul by non montgomery ?\n// abR mod N = (aR mod N)(b mod N) MODULO????\n\n/**\n *\n * abR mod N = REDC((aR mod N)(bR mod N))\n *\n *\n * |N| >= |a| >= |b|\n * |c| = 2*|N| + 1\n * c = 0000.0000 is zero initialized\n *\n */\n\nexport default function _mul(r, N, M, a, b, c) {\n\tconst k = N.length;\n\tconst _2kp1 = 2 * k + 1;\n\n\tassert(a.length <= k, '|a| > |N|');\n\tassert(b.length <= a.length, '|b| > |a|');\n\tassert(c.length === _2kp1, '|c| !== 2*k+1');\n\n\t// C = (aR mod N)(bR mod N)\n\tn_mul(\n\t\tr,\n\t\ta,\n\t\t0,\n\t\ta.length,\n\t\tb,\n\t\t0,\n\t\tb.length,\n\t\tc,\n\t\t_2kp1 - a.length - b.length,\n\t\t_2kp1,\n\t);\n\n\t// C = REDC((aR mod N)(bR mod N))\n\treturn _redc(r, k, N, 0, k, M, 0, k, c, 0, _2kp1);\n}\n","import assert from 'assert';\nimport {\n\t_iadd as n_iadd,\n\t_isub as n_isub,\n\t_cmp as n_cmp,\n\t_cmp_n as n_cmp_n,\n} from '@arithmetic-operations-for/naturals-big-endian';\n\n/**\n *\n * @param {Number} r the radix\n * @param {Array} N number array of length k.\n * @param {Array} a\n * @param {Array} b\n *\n * (a+b)R mod N = aR mod N + bR mod N - ( 0/1 * N )\n *\n * R = r^k\n * N has no leading zeroes\n * N has length k\n * |N| = |a| >= |b|\n * |a| = |b| if you want to avoid side channel attacks\n * a < N\n * b < N\n *\n * t = a + b mod r^k\n * if t < b or t >= N then return t - N mod r^k\n * else return t // Can subtract dummy zero vector here in case we want\n *               // to avoid side channel attacks\n *\n */\nexport default function _iadd(r, N, a, b) {\n\tconst k = N.length;\n\n\tassert(k >= 1);\n\tassert(N[0] !== 0);\n\tassert(a.length === k, '|a| !== k');\n\tassert(b.length <= k, '|b| > k');\n\n\tn_iadd(r, a, 0, k, b, 0, b.length);\n\t// TODO  Use overflow bit.\n\t// const overflow = _iadd(r, a, 0, k, b, 0, b.length) ;\n\n\tif (\n\t\t// Overflow\n\t\tn_cmp(a, 0, k, b, 0, b.length) < 0 ||\n\t\tn_cmp_n(a, 0, k, N, 0) >= 0\n\t) {\n\t\tn_isub(r, a, 0, k, N, 0, k); // Exploits wrapping\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n","import assert from 'assert';\nimport {\n\t_iadd as n_iadd,\n\t_isub as n_isub,\n\t_cmp as n_cmp,\n} from '@arithmetic-operations-for/naturals-big-endian';\n\n/**\n *\n * @param {Number} r the radix\n * @param {Array} N number array of length k.\n * @param {Array} a\n * @param {Array} b\n *\n * (a+b)R mod N = aR mod N - bR mod N + ( 0/1 * N )\n *\n * R = r^k\n * N has no leading zeroes\n * N has length k\n * |N| = |a| >= |b|\n * |a| = |b| if you want to avoid side channel attacks\n * a < N\n * b < N\n *\n * t = a - b mod r^k\n * if a < b then return t + N mod r^k\n * else return t // Can add dummy zero vector here in case we want\n *               // to avoid side channel attacks\n *\n */\nexport default function _isub(r, N, a, b) {\n\tconst k = N.length;\n\n\tassert(k >= 1);\n\tassert(N[0] !== 0);\n\tassert(a.length === k, '|a| !== k');\n\tassert(b.length <= k, '|b| > k');\n\n\tconst underflow = n_cmp(a, 0, k, b, 0, b.length) < 0;\n\tn_isub(r, a, 0, k, b, 0, b.length);\n\t// TODO  Use underflow bit.\n\t// const underflow = n_isub(r, a, 0, k, b, 0, b.length) ;\n\tif (underflow) {\n\t\tn_iadd(r, a, 0, k, N, 0, k); // Exploits wrapping\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n","import assert from 'assert';\nimport {\n\t_alloc as n_alloc,\n\t_zeros as n_zeros,\n\t_copy as n_copy,\n\t_mul as n_mul,\n\t_idivmod as n_idivmod,\n\t_sub as n_sub,\n\t_extended_euclidean_algorithm as n_extended_euclidean_algorithm,\n} from '@arithmetic-operations-for/naturals-big-endian';\n\nimport _redc from './_redc.js';\n\n/**\n *\n * N has no leading zeroes\n *\n * @param {Number} b the radix\n * @param {Array} N number array of length k.\n *\n *\n *\n *\n */\nexport default function _montgomery(b, N) {\n\tassert(N.length > 0);\n\tassert(N[0] !== 0);\n\n\tconst k = N.length;\n\n\tconst _2kp1 = 2 * k + 1;\n\tconst _R = n_zeros(_2kp1);\n\t_R[k] = 1; // B^k\n\n\tconst [\n\t\tGCD,\n\t\tGCDi,\n\t\t// eslint-disable-next-line no-unused-vars\n\t\t_S,\n\t\t// eslint-disable-next-line no-unused-vars\n\t\t_Si,\n\t\t_M,\n\t\t// eslint-disable-next-line no-unused-vars\n\t\t_1,\n\t\t// eslint-disable-next-line no-unused-vars\n\t\t_2,\n\t\t// eslint-disable-next-line no-unused-vars\n\t\t_3,\n\t\t// eslint-disable-next-line no-unused-vars\n\t\t_4,\n\t\t// eslint-disable-next-line no-unused-vars\n\t\t_5,\n\t\tsteps,\n\t] = n_extended_euclidean_algorithm(b, _R, k, _2kp1, N, 0, k);\n\n\t// Assert that GCD(R,N) is 1.\n\tif (GCD.length - GCDi !== 1 || GCD[GCDi] !== 1)\n\t\tthrow new Error('Montgomery: GCD(R,N) is not 1.');\n\n\tconst M = n_alloc(k); // M mod R on k words\n\tif (steps % 2 === 0) {\n\t\t// We use _R[0:k] because it is filled with zeros.\n\t\tn_sub(b, _R, 0, k, _M, _M.length - k, _M.length, M, 0, k); // _M.length-k is always 1 ?\n\t} else {\n\t\tn_copy(_M, _M.length - k, _M.length, M, 0); // _M.length-k is always 1 ?\n\t}\n\n\t// R^2 mod N\n\tconst _R2 = n_zeros(_2kp1);\n\t_R2[0] = 1;\n\tn_idivmod(b, _R2, 0, _2kp1, N, 0, k, _R, 0, _2kp1); // Use mod only function once implemented\n\tconst R2 = n_alloc(k); // R^2 mod N on k words\n\tn_copy(_R2, k + 1, _2kp1, R2, 0);\n\n\t// Avoid using division for the computation of the other constants.\n\t// From Wikipedia:\n\t// Performing these operations requires knowing at least N′ and R2 mod N.\n\t// When R is a power of a small positive integer b, N′ can be computed by\n\t// Hensel's lemma: The inverse of N modulo b is computed by a naive\n\t// algorithm (for instance, if b = 2 then the inverse is 1), and Hensel's\n\t// lemma is used repeatedly to find the inverse modulo higher and higher\n\t// powers of b, stopping when the inverse modulo R is known; N′ is the\n\t// negation of this inverse. The constants R mod N and R3 mod N can be\n\t// generated as REDC(R2 mod N) and as REDC((R2 mod N)(R2 mod N)). The\n\t// fundamental operation is to compute REDC of a product. When standalone\n\t// REDC is needed, it can be computed as REDC of a product with 1 mod N. The\n\t// only place where a direct reduction modulo N is necessary is in the\n\t// precomputation of R2 mod N.\n\n\t// R mod N = REDC(R^2 mod N)\n\t_redc(b, k, N, 0, k, M, 0, k, _R2, 0, _2kp1);\n\tconst R = n_alloc(k); // R mod N on k words\n\tn_copy(_R2, k + 1, _2kp1, R, 0);\n\n\t// R^3 mod N = REDC((R^2 mod N)(R^2 mod N))\n\tconst _R3 = n_zeros(_2kp1);\n\tn_mul(b, R2, 0, k, R2, 0, k, _R3, 1, _2kp1);\n\t_redc(b, k, N, 0, k, M, 0, k, _R3, 0, _2kp1);\n\tconst R3 = n_alloc(k); // R^3 mod N on k words\n\tn_copy(_R3, k + 1, _2kp1, R3, 0);\n\n\t// Console.debug({b, N, k, M, R, R2, R3});\n\treturn {k, M, R, R2, R3};\n}\n","import assert from 'assert';\nimport {\n\t_alloc as n_alloc,\n\t_copy as n_copy,\n} from '@arithmetic-operations-for/naturals-big-endian';\n\n/**\n *\n * |x| >= k\n *\n */\nexport default function modR(k, x) {\n\tassert(x.length >= k, '|x| >= k');\n\n\tconst xmodR = n_alloc(k); // TODO Use UintXArray ?\n\tn_copy(x, x.length - k, x.length, xmodR, 0);\n\treturn xmodR;\n}\n","import {\n\t_alloc as n_alloc,\n\t_zeros as n_zeros,\n\t_copy as n_copy,\n\t_idivmod as n_idivmod,\n\t_trim_positive as n_trim_positive,\n\t_cmp_n as n_cmp_n,\n} from '@arithmetic-operations-for/naturals-big-endian';\n\nimport modR from './modR.js';\n\nexport default function modN(r, N, x) {\n\tconst k = N.length;\n\tconst xj = x.length;\n\tconst xi = n_trim_positive(x, 0, xj);\n\tconst xn = xj - xi;\n\tif (xn > k || (xn === k && n_cmp_n(x, xi, xj, N, 0) >= 0)) {\n\t\tconst xmodN = n_alloc(xn); // TODO Use UintXArray ?\n\t\tn_copy(x, xi, xj, xmodN, 0);\n\t\tconst _ = n_zeros(xn); // TODO use _imod once implemented\n\t\tn_idivmod(r, xmodN, 0, xn, N, 0, k, _, 0, xn);\n\t\treturn modR(k, xmodN);\n\t}\n\n\tconst xmodN = n_zeros(k); // TODO Use UintXArray ?\n\tn_copy(x, xi, xj, xmodN, k - xn);\n\treturn xmodN;\n}\n","import {\n\t_alloc as n_alloc,\n\t_zeros as n_zeros,\n\t_reset as n_reset,\n\t_copy as n_copy,\n\tjz as njz,\n\t_extended_euclidean_algorithm as n_extended_euclidean_algorithm,\n\t_trim_positive as n_trim_positive,\n\t_sub as n_sub,\n\tconvert as nconvert,\n} from '@arithmetic-operations-for/naturals-big-endian';\n\nimport _mul from './_mul.js';\nimport _iadd from './_iadd.js';\nimport _isub from './_isub.js';\nimport _redc from './_redc.js';\nimport _montgomery from './_montgomery.js';\nimport modR from './modR.js';\nimport modN from './modN.js';\n\nexport default class Montgomery {\n\tconstructor(b, N) {\n\t\tconst {k, M, R, R2, R3} = _montgomery(b, N);\n\t\tthis.b = b;\n\t\tthis.N = N;\n\t\tthis.k = k;\n\t\tthis.M = M;\n\t\tthis.R = R;\n\t\tthis.R2 = R2;\n\t\tthis.R3 = R3;\n\t\t// Use shared/pooled memory ?\n\t}\n\n\tone() {\n\t\treturn this.R;\n\t}\n\n\tzero() {\n\t\treturn n_zeros(this.k);\n\t}\n\n\tfrom(x) {\n\t\t// Conversion into Montgomery form is done by computing .\n\t\t// aR mod N = REDC((a mod N)(R^2 mod N))\n\t\tconst _2kp1 = 2 * this.k + 1;\n\t\tconst red = n_zeros(_2kp1); // TODO Use UintXArray ?\n\t\tconst amodN = modN(this.b, this.N, x);\n\t\t_mul(this.b, this.N, this.M, this.R2, amodN, red);\n\t\t// TODO many unnecessary copies/alloc can be avoided by\n\t\t// allowing array offsets in methods.\n\t\treturn modR(this.k, red);\n\t}\n\n\tout(aRmodN) {\n\t\t// Conversion out of Montgomery form is done by computing.\n\t\t// a mod N = REDC(aR mod N)\n\t\tconst _2kp1 = 2 * this.k + 1;\n\t\tconst _red = n_zeros(_2kp1); // TODO Use UintXArray ?\n\t\tn_copy(aRmodN, 0, this.k, _red, _2kp1 - this.k);\n\t\t_redc(this.b, this.k, this.N, 0, this.k, this.M, 0, this.k, _red, 0, _2kp1);\n\t\tconst i = n_trim_positive(_red, this.k + 1, _2kp1);\n\t\tconst red = n_alloc(_2kp1 - i); // TODO Use UintXArray ?\n\t\tn_copy(_red, i, _2kp1, red, 0);\n\t\treturn red;\n\t}\n\n\tmul(aRmodN, bRmodN) {\n\t\tconst _2kp1 = 2 * this.k + 1;\n\t\tconst abRmodN = n_zeros(_2kp1);\n\n\t\t_mul(this.b, this.N, this.M, aRmodN, bRmodN, abRmodN);\n\n\t\treturn modR(this.k, abRmodN);\n\t}\n\n\tadd(aRmodN, bRmodN) {\n\t\tconst aRpbRmodN = n_alloc(this.k);\n\t\tn_copy(aRmodN, 0, this.k, aRpbRmodN, 0);\n\t\t_iadd(this.b, this.N, aRpbRmodN, bRmodN);\n\t\treturn aRpbRmodN;\n\t}\n\n\tsub(aRmodN, bRmodN) {\n\t\tconst aRpbRmodN = n_alloc(this.k);\n\t\tn_copy(aRmodN, 0, this.k, aRpbRmodN, 0);\n\t\t_isub(this.b, this.N, aRpbRmodN, bRmodN);\n\t\treturn aRpbRmodN;\n\t}\n\n\tinv(aRmodN) {\n\t\t// The modular inverse\n\t\t// Compute (aR mod N)^-1 using Euclidean algo\n\t\tconst ai = n_trim_positive(aRmodN, 0, this.k);\n\n\t\tlet [\n\t\t\tGCD,\n\t\t\tGCDi,\n\t\t\t// eslint-disable-next-line no-unused-vars\n\t\t\t_S,\n\t\t\t// eslint-disable-next-line no-unused-vars\n\t\t\t_Si,\n\t\t\taRmodNi,\n\t\t\t// eslint-disable-next-line no-unused-vars\n\t\t\t_1,\n\t\t\t// eslint-disable-next-line no-unused-vars\n\t\t\t_2,\n\t\t\t// eslint-disable-next-line no-unused-vars\n\t\t\t_3,\n\t\t\t// eslint-disable-next-line no-unused-vars\n\t\t\t_4,\n\t\t\t// eslint-disable-next-line no-unused-vars\n\t\t\t_5,\n\t\t\tsteps,\n\t\t] = n_extended_euclidean_algorithm(\n\t\t\tthis.b,\n\t\t\tthis.N,\n\t\t\t0,\n\t\t\tthis.k,\n\t\t\taRmodN,\n\t\t\tai,\n\t\t\tthis.k,\n\t\t);\n\n\t\t// Assert that GCD(N,aRmodN) is 1.\n\t\tif (GCD.length - GCDi !== 1 || GCD[GCDi] !== 1)\n\t\t\tthrow new Error('aRmodN has no inverse modulo N');\n\n\t\tconst _2kp1 = 2 * this.k + 1;\n\t\tconst red = n_zeros(_2kp1); // TODO Use UintXArray ?\n\n\t\tif (steps % 2 === 1) {\n\t\t\t// We compute N - aRmodNi\n\t\t\tconst temporary = n_zeros(this.k);\n\t\t\tn_sub(\n\t\t\t\tthis.b,\n\t\t\t\tthis.N,\n\t\t\t\t0,\n\t\t\t\tthis.k,\n\t\t\t\taRmodNi,\n\t\t\t\t0,\n\t\t\t\tthis.k,\n\t\t\t\ttemporary,\n\t\t\t\t0,\n\t\t\t\tthis.k,\n\t\t\t);\n\t\t\taRmodNi = temporary;\n\t\t}\n\n\t\t// A^-1 R mod N = REDC((aR mod N)^-1(R^3 mod N)).\n\t\t_mul(this.b, this.N, this.M, this.R3, aRmodNi, red);\n\n\t\treturn modR(this.k, red);\n\t}\n\n\tpown(aRmodN, x) {\n\t\t// Modular\n\t\t// exponentiation can be done using exponentiation by squaring by initializing the\n\t\t// initial product to the Montgomery representation of 1, that is, to R mod N, and\n\t\t// by replacing the multiply and square steps by Montgomery multiplies.\n\n\t\tconst nonneg = x >= 0;\n\n\t\tif (!nonneg) x = -x;\n\n\t\tif (x === 0) return this.R;\n\t\tif (x === 1) return nonneg ? aRmodN : this.inv(aRmodN);\n\n\t\tconst xbits = [];\n\n\t\tdo {\n\t\t\txbits.push(x & 1); // eslint-disable-line no-bitwise\n\t\t\tx >>= 1; // eslint-disable-line no-bitwise\n\t\t} while (x !== 1);\n\n\t\treturn this._powb(aRmodN, xbits, nonneg);\n\t}\n\n\t_powb(aRmodN, xbits, nonneg) {\n\t\t// The binary expansion of the exponent is 1 concatenanted with xbits\n\t\t// reversed. Must have xbits.length >= 1.\n\t\tconst aRmodNpown = n_alloc(this.k);\n\t\tn_copy(aRmodN, 0, this.k, aRmodNpown, 0);\n\n\t\tconst _2kp1 = 2 * this.k + 1;\n\t\tconst temporary = n_alloc(_2kp1);\n\n\t\tdo {\n\t\t\tn_reset(temporary, 0, _2kp1);\n\t\t\t_mul(this.b, this.N, this.M, aRmodNpown, aRmodNpown, temporary);\n\t\t\tn_copy(temporary, _2kp1 - this.k, _2kp1, aRmodNpown, 0);\n\t\t\tif (xbits.pop() === 1) {\n\t\t\t\tn_reset(temporary, 0, _2kp1);\n\t\t\t\t_mul(this.b, this.N, this.M, aRmodNpown, aRmodN, temporary);\n\t\t\t\tn_copy(temporary, _2kp1 - this.k, _2kp1, aRmodNpown, 0);\n\t\t\t}\n\t\t} while (xbits.length > 0);\n\n\t\treturn nonneg ? aRmodNpown : this.inv(aRmodNpown);\n\t}\n\n\tpow(aRmodN, b, nonneg = true) {\n\t\tif (njz(b, 0, b.length - 1)) {\n\t\t\t// B consists of a single limb\n\t\t\treturn this.pown(aRmodN, nonneg ? b[b.length - 1] : -b[b.length - 1]);\n\t\t}\n\n\t\tconst xbits = nconvert(this.b, 2, b, 0, b.length);\n\t\txbits.reverse();\n\t\txbits.pop();\n\n\t\treturn this._powb(aRmodN, xbits, nonneg);\n\t}\n}\n"],"names":["_redc","b","k","N","Ni","Nj","M","Mi","Mj","T","Ti","Tj","_Ti","_2k","m","n_zeros","mj","n_mul","mi","X","_zeros","Xj","n_iadd","_iadd","n_copy","_Ti_1","n_reset","n_cmp_n","n_isub","_mul","r","a","c","length","_2kp1","n_cmp","_cmp","_cmp_n","_isub","underflow","_montgomery","_R","GCD","GCDi","_S","_Si","_M","_1","_2","_3","_4","_5","steps","n_extended_euclidean_algorithm","Error","n_alloc","_alloc","n_sub","_R2","n_idivmod","_idivmod","R2","R","_copy","_R3","R3","modR","x","xmodR","xi","n_trim_positive","_trim_positive","xj","xn","xmodN","_","constructor","this","one","zero","from","red","amodN","modN","out","aRmodN","_red","i","mul","bRmodN","abRmodN","add","aRpbRmodN","sub","inv","ai","aRmodNi","temporary","pown","nonneg","xbits","push","_powb","aRmodNpown","pop","pow","njz","jz","nconvert","convert","reverse"],"mappings":"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"}