nastech-app 1.0.0

package/sources/encryption/base64.appspec.ts

@@ -0,0 +1,240 @@
+import { describe, it, expect } from '@/dev/testRunner';
+import { encodeBase64, decodeBase64 } from './base64';
+import { getRandomBytes } from 'expo-crypto';
+
+describe('Base64 Tests', () => {
+    describe('Standard Base64 Encoding/Decoding', () => {
+        it('should encode and decode empty array', async () => {
+            const input = new Uint8Array([]);
+            const encoded = encodeBase64(input);
+            expect(encoded).toEqual('');
+            const decoded = decodeBase64(encoded);
+            expect(decoded).toEqual(input);
+        });
+
+        it('should encode and decode single byte', async () => {
+            const input = new Uint8Array([72]); // 'H'
+            const encoded = encodeBase64(input);
+            expect(encoded).toEqual('SA==');
+            const decoded = decodeBase64(encoded);
+            expect(decoded).toEqual(input);
+        });
+
+        it('should encode and decode "Hello"', async () => {
+            const input = new Uint8Array([72, 101, 108, 108, 111]);
+            const encoded = encodeBase64(input);
+            expect(encoded).toEqual('SGVsbG8=');
+            const decoded = decodeBase64(encoded);
+            expect(decoded).toEqual(input);
+        });
+
+        it('should encode and decode "Hello, World!"', async () => {
+            const input = new Uint8Array([72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33]);
+            const encoded = encodeBase64(input);
+            expect(encoded).toEqual('SGVsbG8sIFdvcmxkIQ==');
+            const decoded = decodeBase64(encoded);
+            expect(decoded).toEqual(input);
+        });
+
+        it('should handle binary data with edge values', async () => {
+            const input = new Uint8Array([0, 1, 2, 3, 252, 253, 254, 255]);
+            const encoded = encodeBase64(input);
+            const decoded = decodeBase64(encoded);
+            expect(decoded).toEqual(input);
+        });
+
+        it('should handle all padding cases', async () => {
+            // No padding (3 bytes)
+            const input1 = new Uint8Array([1, 2, 3]);
+            const encoded1 = encodeBase64(input1);
+            expect(encoded1).toEqual('AQID');
+            expect(decodeBase64(encoded1)).toEqual(input1);
+
+            // 2 padding chars (4 bytes)
+            const input2 = new Uint8Array([1, 2, 3, 4]);
+            const encoded2 = encodeBase64(input2);
+            expect(encoded2).toEqual('AQIDBA==');
+            expect(decodeBase64(encoded2)).toEqual(input2);
+
+            // 1 padding char (5 bytes)
+            const input3 = new Uint8Array([1, 2, 3, 4, 5]);
+            const encoded3 = encodeBase64(input3);
+            expect(encoded3).toEqual('AQIDBAU=');
+            expect(decodeBase64(encoded3)).toEqual(input3);
+        });
+
+        it('should encode and decode 32-byte key', async () => {
+            const input = new Uint8Array([
+                25, 98, 84, 190, 50, 194, 51, 115, 197, 46, 112, 77,
+                155, 180, 158, 245, 129, 17, 92, 203, 118, 244, 18, 70,
+                144, 34, 83, 84, 123, 21, 151, 61
+            ]);
+            const encoded = encodeBase64(input);
+            expect(encoded).toEqual('GWJUvjLCM3PFLnBNm7Se9YERXMt29BJGkCJTVHsVlz0=');
+            const decoded = decodeBase64(encoded);
+            expect(decoded).toEqual(input);
+        });
+
+        it('should handle text encoding round-trip', async () => {
+            const text = 'Hello, 世界! 🌍';
+            const input = new TextEncoder().encode(text);
+            const encoded = encodeBase64(input);
+            expect(typeof encoded).toEqual('string');
+            const decoded = decodeBase64(encoded);
+            const decodedText = new TextDecoder().decode(decoded);
+            expect(decodedText).toEqual(text);
+        });
+
+        it('should handle random data round-trip', async () => {
+            const input = getRandomBytes(100);
+            const encoded = encodeBase64(input);
+            expect(typeof encoded).toEqual('string');
+            const decoded = decodeBase64(encoded);
+            expect(decoded).toEqual(input);
+        });
+
+        it('should handle large data', async () => {
+            const input = getRandomBytes(1024);
+            const encoded = encodeBase64(input);
+            expect(typeof encoded).toEqual('string');
+            const decoded = decodeBase64(encoded);
+            expect(decoded).toEqual(input);
+        });
+    });
+
+    describe('Base64URL Encoding/Decoding', () => {
+        it('should encode and decode with URL-safe characters', async () => {
+            const input = new Uint8Array([62, 63, 62, 63]);
+            const encoded = encodeBase64(input, 'base64url');
+            expect(encoded).toEqual('Pj8-Pw'); // No padding, - and _ instead of + and /
+            const decoded = decodeBase64(encoded, 'base64url');
+            expect(decoded).toEqual(input);
+        });
+
+        it('should encode without padding in base64url', async () => {
+            const input = new Uint8Array([72, 101, 108, 108, 111]);
+            const encoded = encodeBase64(input, 'base64url');
+            expect(encoded).toEqual('SGVsbG8'); // No '=' padding
+            const decoded = decodeBase64(encoded, 'base64url');
+            expect(decoded).toEqual(input);
+        });
+
+        it('should handle all padding cases for base64url', async () => {
+            // No padding needed (3 bytes)
+            const input1 = new Uint8Array([1, 2, 3]);
+            const encoded1 = encodeBase64(input1, 'base64url');
+            expect(encoded1).toEqual('AQID');
+            expect(decodeBase64(encoded1, 'base64url')).toEqual(input1);
+
+            // Would have 2 padding chars in base64 (4 bytes)
+            const input2 = new Uint8Array([1, 2, 3, 4]);
+            const encoded2 = encodeBase64(input2, 'base64url');
+            expect(encoded2).toEqual('AQIDBA'); // No '=='
+            expect(decodeBase64(encoded2, 'base64url')).toEqual(input2);
+
+            // Would have 1 padding char in base64 (5 bytes)
+            const input3 = new Uint8Array([1, 2, 3, 4, 5]);
+            const encoded3 = encodeBase64(input3, 'base64url');
+            expect(encoded3).toEqual('AQIDBAU'); // No '='
+            expect(decodeBase64(encoded3, 'base64url')).toEqual(input3);
+        });
+
+        it('should handle binary data with URL-unsafe chars', async () => {
+            const input = new Uint8Array([252, 253, 254, 255]);
+            const encoded = encodeBase64(input, 'base64url');
+            expect(encoded).toEqual('_P3-_w'); // _ instead of /, - instead of +, no padding
+            const decoded = decodeBase64(encoded, 'base64url');
+            expect(decoded).toEqual(input);
+        });
+
+        it('should encode and decode 32-byte key in base64url', async () => {
+            const input = new Uint8Array([
+                25, 98, 84, 190, 50, 194, 51, 115, 197, 46, 112, 77,
+                155, 180, 158, 245, 129, 17, 92, 203, 118, 244, 18, 70,
+                144, 34, 83, 84, 123, 21, 151, 61
+            ]);
+            const encoded = encodeBase64(input, 'base64url');
+            expect(encoded).toEqual('GWJUvjLCM3PFLnBNm7Se9YERXMt29BJGkCJTVHsVlz0'); // No padding
+            const decoded = decodeBase64(encoded, 'base64url');
+            expect(decoded).toEqual(input);
+        });
+
+        it('should handle random data round-trip in base64url', async () => {
+            const input = getRandomBytes(100);
+            const encoded = encodeBase64(input, 'base64url');
+            expect(typeof encoded).toEqual('string');
+            expect(encoded.indexOf('+')).toEqual(-1); // No + chars
+            expect(encoded.indexOf('/')).toEqual(-1); // No / chars
+            expect(encoded.indexOf('=')).toEqual(-1); // No = chars
+            const decoded = decodeBase64(encoded, 'base64url');
+            expect(decoded).toEqual(input);
+        });
+    });
+
+    describe('Cross-format compatibility', () => {
+        it('should correctly convert between base64 and base64url', async () => {
+            const input = getRandomBytes(50);
+            
+            // Encode as base64
+            const base64 = encodeBase64(input);
+            
+            // Decode as base64 and re-encode as base64url
+            const decoded = decodeBase64(base64);
+            const base64url = encodeBase64(decoded, 'base64url');
+            
+            // Decode base64url and verify it matches original
+            const final = decodeBase64(base64url, 'base64url');
+            expect(final).toEqual(input);
+        });
+
+        it('should handle edge case characters that differ between formats', async () => {
+            // Create data that will produce + and / in base64
+            const input = new Uint8Array([251, 255]); // Will produce /
+            
+            const base64 = encodeBase64(input);
+            const base64url = encodeBase64(input, 'base64url');
+            
+            // Verify they differ in the expected way
+            expect(base64.indexOf('/')).toBeGreaterThan(-1);
+            expect(base64url.indexOf('_')).toBeGreaterThan(-1);
+            expect(base64url.indexOf('/')).toEqual(-1);
+            
+            // Both should decode to same value
+            expect(decodeBase64(base64)).toEqual(input);
+            expect(decodeBase64(base64url, 'base64url')).toEqual(input);
+        });
+    });
+
+    describe('Performance and edge cases', () => {
+        it('should handle all byte values 0-255', async () => {
+            const input = new Uint8Array(256);
+            for (let i = 0; i < 256; i++) {
+                input[i] = i;
+            }
+            
+            const encoded = encodeBase64(input);
+            const decoded = decodeBase64(encoded);
+            expect(decoded).toEqual(input);
+            
+            const encodedUrl = encodeBase64(input, 'base64url');
+            const decodedUrl = decodeBase64(encodedUrl, 'base64url');
+            expect(decodedUrl).toEqual(input);
+        });
+
+        it('should handle zero bytes correctly', async () => {
+            const input = new Uint8Array([0, 0, 0, 0]);
+            const encoded = encodeBase64(input);
+            expect(encoded).toEqual('AAAAAA==');
+            const decoded = decodeBase64(encoded);
+            expect(decoded).toEqual(input);
+        });
+
+        it('should handle maximum byte values', async () => {
+            const input = new Uint8Array([255, 255, 255, 255]);
+            const encoded = encodeBase64(input);
+            expect(encoded).toEqual('/////w==');
+            const decoded = decodeBase64(encoded);
+            expect(decoded).toEqual(input);
+        });
+    });
+});

package/sources/encryption/base64.native.ts

@@ -0,0 +1,12 @@
+import { fromByteArray, toByteArray } from 'react-native-quick-base64';
+
+export function decodeBase64(base64: string, encoding: 'base64' | 'base64url' = 'base64'): Uint8Array {
+    if (encoding === 'base64url') {
+        return toByteArray(base64, true);
+    }
+    return toByteArray(base64, true);
+}
+
+export function encodeBase64(buffer: Uint8Array, encoding: 'base64' | 'base64url' = 'base64'): string {
+    return fromByteArray(buffer, encoding === 'base64url');
+}

package/sources/encryption/base64.ts

@@ -0,0 +1,46 @@
+export function decodeBase64(base64: string, encoding: 'base64' | 'base64url' = 'base64'): Uint8Array {
+    let normalizedBase64 = base64;
+    
+    if (encoding === 'base64url') {
+        normalizedBase64 = base64
+            .replace(/-/g, '+')
+            .replace(/_/g, '/');
+        
+        const padding = normalizedBase64.length % 4;
+        if (padding) {
+            normalizedBase64 += '='.repeat(4 - padding);
+        }
+    }
+    
+    const binaryString = atob(normalizedBase64);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+    
+    for (let i = 0; i < len; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    
+    return bytes;
+}
+
+export function encodeBase64(buffer: Uint8Array, encoding: 'base64' | 'base64url' = 'base64'): string {
+    // Chunk the conversion to avoid `Maximum call stack size exceeded` on
+    // buffers larger than ~64KB on web (String.fromCharCode.apply blows up).
+    // 0x8000 keeps each apply call within engine limits across browsers.
+    const CHUNK = 0x8000;
+    let binaryString = '';
+    for (let i = 0; i < buffer.length; i += CHUNK) {
+        const chunk = buffer.subarray(i, i + CHUNK);
+        binaryString += String.fromCharCode.apply(null, chunk as unknown as number[]);
+    }
+    const base64 = btoa(binaryString);
+
+    if (encoding === 'base64url') {
+        return base64
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=/g, '');
+    }
+
+    return base64;
+}

package/sources/encryption/blob.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi, beforeAll } from 'vitest';
+import sodium from 'libsodium-wrappers';
+
+// Mock expo-crypto to use Node.js crypto
+vi.mock('expo-crypto', () => ({
+    getRandomBytes: (n: number) => {
+        const { randomBytes } = require('crypto');
+        return new Uint8Array(randomBytes(n));
+    },
+}));
+
+// Mock the libsodium.lib import to use the Node.js libsodium-wrappers
+vi.mock('@/encryption/libsodium.lib', () => {
+    const s = require('libsodium-wrappers');
+    return { default: s };
+});
+
+import { encryptBlob, decryptBlob } from './blob';
+
+// 32-byte key for crypto_secretbox (NaCl symmetric encryption)
+const TEST_KEY = new Uint8Array(32);
+for (let i = 0; i < 32; i++) TEST_KEY[i] = i;
+
+beforeAll(async () => {
+    await sodium.ready;
+});
+
+describe('blob encryption', () => {
+    it('should encrypt and decrypt a small blob', () => {
+        const data = new Uint8Array([1, 2, 3, 4, 5]);
+        const encrypted = encryptBlob(data, TEST_KEY);
+        const decrypted = decryptBlob(encrypted, TEST_KEY);
+
+        expect(decrypted).not.toBeNull();
+        expect(new Uint8Array(decrypted!)).toEqual(data);
+    });
+
+    it('should encrypt and decrypt an empty blob', () => {
+        const data = new Uint8Array(0);
+        const encrypted = encryptBlob(data, TEST_KEY);
+        const decrypted = decryptBlob(encrypted, TEST_KEY);
+
+        expect(decrypted).not.toBeNull();
+        expect(new Uint8Array(decrypted!)).toEqual(data);
+    });
+
+    it('should encrypt and decrypt a large blob (1MB)', () => {
+        const data = new Uint8Array(1024 * 1024);
+        for (let i = 0; i < data.length; i++) data[i] = i % 256;
+
+        const encrypted = encryptBlob(data, TEST_KEY);
+        const decrypted = decryptBlob(encrypted, TEST_KEY);
+
+        expect(decrypted).not.toBeNull();
+        expect(new Uint8Array(decrypted!)).toEqual(data);
+    });
+
+    it('should handle binary data with null bytes', () => {
+        const data = new Uint8Array([0, 0, 0, 255, 0, 128, 0]);
+        const encrypted = encryptBlob(data, TEST_KEY);
+        const decrypted = decryptBlob(encrypted, TEST_KEY);
+
+        expect(decrypted).not.toBeNull();
+        expect(new Uint8Array(decrypted!)).toEqual(data);
+    });
+
+    it('should produce different ciphertexts for same plaintext (random nonce)', () => {
+        const data = new Uint8Array([1, 2, 3]);
+        const encrypted1 = encryptBlob(data, TEST_KEY);
+        const encrypted2 = encryptBlob(data, TEST_KEY);
+
+        // Nonces differ, so ciphertexts should differ
+        expect(encrypted1).not.toEqual(encrypted2);
+
+        // But both decrypt to the same plaintext
+        expect(new Uint8Array(decryptBlob(encrypted1, TEST_KEY)!)).toEqual(data);
+        expect(new Uint8Array(decryptBlob(encrypted2, TEST_KEY)!)).toEqual(data);
+    });
+
+    it('should return null for wrong key', () => {
+        const data = new Uint8Array([1, 2, 3]);
+        const encrypted = encryptBlob(data, TEST_KEY);
+
+        const wrongKey = new Uint8Array(32);
+        wrongKey.fill(99);
+
+        const decrypted = decryptBlob(encrypted, wrongKey);
+        expect(decrypted).toBeNull();
+    });
+
+    it('should return null for corrupted ciphertext', () => {
+        const data = new Uint8Array([1, 2, 3]);
+        const encrypted = encryptBlob(data, TEST_KEY);
+
+        // Corrupt a byte in the ciphertext (after the nonce)
+        const corrupted = new Uint8Array(encrypted);
+        corrupted[encrypted.length - 1] ^= 0xff;
+
+        const decrypted = decryptBlob(corrupted, TEST_KEY);
+        expect(decrypted).toBeNull();
+    });
+
+    it('should return null for truncated data', () => {
+        const data = new Uint8Array([1, 2, 3]);
+        const encrypted = encryptBlob(data, TEST_KEY);
+
+        // Truncate to just 5 bytes (less than nonce)
+        const truncated = encrypted.slice(0, 5);
+        const decrypted = decryptBlob(truncated, TEST_KEY);
+        expect(decrypted).toBeNull();
+    });
+
+    it('encrypted blob should be larger than original (nonce + auth tag overhead)', () => {
+        const data = new Uint8Array([1, 2, 3, 4, 5]);
+        const encrypted = encryptBlob(data, TEST_KEY);
+
+        // crypto_secretbox: 24-byte nonce + 16-byte auth tag + plaintext
+        expect(encrypted.length).toBe(data.length + 24 + 16);
+    });
+});

package/sources/encryption/blob.ts

@@ -0,0 +1,58 @@
+/**
+ * Binary blob encryption/decryption using NaCl crypto_secretbox (XSalsa20-Poly1305).
+ *
+ * Unlike encryptSecretBox in libsodium.ts, this operates on raw Uint8Array
+ * without JSON serialization, making it suitable for image/file blobs.
+ *
+ * Wire format: [nonce (24 bytes)] [ciphertext + auth tag (16 bytes + data)]
+ */
+import sodium from '@/encryption/libsodium.lib';
+import { getRandomBytes } from 'expo-crypto';
+
+/**
+ * Encrypt a binary blob with a 32-byte secret key.
+ * Returns: nonce (24) + ciphertext (data.length + 16 auth tag)
+ */
+export function encryptBlob(data: Uint8Array, key: Uint8Array): Uint8Array {
+    const nonce = getRandomBytes(sodium.crypto_secretbox_NONCEBYTES);
+    // Defensive copies: the native libsodium TurboModule on iOS reads
+    // arguments via getArrayBuffer().length(runtime), which returns the
+    // *underlying ArrayBuffer's* byteLength rather than the view length.
+    // If a caller passes in a Uint8Array view onto a larger buffer, the
+    // native side can either reject it ("invalid key length") or read
+    // the wrong bytes. Materializing standalone copies for data/key
+    // makes those checks see exactly the bytes we intended to pass in.
+    const dataStandalone = data.byteOffset === 0 && data.buffer.byteLength === data.length ? data : data.slice();
+    const keyStandalone = key.byteOffset === 0 && key.buffer.byteLength === key.length ? key : key.slice();
+    const encrypted = sodium.crypto_secretbox_easy(dataStandalone, nonce, keyStandalone);
+    const encryptedStandalone = encrypted.byteOffset === 0 && encrypted.buffer.byteLength === encrypted.length
+        ? encrypted
+        : encrypted.slice();
+    const result = new Uint8Array(nonce.length + encryptedStandalone.length);
+    result.set(nonce, 0);
+    result.set(encryptedStandalone, nonce.length);
+    return result;
+}
+
+/**
+ * Decrypt a blob previously encrypted with encryptBlob.
+ * Returns null if decryption fails (wrong key, corrupted, truncated).
+ */
+export function decryptBlob(bundle: Uint8Array, key: Uint8Array): Uint8Array | null {
+    if (bundle.length < sodium.crypto_secretbox_NONCEBYTES + 16) {
+        return null;
+    }
+    const nonce = bundle.slice(0, sodium.crypto_secretbox_NONCEBYTES);
+    const ciphertext = bundle.slice(sodium.crypto_secretbox_NONCEBYTES);
+    // Same defensive standalone copy as in encryptBlob — the native iOS
+    // libsodium TurboModule validates the key by reading the underlying
+    // ArrayBuffer length, and rejects the operation if it sees anything
+    // other than 32 bytes. A subarray view onto a 64-byte HMAC output
+    // slips through length === 32 in JS land but fails this check.
+    const keyStandalone = key.byteOffset === 0 && key.buffer.byteLength === key.length ? key : key.slice();
+    try {
+        return sodium.crypto_secretbox_open_easy(ciphertext, nonce, keyStandalone);
+    } catch {
+        return null;
+    }
+}

package/sources/encryption/deriveKey.appspec.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect } from '@/dev/testRunner';
+import { deriveKey, deriveSecretKeyTreeRoot, deriveSecretKeyTreeChild } from './deriveKey';
+import { encodeUTF8 } from './text';
+import { encodeHex } from './hex';
+
+describe('Key Derivation Tests', () => {
+    // Test vectors
+    const testVectors = [
+        {
+            seed: encodeUTF8('test seed'),
+            usage: 'test usage',
+            path: ['child1', 'child2'],
+            expectedRootKey: 'E6E55652456F9FE47D6FF46CA3614E85B499F77E7B340FBBB1553307CEDC1E74',
+            expectedRootChainCode: '81ECFD529E8EF95DD5C06CFE169158CF02B7C09A33746C527B4BD4D740B9CC5A',
+            expectedChildKey: 'D5EAE039FB9143E9433BB1ADC104C2FF5D7FA6751E680B4B1CBC7ADF1AF65BF3',
+            expectedChildChainCode: '8AA339189BAB38B51DD8770B1498682BCB03E42240E273041ACC7E3DF62FE868',
+            expectedFinalKey: '1011C097D2105D27362B987A631496BBF68B836124D1D072E9D1613C6028CF75',
+            expectedFinalChainCode: 'BE98EF894B1C62B8253B480DD415B6EB707028362F2FCECF2CB3871DB8B007F1'
+        }
+    ];
+
+    it('deriveSecretKeyTreeRoot should produce correct root key and chain code', async () => {
+        for (const vector of testVectors) {
+            const result = await deriveSecretKeyTreeRoot(vector.seed, vector.usage);
+            expect(encodeHex(result.key)).toEqual(vector.expectedRootKey);
+            expect(encodeHex(result.chainCode)).toEqual(vector.expectedRootChainCode);
+        }
+    });
+
+    it('deriveSecretKeyTreeChild should produce correct child key and chain code', async () => {
+        for (const vector of testVectors) {
+            const rootState = await deriveSecretKeyTreeRoot(vector.seed, vector.usage);
+            const childState = await deriveSecretKeyTreeChild(rootState.chainCode, vector.path[0]);
+            const childState2 = await deriveSecretKeyTreeChild(childState.chainCode, vector.path[1]);
+            expect(encodeHex(childState.key)).toEqual(vector.expectedChildKey);
+            expect(encodeHex(childState.chainCode)).toEqual(vector.expectedChildChainCode);
+            expect(encodeHex(childState2.key)).toEqual(vector.expectedFinalKey);
+            expect(encodeHex(childState2.chainCode)).toEqual(vector.expectedFinalChainCode);
+        }
+    });
+
+    it('deriveKey should produce correct final key for given path', async () => {
+        for (const vector of testVectors) {
+            const result = await deriveKey(vector.seed, vector.usage, vector.path);
+            expect(encodeHex(result)).toEqual(vector.expectedFinalKey);
+        }
+    });
+
+    it('deriveKey should be deterministic', async () => {
+        for (const vector of testVectors) {
+            const result1 = await deriveKey(vector.seed, vector.usage, vector.path);
+            const result2 = await deriveKey(vector.seed, vector.usage, vector.path);
+            expect(encodeHex(result1)).toEqual(encodeHex(result2));
+        }
+    });
+
+    it('deriveKey should produce different keys for different paths', async () => {
+        for (const vector of testVectors) {
+            const result1 = await deriveKey(vector.seed, vector.usage, vector.path);
+            const result2 = await deriveKey(vector.seed, vector.usage, [...vector.path, 'additional']);
+            expect(encodeHex(result1)).not.toEqual(encodeHex(result2));
+        }
+    });
+
+    it('deriveKey should produce different keys for different usages', async () => {
+        for (const vector of testVectors) {
+            const result1 = await deriveKey(vector.seed, vector.usage, vector.path);
+            const result2 = await deriveKey(vector.seed, vector.usage + 'different', vector.path);
+            expect(encodeHex(result1)).not.toEqual(encodeHex(result2));
+        }
+    });
+});

package/sources/encryption/deriveKey.ts

@@ -0,0 +1,46 @@
+import { hmac_sha512 } from "./hmac_sha512";
+
+export type KeyTreeState = {
+    key: Uint8Array,
+    chainCode: Uint8Array
+};
+
+export async function deriveSecretKeyTreeRoot(seed: Uint8Array, usage: string): Promise<KeyTreeState> {
+    const I = await hmac_sha512(new TextEncoder().encode(usage + ' Master Seed'), seed);
+    return {
+        key: I.slice(0, 32),
+        chainCode: I.slice(32)
+    };
+}
+
+export async function deriveSecretKeyTreeChild(chainCode: Uint8Array, index: string): Promise<KeyTreeState> {
+
+    // Prepare data
+    const data = new Uint8Array([0x0, ...new TextEncoder().encode(index)]); // prepend 0x00 for separator
+
+    // Derive key
+    const I = await hmac_sha512(chainCode, data);
+    // Use slice() not subarray() so the returned key/chainCode each own a
+    // fresh 32-byte ArrayBuffer. The native libsodium TurboModule on iOS
+    // reads the underlying ArrayBuffer length (`.length(runtime)`) when
+    // validating crypto_secretbox key bytes — passing a subarray view onto
+    // a 64-byte parent buffer makes that check see 64 and reject with
+    // "invalid key length", even though the view itself is the right 32
+    // bytes. The sibling deriveSecretKeyTreeRoot already does this; keep
+    // the two consistent.
+    return {
+        key: I.slice(0, 32),
+        chainCode: I.slice(32),
+    };
+}
+
+export async function deriveKey(master: Uint8Array, usage: string, path: string[]): Promise<Uint8Array> {
+    let state = await deriveSecretKeyTreeRoot(master, usage);
+    let remaining = [...path];
+    while (remaining.length > 0) {
+        let index = remaining[0];
+        remaining = remaining.slice(1);
+        state = await deriveSecretKeyTreeChild(state.chainCode, index);
+    }
+    return state.key;
+}

package/sources/encryption/hex.ts

@@ -0,0 +1,17 @@
+import * as hex from '@stablelib/hex';
+
+export function decodeHex(hexString: string, format: 'normal' | 'mac' = 'normal'): Uint8Array {
+    if (format === 'mac') {
+        const encoded = hexString.replace(/:/g, '');
+        return hex.decode(encoded);
+    }
+    return hex.decode(hexString);
+}
+
+export function encodeHex(buffer: Uint8Array, format: 'normal' | 'mac' = 'normal'): string {
+    if (format === 'mac') {
+        const encoded = hex.encode(buffer);
+        return encoded.match(/.{2}/g)?.join(':') || '';
+    }
+    return hex.encode(buffer);
+}

package/sources/encryption/hmac_sha512.appspec.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from '@/dev/testRunner';
+import { hmac_sha512 } from './hmac_sha512';
+import { decode as decodeHex } from '@stablelib/hex';
+
+function decodeHexString(hexString: string, format: 'normal' | 'mac' = 'normal'): Uint8Array {
+    if (format === 'mac') {
+        const encoded = hexString.replace(/:/g, '');
+        return decodeHex(encoded);
+    }
+    return decodeHex(hexString);
+}
+
+// Test Vectors
+// https://datatracker.ietf.org/doc/html/rfc4231
+const VECTORS = [
+    {
+        key: new TextEncoder().encode('Jefe'),
+        data: decodeHexString('7768617420646f2079612077616e7420666f72206e6f7468696e673f'),
+        output: decodeHexString('164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737')
+    },
+    {
+        key: decodeHexString('0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b'),
+        data: decodeHexString('4869205468657265'),
+        output: decodeHexString('87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854')
+    },
+    {
+        key: decodeHexString('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'),
+        data: decodeHexString('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd'),
+        output: decodeHexString('fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb')
+    }
+];
+
+describe('hmac_sha512', () => {
+    it('should process test vectors', async () => {
+        for (let vec of VECTORS) {
+            let res = await hmac_sha512(vec.key, vec.data);
+            expect(res).toEqual(vec.output);
+        }
+    });
+});