@rikaidev/yomi 0.2.6

package/dist/line/core/e2ee/keys/group-key.js

@@ -0,0 +1,260 @@
+import { Buffer } from 'node:buffer';
+import { aesDecrypt, computeSharedSecret, deriveKeyAndIV, } from '../crypto/crypto-primitives.js';
+import { getPeerPublicKey } from './peer-key.js';
+/**
+ * Read one field from a raw shared-key payload using thrift or named access.
+ *
+ * @param shared - Raw shared-key payload.
+ * @param tupleField - Numeric thrift field id.
+ * @param namedField - Named object field.
+ * @returns Raw field value or null.
+ */
+function readSharedField(shared, tupleField, namedField) {
+    return shared?.[tupleField] ?? shared?.[namedField] ?? null;
+}
+/**
+ * Read one shared-key field and coerce it into a string with fallback support.
+ *
+ * @param shared - Raw shared-key payload.
+ * @param tupleField - Numeric thrift field id.
+ * @param namedField - Named object field.
+ * @param fallback - Fallback string when the field is absent.
+ * @returns String value.
+ */
+function readSharedString(shared, tupleField, namedField, fallback = '') {
+    return String(readSharedField(shared, tupleField, namedField) ?? fallback);
+}
+/**
+ * Extract structured fields from a raw LINE group shared key payload.
+ * Accepts both thrift tuple and named-property shapes.
+ *
+ * @param shared - Raw shared key payload
+ * @param receiverKeyId - Fallback receiver key ID
+ * @param senderMid - Fallback creator MID
+ * @param senderKeyId - Fallback creator key ID
+ * @returns Normalized fields needed for key derivation
+ */
+function extractSharedKeyFields(shared, receiverKeyId, senderMid, senderKeyId) {
+    const sharedReceiverKeyId = readSharedString(shared, 6, 'receiverKeyId', receiverKeyId);
+    const groupKeyId = readSharedString(shared, 2, 'groupKeyId', sharedReceiverKeyId);
+    const rawCreator = readSharedField(shared, 3, 'creator');
+    const creator = rawCreator == null ? senderMid : String(rawCreator);
+    const creatorKeyId = readSharedString(shared, 4, 'creatorKeyId', senderKeyId ?? '');
+    const encryptedSharedKey = readSharedField(shared, 7, 'encryptedSharedKey');
+    return {
+        creator,
+        creatorKeyId,
+        sharedReceiverKeyId,
+        encryptedSharedKey,
+        groupKeyId,
+    };
+}
+/**
+ * Check memory and persisted store for a cached group key.
+ *
+ * @param ctx - KeyManager context
+ * @param chatMid - Group chat MID
+ * @param receiverKeyId - Expected key ID
+ * @returns Cached group key or null
+ */
+async function lookupCachedGroupKey(ctx, chatMid, receiverKeyId) {
+    // Epoch-aware cache: keys are stored per (chat, groupKeyId) and never
+    // overwritten, so once this device has seen a group-key epoch it keeps
+    // decrypting that epoch's messages even after the group rekeys. Without a
+    // specific epoch (the send path asks for "latest"), skip the cache and let
+    // the caller fetch the current key from LINE.
+    if (!receiverKeyId) {
+        return null;
+    }
+    const cacheKey = `${chatMid}:${receiverKeyId}`;
+    const cached = ctx.groupKeys.get(cacheKey);
+    if (cached) {
+        ctx.logGroupKeyEvent('e2ee.group_key.cache_hit', {
+            chat: chatMid,
+            source: 'memory',
+            receiver_key_id: receiverKeyId,
+            group_key_id: cached.keyId,
+        });
+        return cached;
+    }
+    const store = ctx.getStore();
+    const persisted = await store?.get?.(`line_e2ee_group_by_mid:${cacheKey}`);
+    if (!persisted) {
+        return null;
+    }
+    const parsed = JSON.parse(persisted);
+    const groupKey = {
+        keyId: String(parsed.keyId),
+        privateKey: Buffer.from(parsed.privateKey, 'base64'),
+    };
+    ctx.groupKeys.set(cacheKey, groupKey);
+    ctx.logGroupKeyEvent('e2ee.group_key.cache_hit', {
+        chat: chatMid,
+        source: 'persisted',
+        receiver_key_id: receiverKeyId,
+        group_key_id: groupKey.keyId,
+    });
+    return groupKey;
+}
+/**
+ * Return a stable fetch key for one group-key resolution request.
+ *
+ * @param chatMid - Group chat MID
+ * @param receiverKeyId - Expected receiver key id
+ * @returns Stable in-flight fetch key
+ */
+function getGroupKeyFetchKey(chatMid, receiverKeyId) {
+    return `${chatMid}:${receiverKeyId}`;
+}
+/**
+ * Derive and cache a group key from the shared key payload.
+ *
+ * @param ctx - KeyManager context
+ * @param chatMid - Group chat MID
+ * @param shared - Raw shared key payload from LINE
+ * @param receiverKeyId - Receiver key ID fallback
+ * @param senderMid - Sender MID fallback
+ * @param senderKeyId - Sender key ID fallback
+ * @param resolutionSource - Label used in diagnostic logs
+ * @returns Derived group key
+ */
+async function deriveAndCacheGroupKey(ctx, chatMid, shared, receiverKeyId, senderMid, senderKeyId, resolutionSource) {
+    const { creator, creatorKeyId, sharedReceiverKeyId, encryptedSharedKey, groupKeyId, } = extractSharedKeyFields(shared, receiverKeyId, senderMid, senderKeyId);
+    const selfKey = ctx.getSelfKeyById(sharedReceiverKeyId);
+    if (!selfKey) {
+        ctx.raiseWarning('missing_self_key', {
+            receiverKeyId: sharedReceiverKeyId,
+            chatMid,
+        });
+        throw new Error(`Missing self E2EE key for receiverKeyId=${sharedReceiverKeyId}`);
+    }
+    if (!creator || !creatorKeyId || !encryptedSharedKey) {
+        throw new Error('Incomplete group shared key payload');
+    }
+    const selfMid = ctx.getProfileMid();
+    const creatorPublicKey = creator === selfMid
+        ? selfKey.publicKey
+        : await getPeerPublicKey(ctx, creator, creatorKeyId);
+    const aesSecret = computeSharedSecret(selfKey.privateKey, creatorPublicKey);
+    const { key, iv } = deriveKeyAndIV(aesSecret);
+    const raw = encryptedSharedKey;
+    const encrypted = Buffer.isBuffer(raw)
+        ? raw
+        : Buffer.from(raw, typeof raw === 'string' ? 'base64' : undefined);
+    const plainText = aesDecrypt(encrypted, key, iv);
+    const groupKey = { keyId: groupKeyId, privateKey: plainText };
+    // Cache under (chat, groupKeyId) — only ever add, never overwrite a
+    // different epoch, so a later rekey cannot strand messages this device can
+    // already read.
+    const cacheKey = `${chatMid}:${groupKey.keyId}`;
+    ctx.groupKeys.set(cacheKey, groupKey);
+    const store = ctx.getStore();
+    await store?.set?.(`line_e2ee_group_by_mid:${cacheKey}`, JSON.stringify({
+        keyId: groupKey.keyId,
+        privateKey: groupKey.privateKey.toString('base64'),
+    }));
+    ctx.logGroupKeyEvent('e2ee.group_key.resolved', {
+        chat: chatMid,
+        source: resolutionSource,
+        receiver_key_id: sharedReceiverKeyId,
+        creator,
+        creator_key_id: creatorKeyId,
+        group_key_id: groupKeyId,
+        encrypted_shared_key_bytes: encrypted.length,
+    });
+    return groupKey;
+}
+/**
+ * Resolve and cache the group shared key for a chat.
+ *
+ * Yomi is read/send-only over group keys: it resolves an EXISTING shared key
+ * or returns undefined. It NEVER registers (mints) a group key. Minting is an
+ * account-visible write that rotates the group's shared secret for every
+ * member; every message encrypted under the previous secret — all of it, for
+ * every sender — then fails to decrypt, and members who don't adopt the new
+ * secret are stranded too. Group-key lifecycle belongs to the official LINE
+ * clients / the primary device, never to Yomi.
+ *
+ * @param ctx - KeyManager context
+ * @param chatMid - Group chat MID
+ * @param receiverKeyId - Local receiver key ID
+ * @param senderMid - Sender MID
+ * @param senderKeyId - Sender key ID
+ * @returns Group key or undefined when unavailable
+ */
+export async function getGroupKey(ctx, chatMid, receiverKeyId, senderMid, senderKeyId) {
+    if (!receiverKeyId) {
+        const cachedLatest = await lookupCachedGroupKey(ctx, chatMid, null);
+        if (cachedLatest) {
+            return cachedLatest;
+        }
+    }
+    const cached = await lookupCachedGroupKey(ctx, chatMid, receiverKeyId);
+    if (cached) {
+        return cached;
+    }
+    const resolvedReceiverKeyId = receiverKeyId || 'latest';
+    const fetchKey = getGroupKeyFetchKey(chatMid, resolvedReceiverKeyId);
+    const inflight = ctx.groupKeyFetches.get(fetchKey);
+    if (inflight) {
+        ctx.logGroupKeyEvent('e2ee.group_key.fetch_join', {
+            chat: chatMid,
+            receiver_key_id: receiverKeyId,
+            inflight_receiver_key_id: inflight.receiverKeyId,
+        });
+        return inflight.promise;
+    }
+    const fetchPromise = (async () => {
+        const client = ctx.getClient();
+        let shared;
+        let resolutionSource = 'server_fetch';
+        try {
+            shared = await client?.getLastE2EEGroupSharedKey?.(2, chatMid);
+        }
+        catch (error) {
+            const code = typeof error?.data?.code === 'string' ? error.data.code : null;
+            const message = error?.message || String(error);
+            const shouldFallback = code === 'NOT_FOUND' ||
+                message.toLowerCase().includes('no valid group key');
+            if (!shouldFallback) {
+                ctx.logGroupKeyEvent('e2ee.group_key.fetch_failed', {
+                    chat: chatMid,
+                    receiver_key_id: receiverKeyId,
+                    code,
+                    error: message,
+                });
+                throw error;
+            }
+            resolutionSource = 'register_fallback';
+        }
+        if (!shared) {
+            // Yomi never mints. LINE has no readable group key for this
+            // (receiverKeyId, chat) — fail cleanly rather than register one and
+            // rotate the group's secret out from under every other member.
+            ctx.logGroupKeyEvent('e2ee.group_key.mint_suppressed', {
+                chat: chatMid,
+                receiver_key_id: receiverKeyId,
+            });
+        }
+        if (!shared) {
+            ctx.logGroupKeyEvent('e2ee.group_key.unavailable', {
+                chat: chatMid,
+                receiver_key_id: receiverKeyId,
+                source: resolutionSource,
+            });
+            return undefined;
+        }
+        return deriveAndCacheGroupKey(ctx, chatMid, shared, resolvedReceiverKeyId, senderMid, senderKeyId, resolutionSource);
+    })();
+    ctx.groupKeyFetches.set(fetchKey, {
+        receiverKeyId: resolvedReceiverKeyId,
+        promise: fetchPromise,
+    });
+    try {
+        return await fetchPromise;
+    }
+    finally {
+        ctx.groupKeyFetches.delete(fetchKey);
+    }
+}
+export { normalizeGroupPublicKeys } from './key-payload.js';

package/dist/line/core/e2ee/keys/key-manager.js

@@ -0,0 +1,231 @@
+import { Buffer } from 'node:buffer';
+import { generateKeyPairSync } from 'node:crypto';
+import { createCliLogger } from '../../../../util/log.js';
+import { tryDecrypt as tryDecryptFn } from './decrypt.js';
+import { encryptE2EEMessage as encryptE2EEMessageFn } from './encrypt.js';
+import { toChunkKeyId } from './message-crypto.js';
+const e2eeLog = createCliLogger('E2EE');
+/**
+ * KeyManager handles E2EE key generation and storage.
+ * Implements {@link KeyManagerContext} so it can be passed as `ctx` to module-level functions.
+ */
+export class KeyManager {
+    keys = new Map();
+    importedKeys = new Map();
+    selfKeyByMid = new Map();
+    peerPublicKeys = new Map();
+    groupKeys = new Map();
+    groupKeyFetches = new Map();
+    runtimeGetClient;
+    runtimeGetStore;
+    runtimeGetProfileMid;
+    emitWarning;
+    /**
+     * Generate a new X25519 key pair for E2EE.
+     * @returns Generated key pair
+     */
+    generateKeyPair() {
+        const keyPair = generateKeyPairSync('x25519');
+        return {
+            publicKey: keyPair.publicKey
+                .export({ type: 'spki', format: 'der' })
+                .slice(-32),
+            privateKey: keyPair.privateKey
+                .export({ type: 'pkcs8', format: 'der' })
+                .slice(-32),
+        };
+    }
+    /**
+     * Store a key pair for a user.
+     * @param userId - User identifier
+     * @param keyPair - Key pair to store
+     */
+    storeKey(userId, keyPair) {
+        this.keys.set(userId, keyPair);
+    }
+    /**
+     * Get a user's stored key pair.
+     * @param userId - User identifier.
+     * @returns Stored key pair when present.
+     */
+    getKey(userId) {
+        return this.keys.get(userId);
+    }
+    /**
+     * Check if a user has a stored key.
+     * @param userId - User identifier.
+     * @returns True when a key exists for the user.
+     */
+    hasKey(userId) {
+        return this.keys.has(userId);
+    }
+    /**
+     * Import E2EE keys decoded from the login keychain.
+     * Called after successful login with the decrypted key list.
+     * @param keys - Array of key objects from decryptKeyChain
+     */
+    importKeys(keys) {
+        for (const k of keys) {
+            const keyId = String(k.keyId);
+            const importedKey = {
+                keyId,
+                version: k.version != null ? String(k.version) : undefined,
+                createdTime: k.createdTime != null ? Number(k.createdTime) : null,
+                publicKey: Buffer.isBuffer(k.publicKey)
+                    ? k.publicKey
+                    : Buffer.from(k.publicKey),
+                privateKey: Buffer.isBuffer(k.privateKey)
+                    ? k.privateKey
+                    : Buffer.from(k.privateKey),
+            };
+            this.importedKeys.set(keyId, importedKey);
+            if (k.mid) {
+                this.selfKeyByMid.set(String(k.mid), importedKey);
+            }
+        }
+        this.resolveLogger().info('e2ee.keys.imported', {
+            count: keys.length,
+        });
+    }
+    /**
+     * Associate an imported self key with the authenticated user's MID.
+     * @param mid - Authenticated LINE MID
+     */
+    bindSelfKeysToMid(mid) {
+        const latest = [...this.importedKeys.values()].sort((a, b) => (b.createdTime ?? 0) - (a.createdTime ?? 0))[0];
+        if (latest) {
+            this.selfKeyByMid.set(mid, latest);
+        }
+    }
+    /**
+     * Return a self key by stored key ID.
+     * @param keyId - Imported self key identifier.
+     * @returns Matching imported key when present.
+     */
+    getSelfKeyById(keyId) {
+        return this.importedKeys.get(String(keyId));
+    }
+    /**
+     * Return the authenticated user's current self key by MID.
+     * @param mid - Authenticated LINE MID.
+     * @returns Matching imported key when present.
+     */
+    getSelfKeyByMid(mid) {
+        return this.selfKeyByMid.get(String(mid));
+    }
+    /**
+     * Clear only runtime-discovered E2EE caches while preserving imported self keys.
+     *
+     * This is used by session-level recovery: peer public keys and group shared
+     * keys may have become stale or incomplete, but the authenticated self key
+     * material should survive across retries until the user explicitly logs out.
+     */
+    resetTransientCaches() {
+        this.peerPublicKeys.clear();
+        this.groupKeys.clear();
+        this.groupKeyFetches.clear();
+    }
+    /**
+     * Bind runtime dependencies required for async E2EE key resolution.
+     * @param deps - Runtime dependency providers.
+     * @param deps.getClient - Returns the active LINE client.
+     * @param deps.getStore - Returns the credential store.
+     * @param deps.getProfileMid - Returns the authenticated profile MID.
+     * @param deps.emitWarning - Emits a recovery warning to the service.
+     */
+    setRuntime(deps) {
+        this.runtimeGetClient = deps.getClient;
+        this.runtimeGetStore = deps.getStore;
+        this.runtimeGetProfileMid = deps.getProfileMid;
+        this.emitWarning = deps.emitWarning;
+    }
+    /**
+     * Return the active LINE client when runtime dependencies are bound.
+     * @returns Active LINE client.
+     */
+    getClient() {
+        return this.runtimeGetClient?.();
+    }
+    /**
+     * Return the credential store when runtime dependencies are bound.
+     * @returns Credential store.
+     */
+    getStore() {
+        return this.runtimeGetStore?.();
+    }
+    /**
+     * Return the authenticated LINE MID when runtime dependencies are bound.
+     * @returns Authenticated LINE MID.
+     */
+    getProfileMid() {
+        return this.runtimeGetProfileMid?.();
+    }
+    /**
+     * Emit a recovery warning if the service is available.
+     * @param reason - Warning reason code.
+     * @param details - Additional warning metadata.
+     */
+    raiseWarning(reason, details = {}) {
+        this.emitWarning?.({ active: true, reason, ...details });
+    }
+    /**
+     * Emit one visible LINE runtime log for group-key diagnostics.
+     * @param event - Event name
+     * @param context - Structured payload
+     */
+    logGroupKeyEvent(event, context = {}) {
+        this.resolveLogger().info(event, context);
+    }
+    /**
+     * Emit one warning-level E2EE log through the shared CLI logger.
+     *
+     * @param event - Event name
+     * @param context - Structured payload
+     */
+    logE2EEWarning(event, context = {}) {
+        this.resolveLogger().warn(event, context);
+    }
+    /**
+     * Resolve the active E2EE logger using the shared logging contract.
+     *
+     * @returns Startup-aware CLI logger.
+     */
+    resolveLogger() {
+        const client = this.getClient();
+        return client?.startupFlowLogger || client?.logger || e2eeLog;
+    }
+    /**
+     * Attempt to decrypt an E2EE message using stored keys.
+     * Returns plaintext on success, or a no-op result for plaintext messages.
+     * @param msg - Parsed message object (from parsers.ts)
+     * @returns Decryption result with optional plaintext
+     */
+    async tryDecrypt(msg) {
+        return tryDecryptFn(this, msg);
+    }
+    /**
+     * Prepare an outbound LINE E2EE payload using the same chunk layout as linejs.
+     *
+     * The returned structure is transport-ready for TalkService sendMessage:
+     * `chunks` contains `[salt, ciphertext+tag, nonce, senderKeyIdBytes, receiverKeyIdBytes]`
+     * and `contentMetadata` includes the E2EE markers LINE expects for version 2.
+     *
+     * @param to - Target LINE MID
+     * @param data - Text or structured payload to encrypt
+     * @param contentType - LINE content type of the payload
+     * @returns Message chunks plus metadata required by LINE
+     */
+    async encryptE2EEMessage(to, data, contentType = 0) {
+        return encryptE2EEMessageFn(this, to, data, contentType);
+    }
+    /**
+     * Public wrapper used by logging/initializer layers to format key IDs from
+     * raw message chunks without duplicating chunk parsing logic outside E2EE.
+     *
+     * @param value - Raw LINE chunk value
+     * @returns Parsed decimal key ID or null
+     */
+    readChunkKeyId(value) {
+        return toChunkKeyId(value);
+    }
+}

package/dist/line/core/e2ee/keys/key-payload.js

@@ -0,0 +1,130 @@
+import { Buffer } from 'node:buffer';
+/**
+ * Read one normalized field from a negotiated public-key candidate payload.
+ *
+ * @param candidate - Raw candidate payload.
+ * @param fieldId - Target thrift field id.
+ * @returns Raw field value or null.
+ */
+function readCandidateField(candidate, fieldId) {
+    if (!candidate) {
+        return null;
+    }
+    if (fieldId === 2) {
+        return (candidate[2] ??
+            candidate.keyId ??
+            candidate.publicKey?.[2] ??
+            candidate.publicKey?.keyId ??
+            null);
+    }
+    return (candidate[4] ??
+        candidate.keyData ??
+        candidate.publicKey?.[4] ??
+        candidate.publicKey?.keyData ??
+        null);
+}
+/**
+ * Select the nested object that actually contains public key fields.
+ *
+ * @param raw - Raw negotiation response from LINE.
+ * @returns Normalized container object.
+ */
+function readPublicKeyContainer(raw) {
+    return raw?.[2] || raw?.publicKey || raw?.fields?.[2] || raw || null;
+}
+/**
+ * Read one normalized field from the selected negotiated public-key container.
+ *
+ * @param publicKey - Selected public-key container.
+ * @param raw - Raw negotiation response.
+ * @param fieldId - Target thrift field id.
+ * @returns Raw field value or null.
+ */
+function readNegotiatedValue(publicKey, raw, fieldId) {
+    if (fieldId === 2) {
+        return publicKey?.[2] ?? publicKey?.keyId ?? raw?.keyId ?? null;
+    }
+    return publicKey?.[4] ?? publicKey?.keyData ?? raw?.keyData ?? null;
+}
+/**
+ * Normalize raw key payloads into Buffer instances.
+ *
+ * @param keyData - Raw key payload from thrift or object responses.
+ * @returns Buffer instance or null when unsupported.
+ */
+export function toKeyBuffer(keyData) {
+    if (Buffer.isBuffer(keyData)) {
+        return keyData;
+    }
+    if (typeof keyData === 'string') {
+        return Buffer.from(keyData, 'base64');
+    }
+    if (keyData instanceof Uint8Array) {
+        return Buffer.from(keyData);
+    }
+    if (keyData instanceof ArrayBuffer) {
+        return Buffer.from(new Uint8Array(keyData));
+    }
+    return null;
+}
+/**
+ * Normalize the getLastE2EEPublicKeys response into a member->public-key map.
+ *
+ * linejs treats this response as an object keyed by member MID. Depending on
+ * our thrift decoder shape it may arrive as a plain object or as nested field
+ * tuples, so this helper accepts both and extracts only the fields required to
+ * register a new group key.
+ *
+ * @param raw - Raw getLastE2EEPublicKeys response
+ * @returns Map of member MID to key metadata
+ */
+export function normalizeGroupPublicKeys(raw) {
+    const result = new Map();
+    const entries = raw && typeof raw === 'object' ? Object.entries(raw) : [];
+    for (const [mid, value] of entries) {
+        const candidate = value;
+        const keyId = readCandidateField(candidate, 2);
+        const keyData = readCandidateField(candidate, 4);
+        if (keyId == null || !keyData) {
+            continue;
+        }
+        const normalizedKeyData = toKeyBuffer(keyData);
+        if (!normalizedKeyData) {
+            continue;
+        }
+        result.set(String(mid), {
+            keyId: String(keyId),
+            keyData: normalizedKeyData,
+        });
+    }
+    return result;
+}
+/**
+ * Normalize a negotiateE2EEPublicKey response into the key shape used by the
+ * local runtime. LINE returns slightly different nested structs depending on
+ * endpoint version and thrift decoder shape; this helper accepts either.
+ *
+ * @param raw - Raw negotiation response from the LINE Talk service
+ * @returns Normalized key payload or null
+ */
+export function normalizeNegotiatedPublicKey(raw) {
+    const publicKey = readPublicKeyContainer(raw);
+    const keyId = readNegotiatedValue(publicKey, raw, 2);
+    const keyData = readNegotiatedValue(publicKey, raw, 4);
+    if (keyId == null || keyData == null) {
+        return null;
+    }
+    if (!Buffer.isBuffer(keyData) &&
+        typeof keyData !== 'string' &&
+        !(keyData instanceof Uint8Array)) {
+        return null;
+    }
+    return {
+        keyId: String(keyId),
+        keyData: Buffer.isBuffer(keyData)
+            ? keyData
+            : typeof keyData === 'string'
+                ? Buffer.from(keyData, 'base64')
+                : Buffer.from(keyData),
+    };
+}

package/dist/line/core/e2ee/keys/key-types.js

@@ -0,0 +1 @@
+export {};