@pinkparrot/qsafe-sig 0.0.2 → 0.0.4

package/package.json

@@ -1,7 +1,16 @@
 {
   "name": "@pinkparrot/qsafe-sig",
-  "version": "0.0.2",
+  "version": "0.0.4",
+  "author": "PinkParrot",
+  "license": "GPL-3.0",
   "description": "Combination of pre quantum and post quantum signature, designed for a smooth migration.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "browser": "./dist/qsafe-sig.browser.min.js",
+      "default": "./index.mjs"
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -11,7 +20,6 @@
     "build:min": "esbuild index.mjs --bundle --outfile=dist/qsafe-sig.browser.min.js --format=esm --platform=browser --define:ENVIRONMENT_IS_NODE=false --external:node:module --external:node:fs --external:node:path --external:node:crypto --external:node:url",
     "build": "npm run build:min"
   },
-  "files": [],
   "dependencies": {
     "@noble/curves": "2.0.1",
     "@noble/hashes": "2.0.1",
@@ -22,9 +30,14 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/Seigneur-Machiavel/qsafe-sig.git"
+    "url": "git+https://github.com/Seigneur-Machiavel/qsafe-sig.git"
   },
-  "keywords": [],
-  "author": "PinkParrot",
-  "license": "GPL-3.0"
+  "keywords": [
+    "double-signature",
+    "post-quantum",
+    "mayo",
+    "signature",
+    "cryptography",
+    "pqc"
+  ]
 }

package/publish.bat

@@ -0,0 +1,22 @@
+@echo off
+echo Building qsafe-sign...
+
+call npm run build:min
+if errorlevel 1 (
+    echo Build failed. Aborting.
+    pause
+    exit /b 1
+)
+echo.
+
+set /p PUBLISH="Publish to npm? (y/n): "
+if /i not "%PUBLISH%"=="y" (
+    echo Build complete. Nothing published.
+    pause
+    exit /b 0
+)
+
+call npm version patch
+call npm publish --access public
+echo Done.
+pause

package/qsafeHelper.mjs

@@ -0,0 +1,28 @@
+// @ts-check
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { BinaryReader } from './binary-writer-reader.mjs';
+import { PROTOCOL_VERSIONS, HKDF_INFO_ED25519, HKDF_INFO_MAYO,
+		 ED25519_PRIV_SIZE, HEADER_SIZE, VARIANT_BY_ID } from './constants.mjs';
+
+export class QsafeHelper {
+    /** Derives ed25519 + mayo seeds from a master seed via HKDF-SHA256.
+     * @param {Uint8Array} masterSeed  @param {number} mayoSeedSize */
+    static deriveSeeds(masterSeed, mayoSeedSize) {
+        const edSeed   = hkdf(sha256, masterSeed, undefined, HKDF_INFO_ED25519, ED25519_PRIV_SIZE);
+        const mayoSeed = hkdf(sha256, masterSeed, undefined, HKDF_INFO_MAYO, mayoSeedSize);
+        return { edSeed, mayoSeed };
+    }
+
+    /** Resolves version + variantId from a signature header. @param {Uint8Array} sig */
+    static parseHeader(sig) {
+        if (sig.length < HEADER_SIZE) return null;
+        const reader    = new BinaryReader(sig);
+        const version   = String(reader.readU16BE());
+        const variantId = reader.readByte();
+        const variant   = VARIANT_BY_ID[variantId];
+        const vProto    = PROTOCOL_VERSIONS[version];
+        if (!vProto || !variant || !vProto.variants[variant]) return null;
+        return { version, variant, desc: vProto.variants[variant] };
+    }
+}

package/test-helpers.mjs

@@ -0,0 +1,21 @@
+// @ts-check
+
+/** Generates a random Uint8Array of `len` bytes.
+ * - Uses crypto.getRandomValues in 65536-byte chunks (browser/Node API limit).
+ * @param {number} len @returns {Uint8Array} */
+export function createRandomMessage(len) {
+    const buf = new Uint8Array(len);
+    const CHUNK = 65536;
+    for (let offset = 0; offset < len; offset += CHUNK)
+        crypto.getRandomValues(buf.subarray(offset, Math.min(offset + CHUNK, len)));
+    return buf;
+}
+
+/** Constant-time byte equality check.
+ * @param {Uint8Array} a @param {Uint8Array} b */
+export function eq(a, b) { // simple loop for easier debugging hover breakpoints.
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i]) return false;
+    return true;
+}

package/test.mjs

@@ -0,0 +1,83 @@
+// @ts-check
+import { QsafeSigner } from './index.mjs';
+import { createRandomMessage, eq } from './test-helpers.mjs';
+
+const NB_OF_TESTS = 100;
+const msg1 = createRandomMessage(256); // 256-byte message for quick tests
+const msg2 = createRandomMessage(2**17); // 128KB message for testing larger sizes and performance
+
+const SEED_A = crypto.getRandomValues(new Uint8Array(32));
+const SEED_B = crypto.getRandomValues(new Uint8Array(32));
+
+/** @param {'mayo1'|'mayo2'} variant */
+async function testVariant(variant, log = false) {
+	let start = performance.now();
+
+    // -- Keypair determinism --
+    const signerA1 = await QsafeSigner.create(variant);
+    const signerA2 = await QsafeSigner.create(variant);
+    const kpA1 = signerA1.loadMasterKey(SEED_A);
+    const kpA2 = signerA2.loadMasterKey(SEED_A);
+	if (log) console.log(`- keypair generation time ~${((performance.now() - start) / 2).toFixed(2)} ms`);
+    console.assert(eq(kpA1.publicKey, kpA2.publicKey), `${variant} publicKey should be deterministic`);
+    console.assert(eq(kpA1.secretKey, kpA2.secretKey), `${variant} secretKey should be deterministic`);
+    if (log) console.log(`✓ ${variant} keypair determinism OK`);
+
+    // -- Different seeds → different keypairs --
+    const signerB = await QsafeSigner.create(variant);
+    const kpB = signerB.loadMasterKey(SEED_B);
+    console.assert(!eq(kpA1.publicKey, kpB.publicKey), `${variant} collision: same pubKey from different seeds`);
+    console.assert(!eq(kpA1.secretKey, kpB.secretKey), `${variant} collision: same secKey from different seeds`);
+    if (log) console.log(`✓ ${variant} seed isolation OK`);
+
+    // -- Sign/verify roundtrip --
+	start = performance.now();
+    const sig1 = signerA1.sign(msg1);
+    const sig2 = signerA1.sign(msg2);
+	if (log) console.log(`✓ ${variant} signing OK ~${((performance.now() - start) / 2).toFixed(2)} ms`);
+	
+	start = performance.now();
+    const verifier = await QsafeSigner.createFull();
+    console.assert( await verifier.verify(msg1, sig1, kpA1.publicKey),  `${variant} sig1/msg1 rejected`);
+    console.assert( await verifier.verify(msg2, sig2, kpA1.publicKey),  `${variant} sig2/msg2 rejected`);
+
+	console.assert(!await verifier.verify(msg2, sig1, kpA1.publicKey),  `${variant} sig1 wrongly accepts msg2`);
+    console.assert(!await verifier.verify(msg1, sig2, kpA1.publicKey),  `${variant} sig2 wrongly accepts msg1`);
+    if (log) console.log(`✓ ${variant} verifying OK ~${((performance.now() - start) / 4).toFixed(2)} ms`);
+
+    // -- Wrong public key → rejected --
+    console.assert(!await verifier.verify(msg1, sig1, kpB.publicKey), `${variant} wrong pubkey wrongly accepted`);
+    if (log) console.log(`✓ ${variant} cross-key rejection OK`);
+
+	// -- Tampered signature → rejected by verify(), not by checkFormat() --
+	const sigTampered = sig1.slice();
+	const tamperedIdx = 3 + Math.floor(Math.random() * (sig1.length - 3)); // random byte past the 3-byte header
+	sigTampered[tamperedIdx] ^= 0xFF;
+	console.assert(!await verifier.verify(msg1, sigTampered, kpA1.publicKey), `${variant} tampered sig wrongly accepted (flipped byte at index ${tamperedIdx})`);
+	if (log) console.log(`✓ ${variant} tampered sig rejection OK (flipped byte at index ${tamperedIdx})`);
+
+	// -- Tampered message → rejected --
+	const msgTampered = msg1.slice();
+	const msgTamperedIdx = Math.floor(Math.random() * msg1.length);
+	msgTampered[msgTamperedIdx] ^= 0xFF;
+	console.assert(!await verifier.verify(msgTampered, sig1, kpA1.publicKey), `${variant} tampered msg wrongly accepted (flipped byte at index ${msgTamperedIdx})`);
+	if (log) console.log(`✓ ${variant} tampered msg rejection OK (flipped byte at index ${msgTamperedIdx})`);
+
+    // -- checkFormat: structural check only (header + length), NOT a crypto check --
+    // A bit-flipped sig has the same length and a valid header → format is still "correct"
+    console.assert( QsafeSigner.checkFormat(sig1),                         `${variant} valid sig should pass checkFormat`);
+    console.assert( QsafeSigner.checkFormat(sigTampered),                   `${variant} tampered sig has valid format (use verify() for crypto)`);
+    console.assert(!QsafeSigner.checkFormat(sig1.slice(0, sig1.length - 1)), `${variant} truncated sig should fail checkFormat`);
+    console.assert(!QsafeSigner.checkFormat(new Uint8Array(3)),              `${variant} garbage should fail checkFormat`);
+    if (log) console.log(`✓ ${variant} checkFormat OK`);
+}
+
+console.log(`-- Testing mayo1 --`);
+for (let i = 0; i < NB_OF_TESTS - 1; i++) await testVariant('mayo1');
+await testVariant('mayo1', true); // last test: full logs.
+
+console.log(`-- Testing mayo2 --`);
+for (let i = 0; i < NB_OF_TESTS - 1; i++) await testVariant('mayo2');
+await testVariant('mayo2', true); // last test: full logs.
+
+console.log('-- TEST END --');