zapo-js 0.1.0

package/dist/crypto/core/primitives.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Low-level crypto primitives using WebCrypto API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = sha256;
+exports.sha1 = sha1;
+exports.sha512 = sha512;
+exports.md5Bytes = md5Bytes;
+exports.importAesGcmKey = importAesGcmKey;
+exports.aesGcmEncrypt = aesGcmEncrypt;
+exports.aesGcmDecrypt = aesGcmDecrypt;
+exports.importAesCbcKey = importAesCbcKey;
+exports.aesCbcEncrypt = aesCbcEncrypt;
+exports.aesCbcDecrypt = aesCbcDecrypt;
+exports.importHmacKey = importHmacKey;
+exports.importHmacSha512Key = importHmacSha512Key;
+exports.hmacSign = hmacSign;
+exports.pbkdf2DeriveAesCtrKey = pbkdf2DeriveAesCtrKey;
+exports.aesCtrEncrypt = aesCtrEncrypt;
+exports.aesCtrDecrypt = aesCtrDecrypt;
+exports.ed25519VerifyRaw = ed25519VerifyRaw;
+const node_crypto_1 = require("node:crypto");
+const bytes_1 = require("../../util/bytes");
+// ============================================
+// Hash functions
+// ============================================
+async function sha256(value) {
+    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.digest('SHA-256', value));
+}
+async function sha1(value) {
+    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.digest('SHA-1', value));
+}
+async function sha512(value) {
+    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.digest('SHA-512', value));
+}
+function md5Bytes(input) {
+    return (0, bytes_1.toBytesView)((0, node_crypto_1.createHash)('md5').update(input).digest());
+}
+// ============================================
+// AES-GCM (for Noise protocol)
+// ============================================
+async function importAesGcmKey(raw, usages) {
+    return node_crypto_1.webcrypto.subtle.importKey('raw', raw, 'AES-GCM', false, usages);
+}
+async function aesGcmEncrypt(key, nonce, plaintext, aad = bytes_1.EMPTY_BYTES) {
+    const result = await node_crypto_1.webcrypto.subtle.encrypt({ name: 'AES-GCM', iv: nonce, additionalData: aad }, key, plaintext);
+    return (0, bytes_1.toBytesView)(result);
+}
+async function aesGcmDecrypt(key, nonce, ciphertext, aad = bytes_1.EMPTY_BYTES) {
+    const result = await node_crypto_1.webcrypto.subtle.decrypt({ name: 'AES-GCM', iv: nonce, additionalData: aad }, key, ciphertext);
+    return (0, bytes_1.toBytesView)(result);
+}
+// ============================================
+// AES-CBC (for Signal protocol)
+// ============================================
+async function importAesCbcKey(keyBytes) {
+    return node_crypto_1.webcrypto.subtle.importKey('raw', keyBytes, { name: 'AES-CBC', length: 256 }, false, [
+        'encrypt',
+        'decrypt'
+    ]);
+}
+async function aesCbcEncrypt(key, iv, plaintext) {
+    const result = await node_crypto_1.webcrypto.subtle.encrypt({ name: 'AES-CBC', iv }, key, plaintext);
+    return (0, bytes_1.toBytesView)(result);
+}
+async function aesCbcDecrypt(key, iv, ciphertext) {
+    const result = await node_crypto_1.webcrypto.subtle.decrypt({ name: 'AES-CBC', iv }, key, ciphertext);
+    return (0, bytes_1.toBytesView)(result);
+}
+// ============================================
+// HMAC-SHA256 (for Signal protocol)
+// ============================================
+async function importHmacKey(keyBytes) {
+    return node_crypto_1.webcrypto.subtle.importKey('raw', keyBytes, { name: 'HMAC', hash: 'SHA-256' }, false, [
+        'sign'
+    ]);
+}
+async function importHmacSha512Key(keyBytes) {
+    return node_crypto_1.webcrypto.subtle.importKey('raw', keyBytes, { name: 'HMAC', hash: 'SHA-512' }, false, [
+        'sign'
+    ]);
+}
+async function hmacSign(key, data) {
+    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.sign('HMAC', key, data));
+}
+// ============================================
+// PBKDF2 → AES-CTR (for pairing code crypto)
+// ============================================
+async function pbkdf2DeriveAesCtrKey(password, salt, iterations) {
+    const imported = await node_crypto_1.webcrypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, [
+        'deriveKey'
+    ]);
+    return node_crypto_1.webcrypto.subtle.deriveKey({
+        name: 'PBKDF2',
+        hash: 'SHA-256',
+        salt,
+        iterations
+    }, imported, {
+        name: 'AES-CTR',
+        length: 256
+    }, false, ['encrypt', 'decrypt']);
+}
+// ============================================
+// AES-CTR (for pairing code crypto)
+// ============================================
+async function aesCtrEncrypt(key, counter, plaintext) {
+    const result = await node_crypto_1.webcrypto.subtle.encrypt({ name: 'AES-CTR', counter, length: 64 }, key, plaintext);
+    return (0, bytes_1.toBytesView)(result);
+}
+async function aesCtrDecrypt(key, counter, ciphertext) {
+    const result = await node_crypto_1.webcrypto.subtle.decrypt({ name: 'AES-CTR', counter, length: 64 }, key, ciphertext);
+    return (0, bytes_1.toBytesView)(result);
+}
+// ============================================
+// Ed25519 raw verify (for Signal variant sigs)
+// ============================================
+async function ed25519VerifyRaw(publicKey, signature, message) {
+    const cryptoKey = await node_crypto_1.webcrypto.subtle.importKey('raw', publicKey, { name: 'Ed25519' }, false, ['verify']);
+    return node_crypto_1.webcrypto.subtle.verify('Ed25519', cryptoKey, signature, message);
+}

package/dist/crypto/core/random.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomBytesAsync = randomBytesAsync;
+exports.randomIntAsync = randomIntAsync;
+const node_crypto_1 = require("node:crypto");
+const bytes_1 = require("../../util/bytes");
+/**
+ * Generates cryptographically secure random bytes
+ */
+function randomBytesAsync(size) {
+    return new Promise((resolve, reject) => {
+        (0, node_crypto_1.randomBytes)(size, (error, buffer) => {
+            if (error)
+                reject(error);
+            else
+                resolve((0, bytes_1.toBytesView)(buffer));
+        });
+    });
+}
+/**
+ * Generates a cryptographically secure random integer in the range [min, max)
+ */
+function randomIntAsync(min, max) {
+    return new Promise((resolve, reject) => {
+        (0, node_crypto_1.randomInt)(min, max, (error, value) => {
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        });
+    });
+}

package/dist/crypto/curves/Ed25519.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ed25519 = void 0;
+const node_crypto_1 = require("node:crypto");
+const encoding_1 = require("../core/encoding");
+const constants_1 = require("../curves/constants");
+const types_1 = require("../curves/types");
+const bytes_1 = require("../../util/bytes");
+class Ed25519 {
+    static async generateKeyPair() {
+        const keys = (await node_crypto_1.webcrypto.subtle.generateKey({ name: 'Ed25519' }, true, [
+            'sign',
+            'verify'
+        ]));
+        const privateJwk = await node_crypto_1.webcrypto.subtle.exportKey('jwk', keys.privateKey);
+        return {
+            pubKey: (0, encoding_1.decodeBase64Url)(privateJwk.x, 'ed25519 public key'),
+            privKey: (0, encoding_1.decodeBase64Url)(privateJwk.d, 'ed25519 private key')
+        };
+    }
+    static async keyPairFromPrivateKey(privKey) {
+        (0, encoding_1.assert32)(privKey, 'ed25519 private key');
+        const privateKey = await node_crypto_1.webcrypto.subtle.importKey('pkcs8', (0, types_1.pkcs8FromRawPrivate)(constants_1.ED25519_PKCS8_PREFIX, privKey), { name: 'Ed25519' }, true, ['sign']);
+        const privateJwk = await node_crypto_1.webcrypto.subtle.exportKey('jwk', privateKey);
+        return {
+            pubKey: (0, encoding_1.decodeBase64Url)(privateJwk.x, 'ed25519 public key'),
+            privKey: (0, encoding_1.decodeBase64Url)(privateJwk.d, 'ed25519 private key')
+        };
+    }
+    static async sign(message, privKey) {
+        (0, encoding_1.assert32)(privKey, 'ed25519 private key');
+        const privateKey = await node_crypto_1.webcrypto.subtle.importKey('pkcs8', (0, types_1.pkcs8FromRawPrivate)(constants_1.ED25519_PKCS8_PREFIX, privKey), { name: 'Ed25519' }, false, ['sign']);
+        const signature = await node_crypto_1.webcrypto.subtle.sign('Ed25519', privateKey, message);
+        return (0, bytes_1.toBytesView)(signature);
+    }
+    static async verify(message, signature, pubKey) {
+        (0, encoding_1.assert32)(pubKey, 'ed25519 public key');
+        const publicKey = await node_crypto_1.webcrypto.subtle.importKey('raw', pubKey, { name: 'Ed25519' }, false, ['verify']);
+        return node_crypto_1.webcrypto.subtle.verify('Ed25519', publicKey, signature, message);
+    }
+}
+exports.Ed25519 = Ed25519;

package/dist/crypto/curves/X25519.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.X25519 = void 0;
+exports.clampCurvePrivateKeyInPlace = clampCurvePrivateKeyInPlace;
+exports.montgomeryToEdwardsPublic = montgomeryToEdwardsPublic;
+const node_crypto_1 = require("node:crypto");
+const encoding_1 = require("../core/encoding");
+const constants_1 = require("../curves/constants");
+const types_1 = require("../curves/types");
+const le_1 = require("../math/le");
+const mod_1 = require("../math/mod");
+const bytes_1 = require("../../util/bytes");
+function clampCurvePrivateKeyInPlace(privateKey) {
+    if (privateKey.length !== 32) {
+        throw new Error(`invalid curve25519 private key length ${privateKey.length}`);
+    }
+    privateKey[0] &= 248;
+    privateKey[31] &= 127;
+    privateKey[31] |= 64;
+    return privateKey;
+}
+function montgomeryToEdwardsPublic(curvePublicKey, signBit) {
+    if (curvePublicKey.length !== 32) {
+        throw new Error(`invalid curve25519 public key length ${curvePublicKey.length}`);
+    }
+    const x = (0, le_1.bytesToBigIntLE)(curvePublicKey);
+    if (x === mod_1.FIELD_P - 1n) {
+        throw new Error('invalid curve25519 low-order public key');
+    }
+    const y = (0, mod_1.mod)((x - 1n) * (0, mod_1.modInv)(x + 1n));
+    const encoded = (0, le_1.bigIntToBytesLE)(y, 32);
+    encoded[31] = (encoded[31] & 0x7f) | (signBit & 0x80);
+    return encoded;
+}
+class X25519 {
+    static async generateKeyPair() {
+        const keys = (await node_crypto_1.webcrypto.subtle.generateKey({ name: 'X25519' }, true, [
+            'deriveBits'
+        ]));
+        const privateJwk = await node_crypto_1.webcrypto.subtle.exportKey('jwk', keys.privateKey);
+        return {
+            pubKey: (0, encoding_1.decodeBase64Url)(privateJwk.x, 'x25519 public key'),
+            privKey: (0, encoding_1.decodeBase64Url)(privateJwk.d, 'x25519 private key')
+        };
+    }
+    static async keyPairFromPrivateKey(privKey) {
+        (0, encoding_1.assert32)(privKey, 'x25519 private key');
+        const privateKey = await node_crypto_1.webcrypto.subtle.importKey('pkcs8', (0, types_1.pkcs8FromRawPrivate)(constants_1.X25519_PKCS8_PREFIX, privKey), { name: 'X25519' }, true, ['deriveBits']);
+        const privateJwk = await node_crypto_1.webcrypto.subtle.exportKey('jwk', privateKey);
+        return {
+            pubKey: (0, encoding_1.decodeBase64Url)(privateJwk.x, 'x25519 public key'),
+            privKey: (0, encoding_1.decodeBase64Url)(privateJwk.d, 'x25519 private key')
+        };
+    }
+    static async scalarMult(privKey, pubKey) {
+        (0, encoding_1.assert32)(privKey, 'x25519 private key');
+        (0, encoding_1.assert32)(pubKey, 'x25519 public key');
+        const privateKey = await node_crypto_1.webcrypto.subtle.importKey('pkcs8', (0, types_1.pkcs8FromRawPrivate)(constants_1.X25519_PKCS8_PREFIX, privKey), { name: 'X25519' }, false, ['deriveBits']);
+        const publicKey = await node_crypto_1.webcrypto.subtle.importKey('raw', pubKey, { name: 'X25519' }, false, []);
+        const sharedBits = await node_crypto_1.webcrypto.subtle.deriveBits({ name: 'X25519', public: publicKey }, privateKey, 256);
+        return (0, bytes_1.toBytesView)(sharedBits);
+    }
+}
+exports.X25519 = X25519;

package/dist/crypto/curves/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ED25519_PKCS8_PREFIX = exports.X25519_PKCS8_PREFIX = void 0;
+const bytes_1 = require("../../util/bytes");
+exports.X25519_PKCS8_PREFIX = (0, bytes_1.hexToBytes)('302e020100300506032b656e04220420');
+exports.ED25519_PKCS8_PREFIX = (0, bytes_1.hexToBytes)('302e020100300506032b657004220420');

package/dist/crypto/curves/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pkcs8FromRawPrivate = pkcs8FromRawPrivate;
+function pkcs8FromRawPrivate(prefix, raw) {
+    const out = new Uint8Array(prefix.length + raw.length);
+    out.set(prefix, 0);
+    out.set(raw, prefix.length);
+    return out;
+}

package/dist/crypto/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.X25519 = exports.Ed25519 = void 0;
+__exportStar(require("./core"), exports);
+var Ed25519_1 = require("./curves/Ed25519");
+Object.defineProperty(exports, "Ed25519", { enumerable: true, get: function () { return Ed25519_1.Ed25519; } });
+var X25519_1 = require("./curves/X25519");
+Object.defineProperty(exports, "X25519", { enumerable: true, get: function () { return X25519_1.X25519; } });

package/dist/crypto/math/constants.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDENTITY_POINT = exports.BASE_POINT = exports.TWO_D = exports.EDWARDS_D = exports.GROUP_L = exports.FIELD_P = void 0;
+exports.FIELD_P = (1n << 255n) - 19n;
+exports.GROUP_L = (1n << 252n) + 27742317777372353535851937790883648493n;
+function modField(value) {
+    const remainder = value % exports.FIELD_P;
+    return remainder >= 0n ? remainder : remainder + exports.FIELD_P;
+}
+function modPowField(base, exponent) {
+    let result = 1n;
+    let current = modField(base);
+    let power = exponent;
+    while (power > 0n) {
+        if ((power & 1n) === 1n) {
+            result = modField(result * current);
+        }
+        current = modField(current * current);
+        power >>= 1n;
+    }
+    return result;
+}
+function modInvField(value) {
+    if (value === 0n) {
+        throw new Error('field inversion by zero');
+    }
+    return modPowField(value, exports.FIELD_P - 2n);
+}
+const BASE_X = 15112221349535400772501151409588531511454012693041857206046113283949847762202n;
+const BASE_Y = 46316835694926478169428394003475163141307993866256225615783033603165251855960n;
+exports.EDWARDS_D = modField(-121665n * modInvField(121666n));
+exports.TWO_D = modField(2n * exports.EDWARDS_D);
+exports.BASE_POINT = Object.freeze({
+    x: BASE_X,
+    y: BASE_Y,
+    z: 1n,
+    t: modField(BASE_X * BASE_Y)
+});
+exports.IDENTITY_POINT = Object.freeze({
+    x: 0n,
+    y: 1n,
+    z: 1n,
+    t: 0n
+});

package/dist/crypto/math/edwards.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scalarMultBase = scalarMultBase;
+exports.encodeExtendedPoint = encodeExtendedPoint;
+const constants_1 = require("../math/constants");
+const le_1 = require("../math/le");
+const mod_1 = require("../math/mod");
+function addPoint(a, b) {
+    const y1MinusX1 = (0, mod_1.mod)(a.y - a.x);
+    const y2MinusX2 = (0, mod_1.mod)(b.y - b.x);
+    const y1PlusX1 = (0, mod_1.mod)(a.y + a.x);
+    const y2PlusX2 = (0, mod_1.mod)(b.y + b.x);
+    const aTerm = (0, mod_1.mod)(y1MinusX1 * y2MinusX2);
+    const bTerm = (0, mod_1.mod)(y1PlusX1 * y2PlusX2);
+    const cTerm = (0, mod_1.mod)(constants_1.TWO_D * a.t * b.t);
+    const dTerm = (0, mod_1.mod)(2n * a.z * b.z);
+    const eTerm = (0, mod_1.mod)(bTerm - aTerm);
+    const fTerm = (0, mod_1.mod)(dTerm - cTerm);
+    const gTerm = (0, mod_1.mod)(dTerm + cTerm);
+    const hTerm = (0, mod_1.mod)(bTerm + aTerm);
+    return {
+        x: (0, mod_1.mod)(eTerm * fTerm),
+        y: (0, mod_1.mod)(gTerm * hTerm),
+        z: (0, mod_1.mod)(fTerm * gTerm),
+        t: (0, mod_1.mod)(eTerm * hTerm)
+    };
+}
+function doublePoint(point) {
+    const aTerm = (0, mod_1.mod)(point.x * point.x);
+    const bTerm = (0, mod_1.mod)(point.y * point.y);
+    const cTerm = (0, mod_1.mod)(2n * point.z * point.z);
+    const dTerm = (0, mod_1.mod)(-aTerm);
+    const eTerm = (0, mod_1.mod)((0, mod_1.mod)((point.x + point.y) * (point.x + point.y)) - aTerm - bTerm);
+    const gTerm = (0, mod_1.mod)(dTerm + bTerm);
+    const fTerm = (0, mod_1.mod)(gTerm - cTerm);
+    const hTerm = (0, mod_1.mod)(dTerm - bTerm);
+    return {
+        x: (0, mod_1.mod)(eTerm * fTerm),
+        y: (0, mod_1.mod)(gTerm * hTerm),
+        z: (0, mod_1.mod)(fTerm * gTerm),
+        t: (0, mod_1.mod)(eTerm * hTerm)
+    };
+}
+function scalarMultBase(scalar) {
+    let k = (0, mod_1.modGroup)(scalar);
+    let result = constants_1.IDENTITY_POINT;
+    let addend = constants_1.BASE_POINT;
+    while (k > 0n) {
+        if ((k & 1n) === 1n) {
+            result = addPoint(result, addend);
+        }
+        addend = doublePoint(addend);
+        k >>= 1n;
+    }
+    return result;
+}
+function encodeExtendedPoint(point) {
+    const zInv = (0, mod_1.modInv)(point.z);
+    const x = (0, mod_1.mod)(point.x * zInv);
+    const y = (0, mod_1.mod)(point.y * zInv);
+    const encoded = (0, le_1.bigIntToBytesLE)(y, 32);
+    encoded[31] = (encoded[31] & 0x7f) | Number((x & 1n) << 7n);
+    return encoded;
+}

package/dist/crypto/math/le.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesToBigIntLE = bytesToBigIntLE;
+exports.bigIntToBytesLE = bigIntToBytesLE;
+function bytesToBigIntLE(bytes) {
+    let out = 0n;
+    for (let i = bytes.length - 1; i >= 0; i -= 1) {
+        out = (out << 8n) + BigInt(bytes[i]);
+    }
+    return out;
+}
+function bigIntToBytesLE(value, length) {
+    const out = new Uint8Array(length);
+    let current = value;
+    for (let i = 0; i < length; i += 1) {
+        out[i] = Number(current & 0xffn);
+        current >>= 8n;
+    }
+    return out;
+}

package/dist/crypto/math/mod.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GROUP_L = exports.FIELD_P = void 0;
+exports.mod = mod;
+exports.modGroup = modGroup;
+exports.modInv = modInv;
+const constants_1 = require("../math/constants");
+Object.defineProperty(exports, "FIELD_P", { enumerable: true, get: function () { return constants_1.FIELD_P; } });
+Object.defineProperty(exports, "GROUP_L", { enumerable: true, get: function () { return constants_1.GROUP_L; } });
+function mod(value, modulus = constants_1.FIELD_P) {
+    const remainder = value % modulus;
+    return remainder >= 0n ? remainder : remainder + modulus;
+}
+function modGroup(value) {
+    return mod(value, constants_1.GROUP_L);
+}
+function modInv(value, modulus = constants_1.FIELD_P) {
+    if (value === 0n) {
+        throw new Error('field inversion by zero');
+    }
+    return modPow(value, modulus - 2n, modulus);
+}
+function modPow(base, exponent, modulus) {
+    if (modulus <= 0n) {
+        throw new Error('modulus must be positive');
+    }
+    let result = 1n;
+    let current = ((base % modulus) + modulus) % modulus;
+    let e = exponent;
+    while (e > 0n) {
+        if ((e & 1n) === 1n) {
+            result = (result * current) % modulus;
+        }
+        current = (current * current) % modulus;
+        e >>= 1n;
+    }
+    return result;
+}

package/dist/crypto/math/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });