@kojinx/collab-crypto 0.0.2

package/esm2022/kojinx-collab-crypto.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia29qaW54LWNvbGxhYi1jcnlwdG8uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9rb2ppbngvY29sbGFiLWNyeXB0by9zcmMva29qaW54LWNvbGxhYi1jcnlwdG8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/lib/models/crypto.models.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/e2e-chat-crypto.service.mjs

@@ -0,0 +1,148 @@
+import { Injectable, inject } from '@angular/core';
+import { KOJINX_CRYPTO_PROVIDER } from '../tokens';
+import * as i0 from "@angular/core";
+/**
+ * Pure End-to-End Encryption cryptographic service.
+ * Handles AES-256-GCM message encryption/decryption and RSA key wrapping/unwrapping.
+ */
+export class E2EChatCryptoService {
+    constructor() {
+        this.cryptoProvider = inject(KOJINX_CRYPTO_PROVIDER, {
+            optional: true
+        });
+    }
+    /**
+     * Generates a new cryptographically secure 256-bit AES-GCM session key.
+     */
+    async generateAesKey() {
+        return crypto.subtle.generateKey({
+            name: 'AES-GCM',
+            length: 256
+        }, true, // extractable for RSA wrapping & secure export
+        ['encrypt', 'decrypt']);
+    }
+    /**
+     * Encrypts plaintext string using AES-256-GCM with a fresh 12-byte (96-bit) nonce.
+     *
+     * @param sessionKey In-memory active session key
+     * @param plaintext Plaintext message content
+     */
+    async encryptMessage(sessionKey, plaintext) {
+        if (!sessionKey || !sessionKey.rawKey) {
+            throw new Error('Invalid session key provided for encryption.');
+        }
+        // Standard 12-byte initialization vector for AES-GCM
+        const nonce = crypto.getRandomValues(new Uint8Array(12));
+        const encoder = new TextEncoder();
+        const encodedPlaintext = encoder.encode(plaintext);
+        const ciphertextBuffer = await crypto.subtle.encrypt({
+            name: 'AES-GCM',
+            iv: nonce
+        }, sessionKey.rawKey, encodedPlaintext);
+        return {
+            ciphertext: this.arrayBufferToBase64(ciphertextBuffer),
+            nonce: this.arrayBufferToBase64(nonce.buffer),
+            sessionKeyId: sessionKey.id,
+            generation: sessionKey.generation
+        };
+    }
+    /**
+     * Decrypts an EncryptedMessagePayload using AES-256-GCM.
+     *
+     * @param sessionKey In-memory session key corresponding to payload.sessionKeyId
+     * @param payload Encrypted payload containing ciphertext and nonce
+     */
+    async decryptMessage(sessionKey, payload) {
+        if (!sessionKey || !sessionKey.rawKey) {
+            throw new Error('Invalid session key provided for decryption.');
+        }
+        const ciphertext = this.base64ToArrayBuffer(payload.ciphertext);
+        const nonce = this.base64ToArrayBuffer(payload.nonce);
+        const decryptedBuffer = await crypto.subtle.decrypt({
+            name: 'AES-GCM',
+            iv: new Uint8Array(nonce)
+        }, sessionKey.rawKey, ciphertext);
+        const decoder = new TextDecoder();
+        return decoder.decode(decryptedBuffer);
+    }
+    /**
+     * Exports an AES-GCM key and wraps (encrypts) it with a recipient's RSA public key.
+     *
+     * @param aesKey AES CryptoKey to wrap
+     * @param recipientPublicKey Base64-encoded recipient RSA public key
+     */
+    async wrapSessionKey(aesKey, recipientPublicKey) {
+        if (!this.cryptoProvider) {
+            throw new Error('KOJINX_CRYPTO_PROVIDER is not provided. Cannot wrap session keys.');
+        }
+        const rawKeyBytes = await crypto.subtle.exportKey('raw', aesKey);
+        const rawKeyBase64 = this.arrayBufferToBase64(rawKeyBytes);
+        // Asymmetrically encrypt using host RSA provider
+        return this.cryptoProvider.encrypt(recipientPublicKey, rawKeyBase64);
+    }
+    /**
+     * Unwraps (decrypts) an RSA-encrypted AES raw key and imports it back into a W3C CryptoKey.
+     *
+     * @param encryptedAesKeyBase64 RSA-encrypted AES raw key in base64 format
+     */
+    async unwrapSessionKey(encryptedAesKeyBase64) {
+        if (!this.cryptoProvider) {
+            throw new Error('KOJINX_CRYPTO_PROVIDER is not provided. Cannot unwrap session keys.');
+        }
+        // Asymmetrically decrypt using local private key
+        const rawKeyBase64 = await this.cryptoProvider.decrypt(encryptedAesKeyBase64);
+        const rawKeyBuffer = this.base64ToArrayBuffer(rawKeyBase64);
+        return crypto.subtle.importKey('raw', rawKeyBuffer, {
+            name: 'AES-GCM',
+            length: 256
+        }, true, ['encrypt', 'decrypt']);
+    }
+    /**
+     * Exports a CryptoKey to base64 raw bytes.
+     */
+    async exportRawKeyBase64(key) {
+        const raw = await crypto.subtle.exportKey('raw', key);
+        return this.arrayBufferToBase64(raw);
+    }
+    /**
+     * Imports a base64 raw key string into a CryptoKey.
+     */
+    async importRawKeyBase64(base64) {
+        const buffer = this.base64ToArrayBuffer(base64);
+        return crypto.subtle.importKey('raw', buffer, {
+            name: 'AES-GCM',
+            length: 256
+        }, true, ['encrypt', 'decrypt']);
+    }
+    /**
+     * Encodes ArrayBuffer to Base64 string.
+     */
+    arrayBufferToBase64(buffer) {
+        const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    /**
+     * Decodes Base64 string to ArrayBuffer.
+     */
+    base64ToArrayBuffer(base64) {
+        const binary = atob(base64.trim());
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: E2EChatCryptoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: E2EChatCryptoService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: E2EChatCryptoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"e2e-chat-crypto.service.js","sourceRoot":"","sources":["../../../../../../projects/kojinx/collab-crypto/src/lib/services/e2e-chat-crypto.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport {\n  ConversationSessionKey,\n  EncryptedMessagePayload,\n  KojinxCryptoProvider\n} from '../models/crypto.models';\nimport { KOJINX_CRYPTO_PROVIDER } from '../tokens';\n\n/**\n * Pure End-to-End Encryption cryptographic service.\n * Handles AES-256-GCM message encryption/decryption and RSA key wrapping/unwrapping.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class E2EChatCryptoService {\n  private cryptoProvider = inject<KojinxCryptoProvider>(KOJINX_CRYPTO_PROVIDER, {\n    optional: true\n  });\n\n  /**\n   * Generates a new cryptographically secure 256-bit AES-GCM session key.\n   */\n  async generateAesKey(): Promise<CryptoKey> {\n    return crypto.subtle.generateKey(\n      {\n        name: 'AES-GCM',\n        length: 256\n      },\n      true, // extractable for RSA wrapping & secure export\n      ['encrypt', 'decrypt']\n    );\n  }\n\n  /**\n   * Encrypts plaintext string using AES-256-GCM with a fresh 12-byte (96-bit) nonce.\n   *\n   * @param sessionKey In-memory active session key\n   * @param plaintext Plaintext message content\n   */\n  async encryptMessage(\n    sessionKey: ConversationSessionKey,\n    plaintext: string\n  ): Promise<EncryptedMessagePayload> {\n    if (!sessionKey || !sessionKey.rawKey) {\n      throw new Error('Invalid session key provided for encryption.');\n    }\n\n    // Standard 12-byte initialization vector for AES-GCM\n    const nonce = crypto.getRandomValues(new Uint8Array(12));\n    const encoder = new TextEncoder();\n    const encodedPlaintext = encoder.encode(plaintext);\n\n    const ciphertextBuffer = await crypto.subtle.encrypt(\n      {\n        name: 'AES-GCM',\n        iv: nonce\n      },\n      sessionKey.rawKey,\n      encodedPlaintext\n    );\n\n    return {\n      ciphertext: this.arrayBufferToBase64(ciphertextBuffer),\n      nonce: this.arrayBufferToBase64(nonce.buffer),\n      sessionKeyId: sessionKey.id,\n      generation: sessionKey.generation\n    };\n  }\n\n  /**\n   * Decrypts an EncryptedMessagePayload using AES-256-GCM.\n   *\n   * @param sessionKey In-memory session key corresponding to payload.sessionKeyId\n   * @param payload Encrypted payload containing ciphertext and nonce\n   */\n  async decryptMessage(\n    sessionKey: ConversationSessionKey,\n    payload: EncryptedMessagePayload\n  ): Promise<string> {\n    if (!sessionKey || !sessionKey.rawKey) {\n      throw new Error('Invalid session key provided for decryption.');\n    }\n\n    const ciphertext = this.base64ToArrayBuffer(payload.ciphertext);\n    const nonce = this.base64ToArrayBuffer(payload.nonce);\n\n    const decryptedBuffer = await crypto.subtle.decrypt(\n      {\n        name: 'AES-GCM',\n        iv: new Uint8Array(nonce)\n      },\n      sessionKey.rawKey,\n      ciphertext\n    );\n\n    const decoder = new TextDecoder();\n    return decoder.decode(decryptedBuffer);\n  }\n\n  /**\n   * Exports an AES-GCM key and wraps (encrypts) it with a recipient's RSA public key.\n   *\n   * @param aesKey AES CryptoKey to wrap\n   * @param recipientPublicKey Base64-encoded recipient RSA public key\n   */\n  async wrapSessionKey(\n    aesKey: CryptoKey,\n    recipientPublicKey: string\n  ): Promise<string> {\n    if (!this.cryptoProvider) {\n      throw new Error(\n        'KOJINX_CRYPTO_PROVIDER is not provided. Cannot wrap session keys.'\n      );\n    }\n\n    const rawKeyBytes = await crypto.subtle.exportKey('raw', aesKey);\n    const rawKeyBase64 = this.arrayBufferToBase64(rawKeyBytes);\n\n    // Asymmetrically encrypt using host RSA provider\n    return this.cryptoProvider.encrypt(recipientPublicKey, rawKeyBase64);\n  }\n\n  /**\n   * Unwraps (decrypts) an RSA-encrypted AES raw key and imports it back into a W3C CryptoKey.\n   *\n   * @param encryptedAesKeyBase64 RSA-encrypted AES raw key in base64 format\n   */\n  async unwrapSessionKey(encryptedAesKeyBase64: string): Promise<CryptoKey> {\n    if (!this.cryptoProvider) {\n      throw new Error(\n        'KOJINX_CRYPTO_PROVIDER is not provided. Cannot unwrap session keys.'\n      );\n    }\n\n    // Asymmetrically decrypt using local private key\n    const rawKeyBase64 = await this.cryptoProvider.decrypt(\n      encryptedAesKeyBase64\n    );\n    const rawKeyBuffer = this.base64ToArrayBuffer(rawKeyBase64);\n\n    return crypto.subtle.importKey(\n      'raw',\n      rawKeyBuffer,\n      {\n        name: 'AES-GCM',\n        length: 256\n      },\n      true,\n      ['encrypt', 'decrypt']\n    );\n  }\n\n  /**\n   * Exports a CryptoKey to base64 raw bytes.\n   */\n  async exportRawKeyBase64(key: CryptoKey): Promise<string> {\n    const raw = await crypto.subtle.exportKey('raw', key);\n    return this.arrayBufferToBase64(raw);\n  }\n\n  /**\n   * Imports a base64 raw key string into a CryptoKey.\n   */\n  async importRawKeyBase64(base64: string): Promise<CryptoKey> {\n    const buffer = this.base64ToArrayBuffer(base64);\n    return crypto.subtle.importKey(\n      'raw',\n      buffer,\n      {\n        name: 'AES-GCM',\n        length: 256\n      },\n      true,\n      ['encrypt', 'decrypt']\n    );\n  }\n\n  /**\n   * Encodes ArrayBuffer to Base64 string.\n   */\n  arrayBufferToBase64(buffer: ArrayBuffer | Uint8Array): string {\n    const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);\n    let binary = '';\n    for (let i = 0; i < bytes.byteLength; i++) {\n      binary += String.fromCharCode(bytes[i]);\n    }\n    return btoa(binary);\n  }\n\n  /**\n   * Decodes Base64 string to ArrayBuffer.\n   */\n  base64ToArrayBuffer(base64: string): ArrayBuffer {\n    const binary = atob(base64.trim());\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) {\n      bytes[i] = binary.charCodeAt(i);\n    }\n    return bytes.buffer;\n  }\n}\n"]}

package/esm2022/lib/services/session-key-manager.service.mjs

@@ -0,0 +1,267 @@
+import { Injectable, inject } from '@angular/core';
+import { KOJINX_API_BASE_URL, KOJINX_AUTH_TOKEN, KOJINX_CRYPTO_STORAGE, KOJINX_HTTP_FETCH } from '../tokens';
+import { E2EChatCryptoService } from './e2e-chat-crypto.service';
+import * as i0 from "@angular/core";
+/** 30 days in milliseconds for maximum session key lifetime */
+const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
+/**
+ * Manages the lifecycle, caching, negotiation, and rotation of conversation session keys.
+ */
+export class SessionKeyManagerService {
+    constructor() {
+        this.cryptoService = inject(E2EChatCryptoService);
+        this.httpFetch = inject(KOJINX_HTTP_FETCH, {
+            optional: true
+        });
+        this.getApiUrl = inject(KOJINX_API_BASE_URL, {
+            optional: true
+        });
+        this.getAuthToken = inject(KOJINX_AUTH_TOKEN, { optional: true });
+        this.storage = inject(KOJINX_CRYPTO_STORAGE, {
+            optional: true
+        });
+        /** Fast in-memory cache mapped by conversationId */
+        this.activeKeysByConversation = new Map();
+        /** Fast in-memory cache mapped by sessionKeyId (for historic messages) */
+        this.keysById = new Map();
+    }
+    /**
+     * Retrieves or creates an active session key for a 1:1 Direct Message conversation.
+     *
+     * @param localUserId Current user's ID
+     * @param remoteUserId Remote contact's ID
+     * @param remotePublicKey Base64 RSA public key of remote contact
+     * @param localPublicKey Base64 RSA public key of local user
+     */
+    async getOrCreateDmSessionKey(localUserId, remoteUserId, remotePublicKey, localPublicKey) {
+        const conversationId = this.buildDmConversationId(localUserId, remoteUserId);
+        // 1. Check in-memory cache
+        const cached = this.activeKeysByConversation.get(conversationId);
+        if (cached && !this.isKeyExpired(cached)) {
+            return cached;
+        }
+        // 2. Attempt fetching from server if HTTP fetch is provided
+        if (this.httpFetch && this.getApiUrl && this.getAuthToken) {
+            const serverKey = await this.fetchSessionKeyFromServer(conversationId, 'dm');
+            if (serverKey) {
+                this.cacheKey(serverKey);
+                return serverKey;
+            }
+        }
+        // 3. Create fresh session key and distribute
+        return this.createAndDistributeSessionKey({
+            type: 'dm',
+            conversationId,
+            generation: cached ? cached.generation + 1 : 1,
+            members: [
+                { userId: localUserId, publicKey: localPublicKey },
+                { userId: remoteUserId, publicKey: remotePublicKey }
+            ]
+        });
+    }
+    /**
+     * Retrieves or creates an active session key for a Native Channel or Group.
+     *
+     * @param channelId Unique channel ID
+     * @param members List of all workspace/channel members with their public keys
+     */
+    async getOrCreateChannelSessionKey(channelId, members) {
+        const cached = this.activeKeysByConversation.get(channelId);
+        if (cached && !this.isKeyExpired(cached)) {
+            return cached;
+        }
+        if (this.httpFetch && this.getApiUrl && this.getAuthToken) {
+            const serverKey = await this.fetchSessionKeyFromServer(channelId, 'channel');
+            if (serverKey) {
+                this.cacheKey(serverKey);
+                return serverKey;
+            }
+        }
+        return this.createAndDistributeSessionKey({
+            type: 'channel',
+            conversationId: channelId,
+            generation: cached ? cached.generation + 1 : 1,
+            members
+        });
+    }
+    /**
+     * Retrieves a session key by its specific sessionKeyId (used for decrypting historic messages).
+     */
+    async getSessionKeyById(sessionKeyId) {
+        const cached = this.keysById.get(sessionKeyId);
+        if (cached)
+            return cached;
+        // Check local storage
+        if (this.storage) {
+            const stored = await this.storage.getItem(`kojinx_sk_${sessionKeyId}`);
+            if (stored) {
+                try {
+                    const parsed = JSON.parse(stored);
+                    const rawKey = await this.cryptoService.importRawKeyBase64(parsed.rawKeyBase64);
+                    const key = {
+                        id: parsed.id,
+                        type: parsed.type,
+                        conversationId: parsed.conversationId,
+                        rawKey,
+                        generation: parsed.generation,
+                        createdAt: parsed.createdAt
+                    };
+                    this.cacheKey(key);
+                    return key;
+                }
+                catch {
+                    // ignore corrupted local key
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Generates a new AES session key, wraps it for all members, and uploads to the server.
+     */
+    async createAndDistributeSessionKey(params) {
+        const rawAesKey = await this.cryptoService.generateAesKey();
+        const sessionKeyId = this.generateUuid();
+        const memberPayloads = {};
+        for (const member of params.members) {
+            if (member.publicKey) {
+                memberPayloads[member.userId] =
+                    await this.cryptoService.wrapSessionKey(rawAesKey, member.publicKey);
+            }
+        }
+        const sessionKey = {
+            id: sessionKeyId,
+            type: params.type,
+            conversationId: params.conversationId,
+            rawKey: rawAesKey,
+            generation: params.generation,
+            createdAt: Date.now()
+        };
+        // Store in memory
+        this.cacheKey(sessionKey);
+        await this.persistKeyLocally(sessionKey);
+        // Upload to server if online
+        if (this.httpFetch && this.getApiUrl && this.getAuthToken) {
+            const token = await this.getAuthToken();
+            const apiUrl = this.getApiUrl();
+            const payload = {
+                sessionKeyId,
+                conversationType: params.type,
+                conversationId: params.conversationId,
+                generation: params.generation,
+                memberPayloads
+            };
+            try {
+                await this.httpFetch(`${apiUrl}/api/e2e/session-keys`, {
+                    method: 'POST',
+                    headers: {
+                        Authorization: `Bearer ${token}`,
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify(payload)
+                });
+            }
+            catch (err) {
+                console.warn('[SessionKeyManager] Failed to sync session key to server:', err);
+            }
+        }
+        return sessionKey;
+    }
+    /**
+     * Helper to check if a key has exceeded the 30-day rotation threshold.
+     */
+    isKeyExpired(key) {
+        return Date.now() - key.createdAt > THIRTY_DAYS_MS;
+    }
+    /**
+     * Builds a deterministic conversation identifier for 1:1 DMs (lexicographical sort).
+     */
+    buildDmConversationId(userIdA, userIdB) {
+        return [userIdA, userIdB].sort().join('_');
+    }
+    /**
+     * Caches a session key in memory.
+     */
+    cacheKey(key) {
+        this.activeKeysByConversation.set(key.conversationId, key);
+        this.keysById.set(key.id, key);
+    }
+    /**
+     * Persists an unwrapped session key to local storage for fast startup.
+     */
+    async persistKeyLocally(key) {
+        if (!this.storage)
+            return;
+        try {
+            const rawKeyBase64 = await this.cryptoService.exportRawKeyBase64(key.rawKey);
+            const data = JSON.stringify({
+                id: key.id,
+                type: key.type,
+                conversationId: key.conversationId,
+                rawKeyBase64,
+                generation: key.generation,
+                createdAt: key.createdAt
+            });
+            await this.storage.setItem(`kojinx_sk_${key.id}`, data);
+        }
+        catch {
+            // ignore persistence error
+        }
+    }
+    /**
+     * Fetches latest session key from server and unwraps it locally.
+     */
+    async fetchSessionKeyFromServer(conversationId, type) {
+        if (!this.httpFetch || !this.getApiUrl || !this.getAuthToken)
+            return null;
+        try {
+            const token = await this.getAuthToken();
+            const apiUrl = this.getApiUrl();
+            const res = await this.httpFetch(`${apiUrl}/api/e2e/session-keys/${conversationId}`, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${token}`
+                }
+            });
+            if (res.status === 200 && res.data?.encryptedKey) {
+                const rawKey = await this.cryptoService.unwrapSessionKey(res.data.encryptedKey);
+                return {
+                    id: res.data.sessionKeyId,
+                    type,
+                    conversationId,
+                    rawKey,
+                    generation: res.data.generation || 1,
+                    createdAt: res.data.createdAt
+                        ? new Date(res.data.createdAt).getTime()
+                        : Date.now()
+                };
+            }
+        }
+        catch {
+            // Not found or network error
+        }
+        return null;
+    }
+    /**
+     * Generates a random UUID (W3C standard or fallback).
+     */
+    generateUuid() {
+        if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+            return crypto.randomUUID();
+        }
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SessionKeyManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SessionKeyManagerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SessionKeyManagerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session-key-manager.service.js","sourceRoot":"","sources":["../../../../../../projects/kojinx/collab-crypto/src/lib/services/session-key-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport {\n  ConversationSessionKey,\n  KojinxFetchFunction,\n  KojinxStorageProvider,\n  MemberPublicKey,\n  SessionKeyExchangePayload\n} from '../models/crypto.models';\nimport {\n  KOJINX_API_BASE_URL,\n  KOJINX_AUTH_TOKEN,\n  KOJINX_CRYPTO_STORAGE,\n  KOJINX_HTTP_FETCH\n} from '../tokens';\nimport { E2EChatCryptoService } from './e2e-chat-crypto.service';\n\n/** 30 days in milliseconds for maximum session key lifetime */\nconst THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;\n\n/**\n * Manages the lifecycle, caching, negotiation, and rotation of conversation session keys.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class SessionKeyManagerService {\n  private cryptoService = inject(E2EChatCryptoService);\n  private httpFetch = inject<KojinxFetchFunction>(KOJINX_HTTP_FETCH, {\n    optional: true\n  });\n  private getApiUrl = inject<() => string>(KOJINX_API_BASE_URL, {\n    optional: true\n  });\n  private getAuthToken = inject<() => Promise<string | null>>(\n    KOJINX_AUTH_TOKEN,\n    { optional: true }\n  );\n  private storage = inject<KojinxStorageProvider>(KOJINX_CRYPTO_STORAGE, {\n    optional: true\n  });\n\n  /** Fast in-memory cache mapped by conversationId */\n  private activeKeysByConversation = new Map<string, ConversationSessionKey>();\n  /** Fast in-memory cache mapped by sessionKeyId (for historic messages) */\n  private keysById = new Map<string, ConversationSessionKey>();\n\n  /**\n   * Retrieves or creates an active session key for a 1:1 Direct Message conversation.\n   *\n   * @param localUserId Current user's ID\n   * @param remoteUserId Remote contact's ID\n   * @param remotePublicKey Base64 RSA public key of remote contact\n   * @param localPublicKey Base64 RSA public key of local user\n   */\n  async getOrCreateDmSessionKey(\n    localUserId: string,\n    remoteUserId: string,\n    remotePublicKey: string,\n    localPublicKey: string\n  ): Promise<ConversationSessionKey> {\n    const conversationId = this.buildDmConversationId(\n      localUserId,\n      remoteUserId\n    );\n\n    // 1. Check in-memory cache\n    const cached = this.activeKeysByConversation.get(conversationId);\n    if (cached && !this.isKeyExpired(cached)) {\n      return cached;\n    }\n\n    // 2. Attempt fetching from server if HTTP fetch is provided\n    if (this.httpFetch && this.getApiUrl && this.getAuthToken) {\n      const serverKey = await this.fetchSessionKeyFromServer(\n        conversationId,\n        'dm'\n      );\n      if (serverKey) {\n        this.cacheKey(serverKey);\n        return serverKey;\n      }\n    }\n\n    // 3. Create fresh session key and distribute\n    return this.createAndDistributeSessionKey({\n      type: 'dm',\n      conversationId,\n      generation: cached ? cached.generation + 1 : 1,\n      members: [\n        { userId: localUserId, publicKey: localPublicKey },\n        { userId: remoteUserId, publicKey: remotePublicKey }\n      ]\n    });\n  }\n\n  /**\n   * Retrieves or creates an active session key for a Native Channel or Group.\n   *\n   * @param channelId Unique channel ID\n   * @param members List of all workspace/channel members with their public keys\n   */\n  async getOrCreateChannelSessionKey(\n    channelId: string,\n    members: MemberPublicKey[]\n  ): Promise<ConversationSessionKey> {\n    const cached = this.activeKeysByConversation.get(channelId);\n    if (cached && !this.isKeyExpired(cached)) {\n      return cached;\n    }\n\n    if (this.httpFetch && this.getApiUrl && this.getAuthToken) {\n      const serverKey = await this.fetchSessionKeyFromServer(\n        channelId,\n        'channel'\n      );\n      if (serverKey) {\n        this.cacheKey(serverKey);\n        return serverKey;\n      }\n    }\n\n    return this.createAndDistributeSessionKey({\n      type: 'channel',\n      conversationId: channelId,\n      generation: cached ? cached.generation + 1 : 1,\n      members\n    });\n  }\n\n  /**\n   * Retrieves a session key by its specific sessionKeyId (used for decrypting historic messages).\n   */\n  async getSessionKeyById(\n    sessionKeyId: string\n  ): Promise<ConversationSessionKey | null> {\n    const cached = this.keysById.get(sessionKeyId);\n    if (cached) return cached;\n\n    // Check local storage\n    if (this.storage) {\n      const stored = await this.storage.getItem(\n        `kojinx_sk_${sessionKeyId}`\n      );\n      if (stored) {\n        try {\n          const parsed = JSON.parse(stored);\n          const rawKey = await this.cryptoService.importRawKeyBase64(\n            parsed.rawKeyBase64\n          );\n          const key: ConversationSessionKey = {\n            id: parsed.id,\n            type: parsed.type,\n            conversationId: parsed.conversationId,\n            rawKey,\n            generation: parsed.generation,\n            createdAt: parsed.createdAt\n          };\n          this.cacheKey(key);\n          return key;\n        } catch {\n          // ignore corrupted local key\n        }\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Generates a new AES session key, wraps it for all members, and uploads to the server.\n   */\n  async createAndDistributeSessionKey(params: {\n    type: 'dm' | 'channel' | 'group';\n    conversationId: string;\n    generation: number;\n    members: MemberPublicKey[];\n  }): Promise<ConversationSessionKey> {\n    const rawAesKey = await this.cryptoService.generateAesKey();\n    const sessionKeyId = this.generateUuid();\n\n    const memberPayloads: Record<string, string> = {};\n    for (const member of params.members) {\n      if (member.publicKey) {\n        memberPayloads[member.userId] =\n          await this.cryptoService.wrapSessionKey(\n            rawAesKey,\n            member.publicKey\n          );\n      }\n    }\n\n    const sessionKey: ConversationSessionKey = {\n      id: sessionKeyId,\n      type: params.type,\n      conversationId: params.conversationId,\n      rawKey: rawAesKey,\n      generation: params.generation,\n      createdAt: Date.now()\n    };\n\n    // Store in memory\n    this.cacheKey(sessionKey);\n    await this.persistKeyLocally(sessionKey);\n\n    // Upload to server if online\n    if (this.httpFetch && this.getApiUrl && this.getAuthToken) {\n      const token = await this.getAuthToken();\n      const apiUrl = this.getApiUrl();\n      const payload: SessionKeyExchangePayload = {\n        sessionKeyId,\n        conversationType: params.type,\n        conversationId: params.conversationId,\n        generation: params.generation,\n        memberPayloads\n      };\n\n      try {\n        await this.httpFetch(`${apiUrl}/api/e2e/session-keys`, {\n          method: 'POST',\n          headers: {\n            Authorization: `Bearer ${token}`,\n            'Content-Type': 'application/json'\n          },\n          body: JSON.stringify(payload)\n        });\n      } catch (err) {\n        console.warn(\n          '[SessionKeyManager] Failed to sync session key to server:',\n          err\n        );\n      }\n    }\n\n    return sessionKey;\n  }\n\n  /**\n   * Helper to check if a key has exceeded the 30-day rotation threshold.\n   */\n  isKeyExpired(key: ConversationSessionKey): boolean {\n    return Date.now() - key.createdAt > THIRTY_DAYS_MS;\n  }\n\n  /**\n   * Builds a deterministic conversation identifier for 1:1 DMs (lexicographical sort).\n   */\n  buildDmConversationId(userIdA: string, userIdB: string): string {\n    return [userIdA, userIdB].sort().join('_');\n  }\n\n  /**\n   * Caches a session key in memory.\n   */\n  private cacheKey(key: ConversationSessionKey): void {\n    this.activeKeysByConversation.set(key.conversationId, key);\n    this.keysById.set(key.id, key);\n  }\n\n  /**\n   * Persists an unwrapped session key to local storage for fast startup.\n   */\n  private async persistKeyLocally(\n    key: ConversationSessionKey\n  ): Promise<void> {\n    if (!this.storage) return;\n    try {\n      const rawKeyBase64 = await this.cryptoService.exportRawKeyBase64(\n        key.rawKey\n      );\n      const data = JSON.stringify({\n        id: key.id,\n        type: key.type,\n        conversationId: key.conversationId,\n        rawKeyBase64,\n        generation: key.generation,\n        createdAt: key.createdAt\n      });\n      await this.storage.setItem(`kojinx_sk_${key.id}`, data);\n    } catch {\n      // ignore persistence error\n    }\n  }\n\n  /**\n   * Fetches latest session key from server and unwraps it locally.\n   */\n  private async fetchSessionKeyFromServer(\n    conversationId: string,\n    type: 'dm' | 'channel' | 'group'\n  ): Promise<ConversationSessionKey | null> {\n    if (!this.httpFetch || !this.getApiUrl || !this.getAuthToken) return null;\n\n    try {\n      const token = await this.getAuthToken();\n      const apiUrl = this.getApiUrl();\n      const res = await this.httpFetch<{\n        sessionKeyId: string;\n        generation: number;\n        encryptedKey: string;\n        createdAt?: string;\n      }>(`${apiUrl}/api/e2e/session-keys/${conversationId}`, {\n        method: 'GET',\n        headers: {\n          Authorization: `Bearer ${token}`\n        }\n      });\n\n      if (res.status === 200 && res.data?.encryptedKey) {\n        const rawKey = await this.cryptoService.unwrapSessionKey(\n          res.data.encryptedKey\n        );\n        return {\n          id: res.data.sessionKeyId,\n          type,\n          conversationId,\n          rawKey,\n          generation: res.data.generation || 1,\n          createdAt: res.data.createdAt\n            ? new Date(res.data.createdAt).getTime()\n            : Date.now()\n        };\n      }\n    } catch {\n      // Not found or network error\n    }\n\n    return null;\n  }\n\n  /**\n   * Generates a random UUID (W3C standard or fallback).\n   */\n  private generateUuid(): string {\n    if (typeof crypto !== 'undefined' && crypto.randomUUID) {\n      return crypto.randomUUID();\n    }\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {\n      const r = (Math.random() * 16) | 0;\n      const v = c === 'x' ? r : (r & 0x3) | 0x8;\n      return v.toString(16);\n    });\n  }\n}\n"]}

package/esm2022/lib/tokens.mjs

@@ -0,0 +1,36 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Injected Asymmetric Cryptography Provider (RSA-2048 OAEP).
+ * On desktop: Implemented via Tauri Rust Keyring IPC.
+ * On mobile: Implemented via SubtleCrypto + Capacitor SecureStorage.
+ */
+export const KOJINX_CRYPTO_PROVIDER = new InjectionToken('KOJINX_CRYPTO_PROVIDER');
+/**
+ * Injected Client-Agnostic HTTP Fetcher (bypass CORS on native).
+ */
+export const KOJINX_HTTP_FETCH = new InjectionToken('KOJINX_HTTP_FETCH');
+/**
+ * Injected Storage Provider for local session key caching.
+ */
+export const KOJINX_CRYPTO_STORAGE = new InjectionToken('KOJINX_CRYPTO_STORAGE', {
+    factory: () => ({
+        getItem: (key) => Promise.resolve(localStorage.getItem(key)),
+        setItem: (key, value) => {
+            localStorage.setItem(key, value);
+            return Promise.resolve();
+        },
+        removeItem: (key) => {
+            localStorage.removeItem(key);
+            return Promise.resolve();
+        }
+    })
+});
+/**
+ * Injected API Base URL accessor function.
+ */
+export const KOJINX_API_BASE_URL = new InjectionToken('KOJINX_API_BASE_URL');
+/**
+ * Injected Auth Bearer Token accessor function.
+ */
+export const KOJINX_AUTH_TOKEN = new InjectionToken('KOJINX_AUTH_TOKEN');
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/safety-number.utils.mjs

@@ -0,0 +1,72 @@
+/**
+ * Computes deterministic SHA-256 safety verification numbers (Signal-style).
+ * Users can compare these 30-digit numbers out-of-band to verify end-to-end identity.
+ */
+export class SafetyNumberUtils {
+    /**
+     * Generates a Safety Number between two identity public keys.
+     *
+     * @param localPublicKey Base64-encoded local RSA public key
+     * @param remotePublicKey Base64-encoded remote RSA public key
+     */
+    static async generate(localPublicKey, remotePublicKey) {
+        if (!localPublicKey || !remotePublicKey) {
+            throw new Error('Both public keys are required to generate safety numbers.');
+        }
+        const localFingerprint = await this.hashPublicKey(localPublicKey);
+        const remoteFingerprint = await this.hashPublicKey(remotePublicKey);
+        // Sort lexicographically to ensure order-independent verification
+        const sorted = [localFingerprint, remoteFingerprint].sort();
+        const combinedDigest = await this.sha256(sorted.join(''));
+        // Convert hex digest to a 30-digit decimal representation
+        const digits = this.hexTo30Digits(combinedDigest);
+        const formatted = this.formatBlocks(digits);
+        return {
+            raw: combinedDigest,
+            formatted,
+            localFingerprint: localFingerprint.substring(0, 16),
+            remoteFingerprint: remoteFingerprint.substring(0, 16)
+        };
+    }
+    /**
+     * Hashes a single public key using SHA-256.
+     */
+    static async hashPublicKey(publicKeyBase64) {
+        const cleanKey = publicKeyBase64.replace(/\s+/g, '');
+        return this.sha256(cleanKey);
+    }
+    /**
+     * Computes SHA-256 hex string using W3C Web Crypto API.
+     */
+    static async sha256(input) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(input);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+    /**
+     * Converts a hexadecimal string into a deterministic 30-digit decimal string.
+     */
+    static hexTo30Digits(hex) {
+        let result = '';
+        // Take chunks of 8 hex characters (32-bit integers) to produce 5-digit decimal blocks
+        for (let i = 0; i < 6; i++) {
+            const chunk = hex.substring(i * 8, (i + 1) * 8);
+            const num = parseInt(chunk, 16) % 100000;
+            result += num.toString().padStart(5, '0');
+        }
+        return result;
+    }
+    /**
+     * Formats a 30-digit string into 6 blocks of 5 digits separated by spaces.
+     */
+    static formatBlocks(digits) {
+        const blocks = [];
+        for (let i = 0; i < digits.length; i += 5) {
+            blocks.push(digits.substring(i, i + 5));
+        }
+        return blocks.join(' ');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public-api.mjs

@@ -0,0 +1,9 @@
+/*
+ * Public API Surface of @kojinx/collab-crypto
+ */
+export * from './lib/tokens';
+export * from './lib/models/crypto.models';
+export * from './lib/utils/safety-number.utils';
+export * from './lib/services/e2e-chat-crypto.service';
+export * from './lib/services/session-key-manager.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2tvamlueC9jb2xsYWItY3J5cHRvL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsd0NBQXdDLENBQUM7QUFDdkQsY0FBYyw0Q0FBNEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgQGtvamlueC9jb2xsYWItY3J5cHRvXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvdG9rZW5zJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL21vZGVscy9jcnlwdG8ubW9kZWxzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3V0aWxzL3NhZmV0eS1udW1iZXIudXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvZTJlLWNoYXQtY3J5cHRvLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvc2Vzc2lvbi1rZXktbWFuYWdlci5zZXJ2aWNlJztcbiJdfQ==