1
import { xchacha20poly1305 } from '@noble/ciphers/chacha.js';
2
import * as ed from '@noble/ed25519';
3
import { sha512 } from '@noble/hashes/sha2.js';
4

5
ed.hashes.sha512 = sha512;
6

7
/** Derive comment key from share CEK using HKDF-SHA256 */
8
export async function deriveCommentKey(shareCek: Uint8Array): Promise<Uint8Array> {
9
    const info = new TextEncoder().encode('share-comments-v1');
10
    const ikm = await crypto.subtle.importKey('raw', shareCek as any, { name: 'HKDF' }, false, ['deriveBits']);
11
    const derivedBits = await crypto.subtle.deriveBits({
12
        name: 'HKDF', hash: 'SHA-256', salt: new Uint8Array(32).fill(0), info
13
    }, ikm, 256);
14
    return new Uint8Array(derivedBits);
15
}
16

17
/** Encrypt comment using XChaCha20-Poly1305 */
18
export async function encryptComment(content: string, key: Uint8Array): Promise<string> {
19
    const nonce = crypto.getRandomValues(new Uint8Array(24));
20
    const encodedContent = new TextEncoder().encode(content);
21
    const cipher = xchacha20poly1305(key, nonce);
22
    const encrypted = cipher.encrypt(encodedContent);
23
    const combined = new Uint8Array(nonce.length + encrypted.length);
24
    combined.set(nonce);
25
    combined.set(encrypted, nonce.length);
26
    return btoa(String.fromCharCode(...Array.from(combined)));
27
}
28

29
/** Decrypt comment */
30
export async function decryptComment(encryptedBase64: string, key: Uint8Array): Promise<string> {
31
    try {
32
        const combined = new Uint8Array(atob(encryptedBase64).split('').map(c => c.charCodeAt(0)));
33
        const nonce = combined.slice(0, 24);
34
        const encrypted = combined.slice(24);
35
        const cipher = xchacha20poly1305(key, nonce);
36
        const decryptedBytes = cipher.decrypt(encrypted);
37
        return new TextDecoder().decode(decryptedBytes);
38
    } catch (err) {
39
        return '[Decryption Failed]';
40
    }
41
}
42

43
/** Create HMAC-SHA512 fingerprint using userId as key */
44
export async function createMessageFingerprint(message: string, userId: string): Promise<Uint8Array> {
45
    const encoder = new TextEncoder();
46
    const keyBytes = encoder.encode(userId);
47
    const messageBytes = encoder.encode(message);
48
    const key = await crypto.subtle.importKey('raw', keyBytes, { name: 'HMAC', hash: 'SHA-512' }, false, ['sign']);
49
    const hmac = await crypto.subtle.sign('HMAC', key, messageBytes);
50
    return new Uint8Array(hmac);
51
}
52

53
/** Sign fingerprint with Ed25519 private key */
54
export async function signMessageFingerprint(fingerprint: Uint8Array, privateKey: Uint8Array): Promise<Uint8Array> {
55
    return await ed.sign(fingerprint, privateKey);
56
}
57

58
/** Verify Ed25519 signature */
59
export async function verifyMessageSignature(fingerprint: Uint8Array, signature: Uint8Array, publicKey: Uint8Array): Promise<boolean> {
60
    return await ed.verify(signature, fingerprint, publicKey);
61
}