@minionry/minion 0.7.36

package/vendor/e2ee/src/index.js

@@ -0,0 +1,310 @@
+const NONCE_BYTES = 12;
+const X25519_PUBLIC_KEY_BYTES = 32;
+let cryptoProviderPromise;
+function bytes(view) {
+    return view;
+}
+function resolveCrypto() {
+    cryptoProviderPromise ??= (async () => {
+        const globalCrypto = globalThis.crypto;
+        if (globalCrypto?.subtle)
+            return globalCrypto;
+        const specifier = 'node:crypto';
+        const nodeCrypto = (await import(/* @vite-ignore */ specifier));
+        return nodeCrypto.webcrypto;
+    })();
+    return cryptoProviderPromise;
+}
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder('utf-8', { fatal: true });
+export function utf8Encode(text) {
+    return textEncoder.encode(text);
+}
+export function utf8Decode(bytes) {
+    return textDecoder.decode(bytes);
+}
+const B64U_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+const B64U_LOOKUP = (() => {
+    const lookup = new Int16Array(128).fill(-1);
+    for (let i = 0; i < B64U_ALPHABET.length; i++) {
+        lookup[B64U_ALPHABET.charCodeAt(i)] = i;
+    }
+    return lookup;
+})();
+function nodeBuffer() {
+    const ctor = globalThis.Buffer;
+    return ctor && typeof ctor.from === 'function' ? ctor : undefined;
+}
+function assertCanonicalBase64Url(encoded) {
+    const remainder = encoded.length % 4;
+    if (remainder === 1) {
+        throw new Error('e2ee: invalid base64url length');
+    }
+    if (!/^[A-Za-z0-9_-]*$/.test(encoded)) {
+        throw new Error('e2ee: invalid base64url character');
+    }
+    if (remainder !== 0) {
+        const lastSextet = B64U_LOOKUP[encoded.charCodeAt(encoded.length - 1)];
+        if ((lastSextet & (remainder === 2 ? 0x0f : 0x03)) !== 0) {
+            throw new Error('e2ee: non-canonical base64url encoding');
+        }
+    }
+}
+export function toBase64Url(bytes) {
+    const BufferCtor = nodeBuffer();
+    if (BufferCtor) {
+        const view = bytes;
+        return BufferCtor.from(view.buffer, view.byteOffset, view.byteLength).toString('base64url');
+    }
+    const withNative = bytes;
+    if (typeof withNative.toBase64 === 'function') {
+        return withNative.toBase64({ alphabet: 'base64url', omitPadding: true });
+    }
+    if (typeof btoa === 'function') {
+        let binary = '';
+        for (let i = 0; i < bytes.length; i += 0x8000) {
+            binary += String.fromCharCode.apply(null, bytes.subarray(i, i + 0x8000));
+        }
+        return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    }
+    return toBase64UrlScalar(bytes);
+}
+function toBase64UrlScalar(bytes) {
+    let out = '';
+    for (let i = 0; i < bytes.length; i += 3) {
+        const b0 = bytes[i];
+        const b1 = i + 1 < bytes.length ? bytes[i + 1] : undefined;
+        const b2 = i + 2 < bytes.length ? bytes[i + 2] : undefined;
+        out += B64U_ALPHABET[b0 >> 2];
+        out += B64U_ALPHABET[((b0 & 0x03) << 4) | ((b1 ?? 0) >> 4)];
+        if (b1 !== undefined)
+            out += B64U_ALPHABET[((b1 & 0x0f) << 2) | ((b2 ?? 0) >> 6)];
+        if (b2 !== undefined)
+            out += B64U_ALPHABET[b2 & 0x3f];
+    }
+    return out;
+}
+export function fromBase64Url(encoded) {
+    assertCanonicalBase64Url(encoded);
+    const BufferCtor = nodeBuffer();
+    if (BufferCtor) {
+        const decoded = BufferCtor.from(encoded, 'base64url');
+        return new Uint8Array(decoded.buffer, decoded.byteOffset, decoded.byteLength);
+    }
+    const ctor = Uint8Array;
+    if (typeof ctor.fromBase64 === 'function') {
+        return ctor.fromBase64(encoded, { alphabet: 'base64url' });
+    }
+    if (typeof atob === 'function') {
+        const standard = encoded.replace(/-/g, '+').replace(/_/g, '/');
+        const binary = atob(standard + '='.repeat((4 - (standard.length % 4)) % 4));
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            bytes[i] = binary.charCodeAt(i);
+        return bytes;
+    }
+    return fromBase64UrlScalar(encoded);
+}
+function fromBase64UrlScalar(encoded) {
+    const bytes = new Uint8Array(Math.floor((encoded.length * 3) / 4));
+    let bits = 0;
+    let bitCount = 0;
+    let offset = 0;
+    for (let i = 0; i < encoded.length; i++) {
+        bits = (bits << 6) | B64U_LOOKUP[encoded.charCodeAt(i)];
+        bitCount += 6;
+        if (bitCount >= 8) {
+            bitCount -= 8;
+            bytes[offset++] = (bits >> bitCount) & 0xff;
+        }
+    }
+    return bytes;
+}
+export async function generateIdentityKeyPair() {
+    const { subtle } = await resolveCrypto();
+    const generated = await subtle.generateKey({ name: 'X25519' }, true, ['deriveBits']);
+    if (generated === null ||
+        typeof generated !== 'object' ||
+        !('publicKey' in generated) ||
+        !('privateKey' in generated)) {
+        throw new Error('e2ee: X25519 generateKey did not return a key pair');
+    }
+    const pair = generated;
+    const publicKey = new Uint8Array(await subtle.exportKey('raw', pair.publicKey));
+    const privateKey = new Uint8Array(await subtle.exportKey('pkcs8', pair.privateKey));
+    return { publicKey, privateKey };
+}
+export async function agree(theirPublicKey, myPrivateKey) {
+    if (theirPublicKey.length !== X25519_PUBLIC_KEY_BYTES) {
+        throw new Error('e2ee: X25519 public key must be exactly 32 raw bytes');
+    }
+    const { subtle } = await resolveCrypto();
+    const publicKey = await subtle.importKey('raw', bytes(theirPublicKey), { name: 'X25519' }, false, []);
+    const privateKey = await subtle.importKey('pkcs8', bytes(myPrivateKey), { name: 'X25519' }, false, [
+        'deriveBits',
+    ]);
+    const sharedSecret = new Uint8Array(await subtle.deriveBits({ name: 'X25519', public: publicKey }, privateKey, 256));
+    let accumulated = 0;
+    for (const byte of sharedSecret)
+        accumulated |= byte;
+    if (accumulated === 0) {
+        throw new Error('e2ee: X25519 agreement produced an all-zero secret (low-order public key)');
+    }
+    return sharedSecret;
+}
+export async function deriveKey(secret, salt, info) {
+    const { subtle } = await resolveCrypto();
+    const ikm = await subtle.importKey('raw', bytes(secret), 'HKDF', false, ['deriveKey']);
+    return subtle.deriveKey({
+        name: 'HKDF',
+        hash: 'SHA-256',
+        salt: bytes(salt),
+        info: bytes(typeof info === 'string' ? utf8Encode(info) : info),
+    }, ikm, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']);
+}
+export async function seal(key, plaintext, aad, nonce) {
+    const chosenNonce = nonce ?? (await randomNonce());
+    if (chosenNonce.length !== NONCE_BYTES) {
+        throw new Error('e2ee: nonce must be exactly 12 bytes');
+    }
+    const { subtle } = await resolveCrypto();
+    const ct = new Uint8Array(await subtle.encrypt({ name: 'AES-GCM', iv: bytes(chosenNonce), additionalData: bytes(aad), tagLength: 128 }, key, bytes(plaintext)));
+    return { nonce: chosenNonce, ct };
+}
+export async function open(key, box, aad) {
+    if (box.nonce.length !== NONCE_BYTES) {
+        throw new Error('e2ee: nonce must be exactly 12 bytes');
+    }
+    const { subtle } = await resolveCrypto();
+    try {
+        return new Uint8Array(await subtle.decrypt({ name: 'AES-GCM', iv: bytes(box.nonce), additionalData: bytes(aad), tagLength: 128 }, key, bytes(box.ct)));
+    }
+    catch (cause) {
+        throw new Error('e2ee: open failed — ciphertext, key, nonce, or AAD mismatch', { cause });
+    }
+}
+export async function randomNonce() {
+    const provider = await resolveCrypto();
+    return provider.getRandomValues(new Uint8Array(NONCE_BYTES));
+}
+export function counterNonce(dir, seq) {
+    if (dir !== 'wc' && dir !== 'cw') {
+        throw new Error("e2ee: direction must be 'wc' or 'cw'");
+    }
+    let sequence;
+    if (typeof seq === 'bigint') {
+        sequence = seq;
+    }
+    else {
+        if (!Number.isSafeInteger(seq) || seq < 0) {
+            throw new Error('e2ee: seq must be a non-negative safe integer');
+        }
+        sequence = BigInt(seq);
+    }
+    if (sequence < 0n || sequence > 0xffffffffffffffffn) {
+        throw new Error('e2ee: seq must fit in 64 bits');
+    }
+    const nonce = new Uint8Array(NONCE_BYTES);
+    nonce[0] = dir.charCodeAt(0);
+    nonce[1] = dir.charCodeAt(1);
+    new DataView(nonce.buffer).setBigUint64(4, sequence);
+    return nonce;
+}
+export function buildAad(fields) {
+    const { v, type, msgId, sid, dir, seq, epoch } = fields;
+    if (!Number.isSafeInteger(v) || v < 1) {
+        throw new Error('e2ee: AAD v must be an integer ≥ 1');
+    }
+    if (typeof type !== 'string' || type.length === 0) {
+        throw new Error('e2ee: AAD type must be a non-empty string');
+    }
+    if (msgId !== undefined && msgId !== null && typeof msgId !== 'string') {
+        throw new Error('e2ee: AAD msgId must be a string or null');
+    }
+    if (typeof sid !== 'string' || sid.length === 0) {
+        throw new Error('e2ee: AAD sid must be a non-empty string');
+    }
+    if (dir !== 'wc' && dir !== 'cw') {
+        throw new Error("e2ee: AAD dir must be 'wc' or 'cw'");
+    }
+    if (!Number.isSafeInteger(seq) || seq < 0) {
+        throw new Error('e2ee: AAD seq must be a non-negative safe integer');
+    }
+    if (!Number.isSafeInteger(epoch) || epoch < 0) {
+        throw new Error('e2ee: AAD epoch must be a non-negative safe integer');
+    }
+    return utf8Encode(JSON.stringify([v, type, msgId ?? null, sid, dir, seq, epoch]));
+}
+export const SAFETY_NUMBER_INFO = 'minionry/e2ee/safety-number/v1';
+export const SAFETY_NUMBER_GROUPS = 12;
+const SAFETY_NUMBER_GROUP_BYTES = 5;
+const SAFETY_NUMBER_SALT = new Uint8Array(32);
+function compareBytes(a, b) {
+    const length = Math.min(a.length, b.length);
+    for (let i = 0; i < length; i++) {
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    }
+    return a.length - b.length;
+}
+export async function deriveSafetyNumber(publicKeyA, publicKeyB) {
+    if (publicKeyA.length !== X25519_PUBLIC_KEY_BYTES ||
+        publicKeyB.length !== X25519_PUBLIC_KEY_BYTES) {
+        throw new Error('e2ee: safety numbers take two raw 32-byte X25519 public keys');
+    }
+    const [lower, higher] = compareBytes(publicKeyA, publicKeyB) <= 0 ? [publicKeyA, publicKeyB] : [publicKeyB, publicKeyA];
+    const ikm = new Uint8Array(X25519_PUBLIC_KEY_BYTES * 2);
+    ikm.set(lower, 0);
+    ikm.set(higher, X25519_PUBLIC_KEY_BYTES);
+    const { subtle } = await resolveCrypto();
+    const baseKey = await subtle.importKey('raw', bytes(ikm), 'HKDF', false, ['deriveBits']);
+    const okm = new Uint8Array(await subtle.deriveBits({
+        name: 'HKDF',
+        hash: 'SHA-256',
+        salt: bytes(SAFETY_NUMBER_SALT),
+        info: bytes(utf8Encode(SAFETY_NUMBER_INFO)),
+    }, baseKey, SAFETY_NUMBER_GROUPS * SAFETY_NUMBER_GROUP_BYTES * 8));
+    const groups = [];
+    for (let group = 0; group < SAFETY_NUMBER_GROUPS; group++) {
+        let value = 0;
+        for (let i = 0; i < SAFETY_NUMBER_GROUP_BYTES; i++) {
+            value = value * 256 + okm[group * SAFETY_NUMBER_GROUP_BYTES + i];
+        }
+        groups.push(String(value % 100000).padStart(5, '0'));
+    }
+    return groups.join(' ');
+}
+export const CONTROL_MESSAGE_TYPES = [
+    'auth',
+    'ping',
+    'pong',
+    'presence_update',
+    'reportUsage',
+    'sdkGrantState',
+    'auth_ok',
+    'paired',
+    'clientAuthExpired',
+    'client_disconnected',
+    'clientOffline',
+    'cliUpdateRequired',
+    'cliVersionCleared',
+    'orchestra_connected',
+    'orchestra_disconnected',
+    'orchestras_snapshot',
+    'permissionDenied',
+    'presence_joined',
+    'presence_left',
+    'presence_snapshot',
+    'presence_updated',
+    'web_connected',
+    'web_disconnected',
+    'web_viewer_connected',
+    'web_viewer_disconnected',
+    'e2ee_key_request',
+    'e2ee_key',
+    'e2ee_state',
+];
+const CONTROL_MESSAGE_TYPE_SET = new Set(CONTROL_MESSAGE_TYPES);
+export function isContentMessageType(type) {
+    return !CONTROL_MESSAGE_TYPE_SET.has(type);
+}