@theqrl/dilithium5 0.0.6 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theqrl/dilithium5",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Dilithium-5 cryptography",
   "keywords": [
     "dilithium",
@@ -11,7 +11,6 @@
   "homepage": "https://github.com/theQRL/qrypto.js#readme",
   "license": "MIT",
   "main": "src/index.js",
-  "type": "module",
   "directories": {
     "lib": "src",
     "test": "test"
@@ -44,7 +43,6 @@
     "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-prettier": "^4.2.1",
-    "esm": "^3.2.25",
     "mocha": "^10.2.0",
     "prettier": "^2.8.3"
   },

package/src/const.js

@@ -1,41 +1,40 @@
-export const Shake128Rate = 168;
-export const Shake256Rate = 136;
-export const Stream128BlockBytes = Shake128Rate;
-export const Stream256BlockBytes = Shake256Rate;
+const Shake128Rate = 168;
+const Shake256Rate = 136;
+const Stream128BlockBytes = Shake128Rate;
+const Stream256BlockBytes = Shake256Rate;
 
-export const SeedBytes = 32;
-export const CRHBytes = 64;
-export const N = 256;
-export const Q = 8380417;
-export const QInv = 58728449;
-export const D = 13;
+const SeedBytes = 32;
+const CRHBytes = 64;
+const N = 256;
+const Q = 8380417;
+const QInv = 58728449;
+const D = 13;
 
-export const K = 8;
-export const L = 7;
-export const ETA = 2;
-export const TAU = 60;
-export const BETA = 120;
-export const GAMMA1 = 1 << 19;
-export const GAMMA2 = Math.floor((Q - 1) / 32);
-export const OMEGA = 75;
+const K = 8;
+const L = 7;
+const ETA = 2;
+const TAU = 60;
+const BETA = 120;
+const GAMMA1 = 1 << 19;
+const GAMMA2 = Math.floor((Q - 1) / 32);
+const OMEGA = 75;
 
-export const PolyT1PackedBytes = 320;
-export const PolyT0PackedBytes = 416;
-export const PolyETAPackedBytes = 96;
-export const PolyZPackedBytes = 640;
-export const PolyVecHPackedBytes = OMEGA + K;
-export const PolyW1PackedBytes = 128;
+const PolyT1PackedBytes = 320;
+const PolyT0PackedBytes = 416;
+const PolyETAPackedBytes = 96;
+const PolyZPackedBytes = 640;
+const PolyVecHPackedBytes = OMEGA + K;
+const PolyW1PackedBytes = 128;
 
-export const CryptoPublicKeyBytes = SeedBytes + K * PolyT1PackedBytes;
-export const CryptoSecretKeyBytes =
-  3 * SeedBytes + L * PolyETAPackedBytes + K * PolyETAPackedBytes + K * PolyT0PackedBytes;
-export const CryptoBytes = SeedBytes + L * PolyZPackedBytes + PolyVecHPackedBytes;
+const CryptoPublicKeyBytes = SeedBytes + K * PolyT1PackedBytes;
+const CryptoSecretKeyBytes = 3 * SeedBytes + L * PolyETAPackedBytes + K * PolyETAPackedBytes + K * PolyT0PackedBytes;
+const CryptoBytes = SeedBytes + L * PolyZPackedBytes + PolyVecHPackedBytes;
 
-export const PolyUniformNBlocks = Math.floor((768 + Stream128BlockBytes - 1) / Stream128BlockBytes);
-export const PolyUniformETANBlocks = Math.floor((136 + Stream256BlockBytes - 1) / Stream256BlockBytes);
-export const PolyUniformGamma1NBlocks = Math.floor((PolyZPackedBytes + Stream256BlockBytes - 1) / Stream256BlockBytes);
+const PolyUniformNBlocks = Math.floor((768 + Stream128BlockBytes - 1) / Stream128BlockBytes);
+const PolyUniformETANBlocks = Math.floor((136 + Stream256BlockBytes - 1) / Stream256BlockBytes);
+const PolyUniformGamma1NBlocks = Math.floor((PolyZPackedBytes + Stream256BlockBytes - 1) / Stream256BlockBytes);
 
-export const zetas = [
+const zetas = [
   0, 25847, -2608894, -518909, 237124, -777960, -876248, 466468, 1826347, 2353451, -359251, -2091905, 3119733, -2884855,
   3111497, 2680103, 2725464, 1024112, -1079900, 3585928, -549488, -1119584, 2619752, -2108549, -2118186, -3859737,
   -1399561, -3277672, 1757237, -19422, 4010497, 280005, 2706023, 95776, 3077325, 3530437, -1661693, -3592148, -2537516,
@@ -58,3 +57,37 @@ export const zetas = [
   -3833893, -2939036, -2235985, -420899, -2286327, 183443, -976891, 1612842, -3545687, -554416, 3919660, -48306,
   -1362209, 3937738, 1400424, -846154, 1976782,
 ];
+
+module.exports = {
+  Shake128Rate,
+  Shake256Rate,
+  Stream128BlockBytes,
+  Stream256BlockBytes,
+  SeedBytes,
+  CRHBytes,
+  N,
+  Q,
+  QInv,
+  D,
+  K,
+  L,
+  ETA,
+  TAU,
+  BETA,
+  GAMMA1,
+  GAMMA2,
+  OMEGA,
+  PolyT1PackedBytes,
+  PolyT0PackedBytes,
+  PolyETAPackedBytes,
+  PolyZPackedBytes,
+  PolyVecHPackedBytes,
+  PolyW1PackedBytes,
+  CryptoPublicKeyBytes,
+  CryptoSecretKeyBytes,
+  CryptoBytes,
+  PolyUniformNBlocks,
+  PolyUniformETANBlocks,
+  PolyUniformGamma1NBlocks,
+  zetas,
+};

package/src/fips202.js

@@ -1,4 +1,4 @@
-import { Shake128Rate, Shake256Rate } from './const.js';
+const { Shake128Rate, Shake256Rate } = require('./const.js');
 
 const NRounds = 24;
 
@@ -29,7 +29,7 @@ const KeccakFRoundConstants = BigUint64Array.from([
   0x8000000080008008n,
 ]);
 
-export class KeccakState {
+class KeccakState {
   constructor() {
     this.s = new BigUint64Array(25);
     this.pos = 0;
@@ -384,47 +384,63 @@ function keccakSqueezeBlocks(output, outputOffset, nBlocks, s, r) {
   }
 }
 
-export function shake128Init(state) {
+function shake128Init(state) {
   keccakInit(state.s);
   state.pos = 0;
 }
 
-export function shake128Absorb(state, input) {
+function shake128Absorb(state, input) {
   state.pos = keccakAbsorb(state.s, state.pos, Shake128Rate, input);
 }
 
-export function shake128Finalize(state) {
+function shake128Finalize(state) {
   keccakFinalize(state.s, state.pos, Shake128Rate, 0x1f);
   state.pos = Shake128Rate;
 }
 
-export function shake128Squeeze(out, state) {
+function shake128Squeeze(out, state) {
   state.pos = keccakSqueeze(out, state.s, state.pos, Shake128Rate);
 }
 
-export function shake128AbsorbOnce(state, input) {
+function shake128AbsorbOnce(state, input) {
   keccakAbsorbOnce(state.s, Shake128Rate, input, 0x1f);
   state.pos = Shake128Rate;
 }
 
-export function shake128SqueezeBlocks(out, outputOffset, nBlocks, state) {
+function shake128SqueezeBlocks(out, outputOffset, nBlocks, state) {
   keccakSqueezeBlocks(out, outputOffset, nBlocks, state.s, Shake128Rate);
 }
 
-export function shake256Init(state) {
+function shake256Init(state) {
   keccakInit(state.s);
   state.pos = 0;
 }
 
-export function shake256Absorb(state, input) {
+function shake256Absorb(state, input) {
   state.pos = keccakAbsorb(state.s, state.pos, Shake256Rate, input);
 }
 
-export function shake256Finalize(state) {
+function shake256Finalize(state) {
   keccakFinalize(state.s, state.pos, Shake256Rate, 0x1f);
   state.pos = Shake256Rate;
 }
 
-export function shake256SqueezeBlocks(out, outputOffset, nBlocks, state) {
+function shake256SqueezeBlocks(out, outputOffset, nBlocks, state) {
   keccakSqueezeBlocks(out, outputOffset, nBlocks, state.s, Shake256Rate);
 }
+
+module.exports = {
+  KeccakState,
+  shake128Init,
+  shake128Absorb,
+  shake128Finalize,
+  shake128Squeeze,
+  shake128AbsorbOnce,
+  shake128SqueezeBlocks,
+  shake256Init,
+  shake256Absorb,
+  shake256Finalize,
+  shake256SqueezeBlocks,
+  NRounds,
+  KeccakFRoundConstants,
+};

package/src/ntt.js

@@ -1,7 +1,7 @@
-import { N, zetas } from './const.js';
-import { montgomeryReduce } from './reduce.js';
+const { N, zetas } = require('./const.js');
+const { montgomeryReduce } = require('./reduce.js');
 
-export function ntt(a) {
+function ntt(a) {
   let k = 0;
   let j = 0;
 
@@ -17,7 +17,7 @@ export function ntt(a) {
   }
 }
 
-export function invNTTToMont(a) {
+function invNTTToMont(a) {
   const f = 41978n; // mont^2/256
   let j = 0;
   let k = 256;
@@ -38,3 +38,8 @@ export function invNTTToMont(a) {
     a[j] = Number(montgomeryReduce(BigInt.asIntN(64, f * BigInt(a[j]))));
   }
 }
+
+module.exports = {
+  ntt,
+  invNTTToMont,
+};

package/src/packing.js

@@ -1,4 +1,4 @@
-import {
+const {
   K,
   L,
   N,
@@ -8,8 +8,8 @@ import {
   PolyT1PackedBytes,
   PolyZPackedBytes,
   SeedBytes,
-} from './const.js';
-import {
+} = require('./const.js');
+const {
   polyEtaPack,
   polyEtaUnpack,
   polyT0Pack,
@@ -18,9 +18,9 @@ import {
   polyT1Unpack,
   polyZPack,
   polyZUnpack,
-} from './poly.js';
+} = require('./poly.js');
 
-export function packPk(pkp, rho, t1) {
+function packPk(pkp, rho, t1) {
   const pk = pkp;
   for (let i = 0; i < SeedBytes; ++i) {
     pk[i] = rho[i];
@@ -30,7 +30,7 @@ export function packPk(pkp, rho, t1) {
   }
 }
 
-export function unpackPk(rhop, t1, pk) {
+function unpackPk(rhop, t1, pk) {
   const rho = rhop;
   for (let i = 0; i < SeedBytes; ++i) {
     rho[i] = pk[i];
@@ -41,7 +41,7 @@ export function unpackPk(rhop, t1, pk) {
   }
 }
 
-export function packSk(skp, rho, tr, key, t0, s1, s2) {
+function packSk(skp, rho, tr, key, t0, s1, s2) {
   let skOffset = 0;
   const sk = skp;
   for (let i = 0; i < SeedBytes; ++i) {
@@ -74,7 +74,7 @@ export function packSk(skp, rho, tr, key, t0, s1, s2) {
   }
 }
 
-export function unpackSk(rhoP, trP, keyP, t0, s1, s2, sk) {
+function unpackSk(rhoP, trP, keyP, t0, s1, s2, sk) {
   let skOffset = 0;
   const rho = rhoP;
   const tr = trP;
@@ -109,7 +109,7 @@ export function unpackSk(rhoP, trP, keyP, t0, s1, s2, sk) {
   }
 }
 
-export function packSig(sigP, c, z, h) {
+function packSig(sigP, c, z, h) {
   let sigOffset = 0;
   const sig = sigP;
   for (let i = 0; i < SeedBytes; ++i) {
@@ -138,7 +138,7 @@ export function packSig(sigP, c, z, h) {
   }
 }
 
-export function unpackSig(cP, z, hP, sig) {
+function unpackSig(cP, z, hP, sig) {
   let sigOffset = 0;
   const c = cP;
   const h = hP;
@@ -183,3 +183,12 @@ export function unpackSig(cP, z, hP, sig) {
 
   return 0;
 }
+
+module.exports = {
+  packPk,
+  unpackPk,
+  packSk,
+  unpackSk,
+  packSig,
+  unpackSig,
+};

package/src/poly.js

@@ -1,4 +1,4 @@
-import {
+const {
   D,
   ETA,
   GAMMA1,
@@ -12,21 +12,23 @@ import {
   Stream128BlockBytes,
   Stream256BlockBytes,
   TAU,
-} from './const.js';
-import {
+} = require('./const.js');
+
+const {
   KeccakState,
   shake128SqueezeBlocks,
   shake256Absorb,
   shake256Finalize,
   shake256Init,
   shake256SqueezeBlocks,
-} from './fips202.js';
-import { dilithiumShake128StreamInit, dilithiumShake256StreamInit } from './symmetric-shake.js';
-import { invNTTToMont, ntt } from './ntt.js';
-import { cAddQ, montgomeryReduce, reduce32 } from './reduce.js';
-import { decompose, makeHint, power2round, useHint } from './rounding.js';
+} = require('./fips202.js');
+
+const { dilithiumShake128StreamInit, dilithiumShake256StreamInit } = require('./symmetric-shake.js');
+const { invNTTToMont, ntt } = require('./ntt.js');
+const { cAddQ, montgomeryReduce, reduce32 } = require('./reduce.js');
+const { decompose, makeHint, power2round, useHint } = require('./rounding.js');
 
-export class Poly {
+class Poly {
   constructor() {
     this.coeffs = new Int32Array(N);
   }
@@ -38,55 +40,55 @@ export class Poly {
   }
 }
 
-export function polyReduce(aP) {
+function polyReduce(aP) {
   const a = aP;
   for (let i = 0; i < N; ++i) a.coeffs[i] = reduce32(a.coeffs[i]);
 }
 
-export function polyCAddQ(aP) {
+function polyCAddQ(aP) {
   const a = aP;
   for (let i = 0; i < N; ++i) a.coeffs[i] = cAddQ(a.coeffs[i]);
 }
 
-export function polyAdd(cP, a, b) {
+function polyAdd(cP, a, b) {
   const c = cP;
   for (let i = 0; i < N; ++i) c.coeffs[i] = a.coeffs[i] + b.coeffs[i];
 }
 
-export function polySub(cP, a, b) {
+function polySub(cP, a, b) {
   const c = cP;
   for (let i = 0; i < N; ++i) c.coeffs[i] = a.coeffs[i] - b.coeffs[i];
 }
 
-export function polyShiftL(aP) {
+function polyShiftL(aP) {
   const a = aP;
   for (let i = 0; i < N; ++i) a.coeffs[i] <<= D;
 }
 
-export function polyNTT(a) {
+function polyNTT(a) {
   ntt(a.coeffs);
 }
 
-export function polyInvNTTToMont(a) {
+function polyInvNTTToMont(a) {
   invNTTToMont(a.coeffs);
 }
 
-export function polyPointWiseMontgomery(cP, a, b) {
+function polyPointWiseMontgomery(cP, a, b) {
   const c = cP;
   for (let i = 0; i < N; ++i) c.coeffs[i] = Number(montgomeryReduce(BigInt(a.coeffs[i]) * BigInt(b.coeffs[i])));
 }
 
-export function polyPower2round(a1p, a0, a) {
+function polyPower2round(a1p, a0, a) {
   const a1 = a1p;
   for (let i = 0; i < N; ++i) a1.coeffs[i] = power2round(a0.coeffs, i, a.coeffs[i]);
 }
 
-export function polyDecompose(a1p, a0, a) {
+function polyDecompose(a1p, a0, a) {
   const a1 = a1p;
   for (let i = 0; i < N; ++i) a1.coeffs[i] = decompose(a0.coeffs, i, a.coeffs[i]);
 }
 
-export function polyMakeHint(hp, a0, a1) {
+function polyMakeHint(hp, a0, a1) {
   let s = 0;
   const h = hp;
   for (let i = 0; i < N; ++i) {
@@ -97,14 +99,14 @@ export function polyMakeHint(hp, a0, a1) {
   return s;
 }
 
-export function polyUseHint(bp, a, h) {
+function polyUseHint(bp, a, h) {
   const b = bp;
   for (let i = 0; i < N; ++i) {
     b.coeffs[i] = useHint(a.coeffs[i], h.coeffs[i]);
   }
 }
 
-export function polyChkNorm(a, b) {
+function polyChkNorm(a, b) {
   if (b > Math.floor((Q - 1) / 8)) {
     return 1;
   }
@@ -121,7 +123,7 @@ export function polyChkNorm(a, b) {
   return 0;
 }
 
-export function rejUniform(ap, aOffset, len, buf, bufLen) {
+function rejUniform(ap, aOffset, len, buf, bufLen) {
   let ctr = 0;
   let pos = 0;
   const a = ap;
@@ -139,7 +141,7 @@ export function rejUniform(ap, aOffset, len, buf, bufLen) {
   return ctr;
 }
 
-export function polyUniform(a, seed, nonce) {
+function polyUniform(a, seed, nonce) {
   let off = 0;
   let bufLen = PolyUniformNBlocks * Stream128BlockBytes;
   const buf = new Uint8Array(PolyUniformNBlocks * Stream128BlockBytes + 2);
@@ -160,7 +162,7 @@ export function polyUniform(a, seed, nonce) {
   }
 }
 
-export function rejEta(aP, aOffset, len, buf, bufLen) {
+function rejEta(aP, aOffset, len, buf, bufLen) {
   let ctr;
   let pos;
   let t0;
@@ -185,7 +187,7 @@ export function rejEta(aP, aOffset, len, buf, bufLen) {
   return ctr;
 }
 
-export function polyUniformEta(a, seed, nonce) {
+function polyUniformEta(a, seed, nonce) {
   let ctr;
   const bufLen = PolyUniformETANBlocks * Stream256BlockBytes;
   const buf = new Uint8Array(bufLen);
@@ -201,7 +203,7 @@ export function polyUniformEta(a, seed, nonce) {
   }
 }
 
-export function polyZUnpack(rP, a, aOffset) {
+function polyZUnpack(rP, a, aOffset) {
   const r = rP;
   for (let i = 0; i < N / 2; ++i) {
     r.coeffs[2 * i] = a[aOffset + 5 * i];
@@ -219,7 +221,7 @@ export function polyZUnpack(rP, a, aOffset) {
   }
 }
 
-export function polyUniformGamma1(a, seed, nonce) {
+function polyUniformGamma1(a, seed, nonce) {
   const buf = new Uint8Array(PolyUniformGamma1NBlocks * Stream256BlockBytes);
 
   const state = new KeccakState();
@@ -228,7 +230,7 @@ export function polyUniformGamma1(a, seed, nonce) {
   polyZUnpack(a, buf, 0);
 }
 
-export function polyChallenge(cP, seed) {
+function polyChallenge(cP, seed) {
   let b;
   let pos;
   const c = cP;
@@ -265,7 +267,7 @@ export function polyChallenge(cP, seed) {
   }
 }
 
-export function polyEtaPack(rP, rOffset, a) {
+function polyEtaPack(rP, rOffset, a) {
   const t = new Uint8Array(8);
   const r = rP;
   for (let i = 0; i < N / 8; ++i) {
@@ -284,7 +286,7 @@ export function polyEtaPack(rP, rOffset, a) {
   }
 }
 
-export function polyEtaUnpack(rP, a, aOffset) {
+function polyEtaUnpack(rP, a, aOffset) {
   const r = rP;
   for (let i = 0; i < N / 8; ++i) {
     r.coeffs[8 * i] = (a[aOffset + 3 * i] >> 0) & 7;
@@ -307,7 +309,7 @@ export function polyEtaUnpack(rP, a, aOffset) {
   }
 }
 
-export function polyT1Pack(rP, rOffset, a) {
+function polyT1Pack(rP, rOffset, a) {
   const r = rP;
   for (let i = 0; i < N / 4; ++i) {
     r[rOffset + 5 * i] = a.coeffs[4 * i] >> 0;
@@ -318,7 +320,7 @@ export function polyT1Pack(rP, rOffset, a) {
   }
 }
 
-export function polyT1Unpack(rP, a, aOffset) {
+function polyT1Unpack(rP, a, aOffset) {
   const r = rP;
   for (let i = 0; i < N / 4; ++i) {
     r.coeffs[4 * i] = ((a[aOffset + 5 * i] >> 0) | (a[aOffset + 5 * i + 1] << 8)) & 0x3ff;
@@ -328,7 +330,7 @@ export function polyT1Unpack(rP, a, aOffset) {
   }
 }
 
-export function polyT0Pack(rP, rOffset, a) {
+function polyT0Pack(rP, rOffset, a) {
   const t = new Uint32Array(8);
   const r = rP;
   for (let i = 0; i < N / 8; ++i) {
@@ -364,7 +366,7 @@ export function polyT0Pack(rP, rOffset, a) {
   }
 }
 
-export function polyT0Unpack(rP, a, aOffset) {
+function polyT0Unpack(rP, a, aOffset) {
   const r = rP;
   for (let i = 0; i < N / 8; ++i) {
     r.coeffs[8 * i] = a[aOffset + 13 * i];
@@ -414,7 +416,7 @@ export function polyT0Unpack(rP, a, aOffset) {
   }
 }
 
-export function polyZPack(rP, rOffset, a) {
+function polyZPack(rP, rOffset, a) {
   const t = new Uint32Array(4);
   const r = rP;
   for (let i = 0; i < N / 2; ++i) {
@@ -430,9 +432,41 @@ export function polyZPack(rP, rOffset, a) {
   }
 }
 
-export function polyW1Pack(rP, rOffset, a) {
+function polyW1Pack(rP, rOffset, a) {
   const r = rP;
   for (let i = 0; i < N / 2; ++i) {
     r[rOffset + i] = a.coeffs[2 * i] | (a.coeffs[2 * i + 1] << 4);
   }
 }
+
+module.exports = {
+  polyW1Pack,
+  polyZPack,
+  polyT0Unpack,
+  polyT0Pack,
+  polyT1Unpack,
+  polyT1Pack,
+  polyEtaPack,
+  polyEtaUnpack,
+  polyChallenge,
+  polyUniformGamma1,
+  polyZUnpack,
+  polyUniformEta,
+  rejEta,
+  polyUniform,
+  rejUniform,
+  polyChkNorm,
+  polyUseHint,
+  polyMakeHint,
+  polyDecompose,
+  polyPower2round,
+  polyPointWiseMontgomery,
+  polyInvNTTToMont,
+  polyNTT,
+  polyShiftL,
+  polyAdd,
+  polySub,
+  polyCAddQ,
+  polyReduce,
+  Poly,
+};

package/src/polyvec.js

@@ -1,4 +1,4 @@
-import {
+const {
   Poly,
   polyAdd,
   polyCAddQ,
@@ -17,16 +17,16 @@ import {
   polyUniformGamma1,
   polyUseHint,
   polyW1Pack,
-} from './poly.js';
-import { CRHBytes, K, L, PolyW1PackedBytes, SeedBytes } from './const.js';
+} = require('./poly.js');
+const { CRHBytes, K, L, PolyW1PackedBytes, SeedBytes } = require('./const.js');
 
-export class PolyVecK {
+class PolyVecK {
   constructor() {
     this.vec = new Array(K).fill().map((_) => new Poly());
   }
 }
 
-export class PolyVecL {
+class PolyVecL {
   constructor() {
     this.vec = new Array(L).fill().map((_) => new Poly());
   }
@@ -38,7 +38,7 @@ export class PolyVecL {
   }
 }
 
-export function polyVecMatrixExpand(mat, rho) {
+function polyVecMatrixExpand(mat, rho) {
   if (rho.length !== SeedBytes) {
     throw new Error(`invalid rho length ${rho.length} | Expected length ${SeedBytes}`);
   }
@@ -49,13 +49,13 @@ export function polyVecMatrixExpand(mat, rho) {
   }
 }
 
-export function polyVecMatrixPointWiseMontgomery(t, mat, v) {
+function polyVecMatrixPointWiseMontgomery(t, mat, v) {
   for (let i = 0; i < K; ++i) {
     polyVecLPointWiseAccMontgomery(t.vec[i], mat[i], v);
   }
 }
 
-export function polyVecLUniformEta(v, seed, nonce) {
+function polyVecLUniformEta(v, seed, nonce) {
   if (seed.length !== CRHBytes) {
     throw new Error(`invalid seed length ${seed.length} | Expected length ${CRHBytes}`);
   }
@@ -64,7 +64,7 @@ export function polyVecLUniformEta(v, seed, nonce) {
   }
 }
 
-export function polyVecLUniformGamma1(v, seed, nonce) {
+function polyVecLUniformGamma1(v, seed, nonce) {
   if (seed.length !== CRHBytes) {
     throw new Error(`invalid seed length ${seed.length} | Expected length ${CRHBytes}`);
   }
@@ -73,31 +73,31 @@ export function polyVecLUniformGamma1(v, seed, nonce) {
   }
 }
 
-export function polyVecLReduce(v) {
+function polyVecLReduce(v) {
   for (let i = 0; i < L; i++) {
     polyReduce(v.vec[i]);
   }
 }
 
-export function polyVecLAdd(w, u, v) {
+function polyVecLAdd(w, u, v) {
   for (let i = 0; i < L; ++i) {
     polyAdd(w.vec[i], u.vec[i], v.vec[i]);
   }
 }
 
-export function polyVecLNTT(v) {
+function polyVecLNTT(v) {
   for (let i = 0; i < L; ++i) {
     polyNTT(v.vec[i]);
   }
 }
 
-export function polyVecLInvNTTToMont(v) {
+function polyVecLInvNTTToMont(v) {
   for (let i = 0; i < L; ++i) {
     polyInvNTTToMont(v.vec[i]);
   }
 }
 
-export function polyVecLPointWisePolyMontgomery(r, a, v) {
+function polyVecLPointWisePolyMontgomery(r, a, v) {
   for (let i = 0; i < L; ++i) {
     polyPointWiseMontgomery(r.vec[i], a, v.vec[i]);
   }
@@ -112,7 +112,7 @@ function polyVecLPointWiseAccMontgomery(w, u, v) {
   }
 }
 
-export function polyVecLChkNorm(v, bound) {
+function polyVecLChkNorm(v, bound) {
   for (let i = 0; i < L; i++) {
     if (polyChkNorm(v.vec[i], bound) !== 0) {
       return 1;
@@ -121,61 +121,61 @@ export function polyVecLChkNorm(v, bound) {
   return 0;
 }
 
-export function polyVecKUniformEta(v, seed, nonce) {
+function polyVecKUniformEta(v, seed, nonce) {
   for (let i = 0; i < K; ++i) {
     polyUniformEta(v.vec[i], seed, nonce++);
   }
 }
 
-export function polyVecKReduce(v) {
+function polyVecKReduce(v) {
   for (let i = 0; i < K; ++i) {
     polyReduce(v.vec[i]);
   }
 }
 
-export function polyVecKCAddQ(v) {
+function polyVecKCAddQ(v) {
   for (let i = 0; i < K; ++i) {
     polyCAddQ(v.vec[i]);
   }
 }
 
-export function polyVecKAdd(w, u, v) {
+function polyVecKAdd(w, u, v) {
   for (let i = 0; i < K; ++i) {
     polyAdd(w.vec[i], u.vec[i], v.vec[i]);
   }
 }
 
-export function polyVecKSub(w, u, v) {
+function polyVecKSub(w, u, v) {
   for (let i = 0; i < K; ++i) {
     polySub(w.vec[i], u.vec[i], v.vec[i]);
   }
 }
 
-export function polyVecKShiftL(v) {
+function polyVecKShiftL(v) {
   for (let i = 0; i < K; ++i) {
     polyShiftL(v.vec[i]);
   }
 }
 
-export function polyVecKNTT(v) {
+function polyVecKNTT(v) {
   for (let i = 0; i < K; i++) {
     polyNTT(v.vec[i]);
   }
 }
 
-export function polyVecKInvNTTToMont(v) {
+function polyVecKInvNTTToMont(v) {
   for (let i = 0; i < K; i++) {
     polyInvNTTToMont(v.vec[i]);
   }
 }
 
-export function polyVecKPointWisePolyMontgomery(r, a, v) {
+function polyVecKPointWisePolyMontgomery(r, a, v) {
   for (let i = 0; i < K; i++) {
     polyPointWiseMontgomery(r.vec[i], a, v.vec[i]);
   }
 }
 
-export function polyVecKChkNorm(v, bound) {
+function polyVecKChkNorm(v, bound) {
   for (let i = 0; i < K; i++) {
     if (polyChkNorm(v.vec[i], bound) !== 0) {
       return 1;
@@ -184,19 +184,19 @@ export function polyVecKChkNorm(v, bound) {
   return 0;
 }
 
-export function polyVecKPower2round(v1, v0, v) {
+function polyVecKPower2round(v1, v0, v) {
   for (let i = 0; i < K; i++) {
     polyPower2round(v1.vec[i], v0.vec[i], v.vec[i]);
   }
 }
 
-export function polyVecKDecompose(v1, v0, v) {
+function polyVecKDecompose(v1, v0, v) {
   for (let i = 0; i < K; i++) {
     polyDecompose(v1.vec[i], v0.vec[i], v.vec[i]);
   }
 }
 
-export function polyVecKMakeHint(h, v0, v1) {
+function polyVecKMakeHint(h, v0, v1) {
   let s = 0;
   for (let i = 0; i < K; i++) {
     s += polyMakeHint(h.vec[i], v0.vec[i], v1.vec[i]);
@@ -204,14 +204,45 @@ export function polyVecKMakeHint(h, v0, v1) {
   return s;
 }
 
-export function polyVecKUseHint(w, u, h) {
+function polyVecKUseHint(w, u, h) {
   for (let i = 0; i < K; ++i) {
     polyUseHint(w.vec[i], u.vec[i], h.vec[i]);
   }
 }
 
-export function polyVecKPackW1(r, w1) {
+function polyVecKPackW1(r, w1) {
   for (let i = 0; i < K; ++i) {
     polyW1Pack(r, i * PolyW1PackedBytes, w1.vec[i]);
   }
 }
+
+module.exports = {
+  polyVecLUniformEta,
+  polyVecLUniformGamma1,
+  polyVecLReduce,
+  polyVecLAdd,
+  polyVecLNTT,
+  polyVecLInvNTTToMont,
+  polyVecLPointWisePolyMontgomery,
+  polyVecLPointWiseAccMontgomery,
+  polyVecLChkNorm,
+  polyVecKUniformEta,
+  polyVecKReduce,
+  polyVecKCAddQ,
+  polyVecKAdd,
+  polyVecKSub,
+  polyVecKShiftL,
+  polyVecKNTT,
+  polyVecKInvNTTToMont,
+  polyVecKPointWisePolyMontgomery,
+  polyVecKChkNorm,
+  polyVecKPower2round,
+  polyVecKDecompose,
+  polyVecKMakeHint,
+  polyVecKUseHint,
+  polyVecKPackW1,
+  polyVecMatrixPointWiseMontgomery,
+  PolyVecL,
+  PolyVecK,
+  polyVecMatrixExpand,
+};

package/src/reduce.js

@@ -1,19 +1,25 @@
-import { Q, QInv } from './const.js';
+const { Q, QInv } = require('./const.js');
 
-export function montgomeryReduce(a) {
+function montgomeryReduce(a) {
   let t = BigInt.asIntN(32, BigInt.asIntN(64, BigInt.asIntN(32, a)) * BigInt(QInv));
   t = BigInt.asIntN(32, (a - t * BigInt(Q)) >> 32n);
   return t;
 }
 
-export function reduce32(a) {
+function reduce32(a) {
   let t = (a + (1 << 22)) >> 23;
   t = a - t * Q;
   return t;
 }
 
-export function cAddQ(a) {
+function cAddQ(a) {
   let ar = a;
   ar += (ar >> 31) & Q;
   return ar;
 }
+
+module.exports = {
+  montgomeryReduce,
+  reduce32,
+  cAddQ,
+};

package/src/rounding.js

@@ -1,13 +1,13 @@
-import { D, GAMMA2, Q } from './const.js';
+const { D, GAMMA2, Q } = require('./const.js');
 
-export function power2round(a0p, i, a) {
+function power2round(a0p, i, a) {
   const a0 = a0p;
   const a1 = (a + (1 << (D - 1)) - 1) >> D;
   a0[i] = a - (a1 << D);
   return a1;
 }
 
-export function decompose(a0p, i, a) {
+function decompose(a0p, i, a) {
   const a0 = a0p;
   let a1 = (a + 127) >> 7;
   a1 = (a1 * 1025 + (1 << 21)) >> 22;
@@ -18,13 +18,13 @@ export function decompose(a0p, i, a) {
   return a1;
 }
 
-export function makeHint(a0, a1) {
+function makeHint(a0, a1) {
   if (a0 > GAMMA2 || a0 < -GAMMA2 || (a0 === -GAMMA2 && a1 !== 0)) return 1;
 
   return 0;
 }
 
-export function useHint(a, hint) {
+function useHint(a, hint) {
   const a0 = new Int32Array(1);
   const a1 = decompose(a0, 0, a);
 
@@ -33,3 +33,10 @@ export function useHint(a, hint) {
   if (a0[0] > 0) return (a1 + 1) & 15;
   return (a1 - 1) & 15;
 }
+
+module.exports = {
+  power2round,
+  decompose,
+  makeHint,
+  useHint,
+};

package/src/sign.js

@@ -1,7 +1,7 @@
-import pkg from 'randombytes'; // eslint-disable-line import/no-extraneous-dependencies
-import { SHAKE } from 'sha3'; // eslint-disable-line import/no-extraneous-dependencies
+const randomBytes = require('randombytes'); // eslint-disable-line import/no-extraneous-dependencies
+const { SHAKE } = require('sha3'); // eslint-disable-line import/no-extraneous-dependencies
 
-import {
+const {
   PolyVecK,
   polyVecKAdd,
   polyVecKCAddQ,
@@ -29,8 +29,8 @@ import {
   polyVecLUniformGamma1,
   polyVecMatrixExpand,
   polyVecMatrixPointWiseMontgomery,
-} from './polyvec.js';
-import {
+} = require('./polyvec.js');
+const {
   BETA,
   CRHBytes,
   CryptoBytes,
@@ -43,13 +43,11 @@ import {
   OMEGA,
   PolyW1PackedBytes,
   SeedBytes,
-} from './const.js';
-import { Poly, polyChallenge, polyNTT } from './poly.js';
-import { packPk, packSig, packSk, unpackPk, unpackSig, unpackSk } from './packing.js';
+} = require('./const.js');
+const { Poly, polyChallenge, polyNTT } = require('./poly.js');
+const { packPk, packSig, packSk, unpackPk, unpackSig, unpackSk } = require('./packing.js');
 
-const randomBytes = pkg;
-
-export function cryptoSignKeypair(passedSeed, pk, sk) {
+function cryptoSignKeypair(passedSeed, pk, sk) {
   try {
     if (pk.length !== CryptoPublicKeyBytes) {
       throw new Error(`invalid pk length ${pk.length} | Expected length ${CryptoPublicKeyBytes}`);
@@ -115,7 +113,7 @@ export function cryptoSignKeypair(passedSeed, pk, sk) {
   return seed;
 }
 
-export function cryptoSignSignature(sig, m, sk, randomizedSigning) {
+function cryptoSignSignature(sig, m, sk, randomizedSigning) {
   if (sk.length !== CryptoSecretKeyBytes) {
     throw new Error(`invalid sk length ${sk.length} | Expected length ${CryptoSecretKeyBytes}`);
   }
@@ -221,7 +219,7 @@ export function cryptoSignSignature(sig, m, sk, randomizedSigning) {
   }
 }
 
-export function cryptoSign(msg, sk, randomizedSigning) {
+function cryptoSign(msg, sk, randomizedSigning) {
   const sm = new Uint8Array(CryptoBytes + msg.length);
   const mLen = msg.length;
   for (let i = 0; i < mLen; ++i) {
@@ -235,7 +233,7 @@ export function cryptoSign(msg, sk, randomizedSigning) {
   return sm;
 }
 
-export function cryptoSignVerify(sig, m, pk) {
+function cryptoSignVerify(sig, m, pk) {
   let i;
   const buf = new Uint8Array(K * PolyW1PackedBytes);
   const rho = new Uint8Array(SeedBytes);
@@ -309,7 +307,7 @@ export function cryptoSignVerify(sig, m, pk) {
   return true;
 }
 
-export function cryptoSignOpen(sm, pk) {
+function cryptoSignOpen(sm, pk) {
   if (sm.length < CryptoBytes) {
     return undefined;
   }
@@ -322,3 +320,11 @@ export function cryptoSignOpen(sm, pk) {
 
   return msg;
 }
+
+module.exports = {
+  cryptoSignKeypair,
+  cryptoSignSignature,
+  cryptoSign,
+  cryptoSignVerify,
+  cryptoSignOpen,
+};

package/src/symmetric-shake.js

@@ -1,14 +1,14 @@
-import {
+const {
   shake128Absorb,
   shake128Finalize,
   shake128Init,
   shake256Absorb,
   shake256Finalize,
   shake256Init,
-} from './fips202.js';
-import { CRHBytes, SeedBytes } from './const.js';
+} = require('./fips202.js');
+const { CRHBytes, SeedBytes } = require('./const.js');
 
-export function dilithiumShake128StreamInit(state, seed, nonce) {
+function dilithiumShake128StreamInit(state, seed, nonce) {
   if (seed.length !== SeedBytes) {
     throw new Error(`invalid seed length ${seed.length} | expected ${SeedBytes}`);
   }
@@ -22,7 +22,7 @@ export function dilithiumShake128StreamInit(state, seed, nonce) {
   shake128Finalize(state);
 }
 
-export function dilithiumShake256StreamInit(state, seed, nonce) {
+function dilithiumShake256StreamInit(state, seed, nonce) {
   if (seed.length !== CRHBytes) {
     throw new Error(`invalid seed length ${seed.length} | expected ${CRHBytes}`);
   }
@@ -35,3 +35,8 @@ export function dilithiumShake256StreamInit(state, seed, nonce) {
   shake256Absorb(state, t);
   shake256Finalize(state);
 }
+
+module.exports = {
+  dilithiumShake128StreamInit,
+  dilithiumShake256StreamInit,
+};