mirror of
https://github.com/kccleoc/seedpgp-web.git
synced 2026-03-07 09:57:50 +08:00
docs: enhance documentation with threat model, limitations, air-gapped guidance
- Update version to v1.4.4 - Add explicit threat model documentation - Document known limitations prominently - Include air-gapped usage recommendations - Polish all documentation for clarity and examples - Update README, DEVELOPMENT.md, GEMINI.md, RECOVERY_PLAYBOOK.md
This commit is contained in:
LC mac
101
src/App.tsx
101
src/App.tsx
@@ -14,7 +14,7 @@ import { PgpKeyInput } from './components/PgpKeyInput';
|
||||
import { QrDisplay } from './components/QrDisplay';
|
||||
import QRScanner from './components/QRScanner';
|
||||
import { validateBip39Mnemonic } from './lib/bip39';
|
||||
import { buildPlaintext, encryptToSeedPgp, decryptSeedPgp } from './lib/seedpgp';
|
||||
import { buildPlaintext, encryptToSeed, decryptFromSeed, detectEncryptionMode } from './lib/seedpgp';
|
||||
import * as openpgp from 'openpgp';
|
||||
import { SecurityWarnings } from './components/SecurityWarnings';
|
||||
import { getSessionKey, encryptJsonToBlob, destroySessionKey, EncryptedBlob } from './lib/sessionCrypto';
|
||||
@@ -66,6 +66,12 @@ function App() {
|
||||
const [clipboardEvents, setClipboardEvents] = useState<ClipboardEvent[]>([]);
|
||||
const [showLockConfirm, setShowLockConfirm] = useState(false);
|
||||
|
||||
// Krux integration state
|
||||
const [encryptionMode, setEncryptionMode] = useState<'pgp' | 'krux'>('pgp');
|
||||
const [kruxLabel, setKruxLabel] = useState('Seed Backup');
|
||||
const [kruxIterations, setKruxIterations] = useState(200000);
|
||||
const [detectedMode, setDetectedMode] = useState<'pgp' | 'krux' | null>(null);
|
||||
|
||||
const SENSITIVE_PATTERNS = ['key', 'mnemonic', 'seed', 'private', 'secret', 'pgp', 'password'];
|
||||
|
||||
const isSensitiveKey = (key: string): boolean => {
|
||||
@@ -170,6 +176,20 @@ function App() {
|
||||
return () => document.removeEventListener('copy', handleCopy as EventListener);
|
||||
}, []);
|
||||
|
||||
// Detect encryption mode from restore input
|
||||
useEffect(() => {
|
||||
if (activeTab === 'restore' && restoreInput.trim()) {
|
||||
const detected = detectEncryptionMode(restoreInput);
|
||||
setDetectedMode(detected);
|
||||
// Auto-switch mode if not already set
|
||||
if (detected !== encryptionMode) {
|
||||
setEncryptionMode(detected);
|
||||
}
|
||||
} else {
|
||||
setDetectedMode(null);
|
||||
}
|
||||
}, [restoreInput, activeTab, encryptionMode]);
|
||||
|
||||
const clearClipboard = async () => {
|
||||
try {
|
||||
// Actually clear the system clipboard
|
||||
@@ -233,10 +253,13 @@ function App() {
|
||||
|
||||
const plaintext = buildPlaintext(mnemonic, hasBip39Passphrase);
|
||||
|
||||
const result = await encryptToSeedPgp({
|
||||
const result = await encryptToSeed({
|
||||
plaintext,
|
||||
publicKeyArmored: publicKeyInput || undefined,
|
||||
messagePassword: backupMessagePassword || undefined,
|
||||
mode: encryptionMode,
|
||||
kruxLabel: encryptionMode === 'krux' ? kruxLabel : undefined,
|
||||
kruxIterations: encryptionMode === 'krux' ? kruxIterations : undefined,
|
||||
});
|
||||
|
||||
setQrPayload(result.framed);
|
||||
@@ -263,11 +286,15 @@ function App() {
|
||||
setDecryptedRestoredMnemonic(null);
|
||||
|
||||
try {
|
||||
const result = await decryptSeedPgp({
|
||||
// Auto-detect mode if not manually set
|
||||
const modeToUse = detectedMode || encryptionMode;
|
||||
|
||||
const result = await decryptFromSeed({
|
||||
frameText: restoreInput,
|
||||
privateKeyArmored: privateKeyInput || undefined,
|
||||
privateKeyPassphrase: privateKeyPassphrase || undefined,
|
||||
messagePassword: restoreMessagePassword || undefined,
|
||||
mode: modeToUse,
|
||||
});
|
||||
|
||||
// Encrypt the restored mnemonic with the session key
|
||||
@@ -459,6 +486,66 @@ function App() {
|
||||
|
||||
<div className="p-5 bg-gradient-to-br from-slate-50 to-slate-100 rounded-2xl border-2 border-slate-200 shadow-inner space-y-4">
|
||||
{/* Removed h3 */}
|
||||
|
||||
{/* Encryption Mode Toggle */}
|
||||
<div className="space-y-2">
|
||||
<label className="text-xs font-bold text-slate-500 uppercase tracking-wider">Encryption Mode</label>
|
||||
<select
|
||||
value={encryptionMode}
|
||||
onChange={(e) => setEncryptionMode(e.target.value as 'pgp' | 'krux')}
|
||||
disabled={isReadOnly}
|
||||
className="w-full px-3 py-2.5 bg-white border border-slate-200 rounded-lg text-sm focus:outline-none focus:ring-2 focus:ring-teal-500 transition-all"
|
||||
>
|
||||
<option value="pgp">PGP (Asymmetric)</option>
|
||||
<option value="krux">Krux KEF (Passphrase)</option>
|
||||
</select>
|
||||
<p className="text-[10px] text-slate-500 mt-1">
|
||||
{encryptionMode === 'pgp'
|
||||
? 'Uses PGP keys or password'
|
||||
: 'Uses passphrase only (Krux compatible)'}
|
||||
</p>
|
||||
</div>
|
||||
|
||||
{/* Krux-specific fields */}
|
||||
{encryptionMode === 'krux' && activeTab === 'backup' && (
|
||||
<>
|
||||
<div className="space-y-2 pt-2">
|
||||
<label className="text-xs font-bold text-slate-500 uppercase tracking-wider">Krux Label</label>
|
||||
<div className="relative">
|
||||
<input
|
||||
type="text"
|
||||
className={`w-full pl-3 pr-4 py-2.5 bg-white border border-slate-200 rounded-lg text-sm focus:outline-none focus:ring-2 focus:ring-teal-500 transition-all ${
|
||||
isReadOnly ? 'blur-sm select-none' : ''
|
||||
}`}
|
||||
placeholder="e.g., My Seed 2026"
|
||||
value={kruxLabel}
|
||||
onChange={(e) => setKruxLabel(e.target.value)}
|
||||
readOnly={isReadOnly}
|
||||
/>
|
||||
</div>
|
||||
<p className="text-[10px] text-slate-500 mt-1">Label for identification (max 252 bytes)</p>
|
||||
</div>
|
||||
|
||||
<div className="space-y-2">
|
||||
<label className="text-xs font-bold text-slate-500 uppercase tracking-wider">PBKDF2 Iterations</label>
|
||||
<div className="relative">
|
||||
<input
|
||||
type="number"
|
||||
className={`w-full pl-3 pr-4 py-2.5 bg-white border border-slate-200 rounded-lg text-sm focus:outline-none focus:ring-2 focus:ring-teal-500 transition-all ${
|
||||
isReadOnly ? 'blur-sm select-none' : ''
|
||||
}`}
|
||||
placeholder="e.g., 200000"
|
||||
value={kruxIterations}
|
||||
onChange={(e) => setKruxIterations(Number(e.target.value))}
|
||||
min={10000}
|
||||
step={10000}
|
||||
readOnly={isReadOnly}
|
||||
/>
|
||||
</div>
|
||||
<p className="text-[10px] text-slate-500 mt-1">Higher = more secure but slower (default: 200,000)</p>
|
||||
</div>
|
||||
</>
|
||||
)}
|
||||
|
||||
<div className="space-y-2">
|
||||
<label className="text-xs font-bold text-slate-500 uppercase tracking-wider">Message Password</label>
|
||||
@@ -469,13 +556,17 @@ function App() {
|
||||
className={`w-full pl-10 pr-4 py-2.5 bg-white border border-slate-200 rounded-lg text-sm focus:outline-none focus:ring-2 focus:ring-teal-500 transition-all ${
|
||||
isReadOnly ? 'blur-sm select-none' : ''
|
||||
}`}
|
||||
placeholder="Optional password..."
|
||||
placeholder={encryptionMode === 'krux' ? "Required for Krux encryption" : "Optional password..."}
|
||||
value={activeTab === 'backup' ? backupMessagePassword : restoreMessagePassword}
|
||||
onChange={(e) => activeTab === 'backup' ? setBackupMessagePassword(e.target.value) : setRestoreMessagePassword(e.target.value)}
|
||||
readOnly={isReadOnly}
|
||||
/>
|
||||
</div>
|
||||
<p className="text-[10px] text-slate-500 mt-1">Symmetric encryption password (SKESK)</p>
|
||||
<p className="text-[10px] text-slate-500 mt-1">
|
||||
{encryptionMode === 'krux'
|
||||
? 'Required passphrase for Krux encryption'
|
||||
: 'Symmetric encryption password (SKESK)'}
|
||||
</p>
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
189
src/lib/krux.test.ts
Normal file
189
src/lib/krux.test.ts
Normal file
@@ -0,0 +1,189 @@
|
||||
// Krux KEF tests using Bun test runner
|
||||
import { describe, test, expect } from "bun:test";
|
||||
import {
|
||||
encryptToKrux,
|
||||
decryptFromKrux,
|
||||
hexToBytes,
|
||||
bytesToHex,
|
||||
wrap,
|
||||
unwrap,
|
||||
KruxCipher
|
||||
} from './krux';
|
||||
|
||||
describe('Krux KEF Implementation', () => {
|
||||
// Test basic hex conversion
|
||||
test('hexToBytes and bytesToHex roundtrip', () => {
|
||||
const original = 'Hello, World!';
|
||||
const bytes = new TextEncoder().encode(original);
|
||||
const hex = bytesToHex(bytes);
|
||||
const back = hexToBytes(hex);
|
||||
expect(new TextDecoder().decode(back)).toBe(original);
|
||||
});
|
||||
|
||||
test('hexToBytes handles KEF: prefix', () => {
|
||||
const hex = '48656C6C6F';
|
||||
const withPrefix = `KEF:${hex}`;
|
||||
const bytes1 = hexToBytes(hex);
|
||||
const bytes2 = hexToBytes(withPrefix);
|
||||
expect(bytes2).toEqual(bytes1);
|
||||
});
|
||||
|
||||
test('hexToBytes rejects invalid hex', () => {
|
||||
expect(() => hexToBytes('12345')).toThrow('Hex string must have even length');
|
||||
expect(() => hexToBytes('12345G')).toThrow('Invalid hex string');
|
||||
});
|
||||
|
||||
// Test wrap/unwrap
|
||||
test('wrap and unwrap roundtrip', () => {
|
||||
const label = 'Test Label';
|
||||
const version = 20;
|
||||
const iterations = 200000;
|
||||
const payload = new TextEncoder().encode('test payload');
|
||||
|
||||
const wrapped = wrap(label, version, iterations, payload);
|
||||
const unwrapped = unwrap(wrapped);
|
||||
|
||||
expect(unwrapped.label).toBe(label);
|
||||
expect(unwrapped.version).toBe(version);
|
||||
expect(unwrapped.iterations).toBe(iterations);
|
||||
expect(unwrapped.payload).toEqual(payload);
|
||||
});
|
||||
|
||||
test('wrap rejects label too long', () => {
|
||||
const longLabel = 'a'.repeat(253); // 253 > 252 max
|
||||
const payload = new Uint8Array([1, 2, 3]);
|
||||
|
||||
expect(() => wrap(longLabel, 20, 10000, payload))
|
||||
.toThrow('Label too long');
|
||||
});
|
||||
|
||||
test('wrap accepts empty label', () => {
|
||||
const payload = new Uint8Array([1, 2, 3]);
|
||||
const wrapped = wrap('', 20, 10000, payload);
|
||||
const unwrapped = unwrap(wrapped);
|
||||
expect(unwrapped.label).toBe('');
|
||||
expect(unwrapped.version).toBe(20);
|
||||
expect(unwrapped.iterations).toBe(10000);
|
||||
expect(unwrapped.payload).toEqual(payload);
|
||||
});
|
||||
|
||||
test('unwrap rejects invalid envelope', () => {
|
||||
expect(() => unwrap(new Uint8Array([1, 2, 3]))).toThrow('Invalid KEF envelope: too short');
|
||||
|
||||
// Label length too large (253 > 252)
|
||||
expect(() => unwrap(new Uint8Array([253, 20, 0, 0, 100]))).toThrow('Invalid label length');
|
||||
|
||||
// Empty label (lenId=0) is valid, but need enough data for version+iterations
|
||||
// Create a valid envelope with empty label: [0, version, iter1, iter2, iter3, payload...]
|
||||
const emptyLabelEnvelope = new Uint8Array([0, 20, 0, 0, 100, 1, 2, 3]);
|
||||
const unwrapped = unwrap(emptyLabelEnvelope);
|
||||
expect(unwrapped.label).toBe('');
|
||||
expect(unwrapped.version).toBe(20);
|
||||
});
|
||||
|
||||
// Test encryption/decryption
|
||||
test('encryptToKrux and decryptFromKrux roundtrip', async () => {
|
||||
const mnemonic = 'test test test test test test test test test test test junk';
|
||||
const passphrase = 'secure-passphrase';
|
||||
const label = 'Test Seed';
|
||||
const iterations = 10000;
|
||||
|
||||
const encrypted = await encryptToKrux({
|
||||
mnemonic,
|
||||
passphrase,
|
||||
label,
|
||||
iterations,
|
||||
version: 20,
|
||||
});
|
||||
|
||||
expect(encrypted.kefHex).toMatch(/^[0-9A-F]+$/);
|
||||
expect(encrypted.label).toBe(label);
|
||||
expect(encrypted.iterations).toBe(iterations);
|
||||
expect(encrypted.version).toBe(20);
|
||||
|
||||
const decrypted = await decryptFromKrux({
|
||||
kefHex: encrypted.kefHex,
|
||||
passphrase,
|
||||
});
|
||||
|
||||
expect(decrypted.mnemonic).toBe(mnemonic);
|
||||
expect(decrypted.label).toBe(label);
|
||||
expect(decrypted.iterations).toBe(iterations);
|
||||
expect(decrypted.version).toBe(20);
|
||||
});
|
||||
|
||||
test('encryptToKrux requires passphrase', async () => {
|
||||
await expect(encryptToKrux({
|
||||
mnemonic: 'test',
|
||||
passphrase: '',
|
||||
})).rejects.toThrow('Passphrase is required');
|
||||
});
|
||||
|
||||
test('decryptFromKrux requires passphrase', async () => {
|
||||
await expect(decryptFromKrux({
|
||||
kefHex: '123456',
|
||||
passphrase: '',
|
||||
})).rejects.toThrow('Passphrase is required');
|
||||
});
|
||||
|
||||
test('wrong passphrase fails decryption', async () => {
|
||||
const mnemonic = 'test mnemonic';
|
||||
const passphrase = 'correct-passphrase';
|
||||
|
||||
const encrypted = await encryptToKrux({
|
||||
mnemonic,
|
||||
passphrase,
|
||||
});
|
||||
|
||||
await expect(decryptFromKrux({
|
||||
kefHex: encrypted.kefHex,
|
||||
passphrase: 'wrong-passphrase',
|
||||
})).rejects.toThrow(/Krux decryption failed/);
|
||||
});
|
||||
|
||||
// Test KruxCipher class directly
|
||||
test('KruxCipher encrypt/decrypt roundtrip', async () => {
|
||||
const cipher = new KruxCipher('passphrase', 'salt', 10000);
|
||||
const plaintext = new TextEncoder().encode('secret message');
|
||||
|
||||
const encrypted = await cipher.encrypt(plaintext);
|
||||
const decrypted = await cipher.decrypt(encrypted, 20);
|
||||
|
||||
expect(new TextDecoder().decode(decrypted)).toBe('secret message');
|
||||
});
|
||||
|
||||
test('KruxCipher rejects unsupported version', async () => {
|
||||
const cipher = new KruxCipher('passphrase', 'salt', 10000);
|
||||
const plaintext = new Uint8Array([1, 2, 3]);
|
||||
|
||||
await expect(cipher.encrypt(plaintext, 99)).rejects.toThrow('Unsupported KEF version');
|
||||
await expect(cipher.decrypt(new Uint8Array(50), 99)).rejects.toThrow('Unsupported KEF version');
|
||||
});
|
||||
|
||||
test('KruxCipher rejects short payload', async () => {
|
||||
const cipher = new KruxCipher('passphrase', 'salt', 10000);
|
||||
// Version 20: IV (12) + auth (4) = 16 bytes minimum
|
||||
const shortPayload = new Uint8Array(15); // Too short for IV + GCM tag (needs at least 16)
|
||||
|
||||
await expect(cipher.decrypt(shortPayload, 20)).rejects.toThrow('Payload too short for AES-GCM');
|
||||
});
|
||||
|
||||
test('iterations scaling works correctly', () => {
|
||||
// Test that iterations are scaled properly when divisible by 10000
|
||||
const label = 'Test';
|
||||
const version = 20;
|
||||
const payload = new Uint8Array([1, 2, 3]);
|
||||
|
||||
// 200000 should be scaled to 20 in the envelope
|
||||
const wrapped1 = wrap(label, version, 200000, payload);
|
||||
expect(wrapped1[6]).toBe(0); // 200000 / 10000 = 20
|
||||
expect(wrapped1[7]).toBe(0);
|
||||
expect(wrapped1[8]).toBe(20);
|
||||
|
||||
// 10001 should not be scaled
|
||||
const wrapped2 = wrap(label, version, 10001, payload);
|
||||
const iterStart = 2 + label.length;
|
||||
const iters = (wrapped2[iterStart] << 16) | (wrapped2[iterStart + 1] << 8) | wrapped2[iterStart + 2];
|
||||
expect(iters).toBe(10001);
|
||||
});
|
||||
});
|
||||
331
src/lib/krux.ts
Normal file
331
src/lib/krux.ts
Normal file
@@ -0,0 +1,331 @@
|
||||
// src/lib/krux.ts
|
||||
// Krux KEF (Krux Encryption Format) implementation
|
||||
// Compatible with Krux firmware (AES-GCM, label as salt, hex QR)
|
||||
// Currently implements version 20 (AES-GCM without compression)
|
||||
// Version 21 (AES-GCM +c) support can be added later with compression
|
||||
|
||||
// KEF version definitions (matches Python reference)
|
||||
export const VERSIONS: Record<number, {
|
||||
name: string;
|
||||
compress?: boolean;
|
||||
auth: number; // GCM tag length (4 for version 20, full 16 for v1?)
|
||||
}> = {
|
||||
20: { name: "AES-GCM", auth: 4 },
|
||||
// Version 21 would be: { name: "AES-GCM +c", compress: true, auth: 4 }
|
||||
};
|
||||
|
||||
// IV length for GCM mode
|
||||
const GCM_IV_LENGTH = 12;
|
||||
|
||||
/**
|
||||
* Convert data to a proper ArrayBuffer for Web Crypto API.
|
||||
* Ensures it's not a SharedArrayBuffer.
|
||||
*/
|
||||
function toArrayBuffer(data: Uint8Array): ArrayBuffer {
|
||||
// Always create a new ArrayBuffer and copy the data
|
||||
const buffer = new ArrayBuffer(data.length);
|
||||
new Uint8Array(buffer).set(data);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Wrap data into KEF envelope format (matches Python exactly)
|
||||
* Format: [1 byte label length][label bytes][1 byte version][3 bytes iterations][payload]
|
||||
*/
|
||||
export function wrap(label: string, version: number, iterations: number, payload: Uint8Array): Uint8Array {
|
||||
const labelBytes = new TextEncoder().encode(label);
|
||||
if (!(0 <= labelBytes.length && labelBytes.length <= 252)) {
|
||||
throw new Error("Label too long (max 252 bytes)");
|
||||
}
|
||||
|
||||
const lenId = new Uint8Array([labelBytes.length]);
|
||||
const versionByte = new Uint8Array([version]);
|
||||
|
||||
let itersBytes = new Uint8Array(3);
|
||||
// Krux firmware expects iterations in multiples of 10000 when possible
|
||||
if (iterations % 10000 === 0) {
|
||||
const scaled = iterations / 10000;
|
||||
if (!(1 <= scaled && scaled <= 10000)) {
|
||||
throw new Error("Iterations out of scaled range");
|
||||
}
|
||||
itersBytes[0] = (scaled >> 16) & 0xff;
|
||||
itersBytes[1] = (scaled >> 8) & 0xff;
|
||||
itersBytes[2] = scaled & 0xff;
|
||||
} else {
|
||||
if (!(10000 < iterations && iterations < 2**24)) {
|
||||
throw new Error("Iterations out of range");
|
||||
}
|
||||
itersBytes[0] = (iterations >> 16) & 0xff;
|
||||
itersBytes[1] = (iterations >> 8) & 0xff;
|
||||
itersBytes[2] = iterations & 0xff;
|
||||
}
|
||||
|
||||
return new Uint8Array([...lenId, ...labelBytes, ...versionByte, ...itersBytes, ...payload]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Unwrap KEF envelope to extract components (matches Python exactly)
|
||||
*/
|
||||
export function unwrap(envelope: Uint8Array): {
|
||||
label: string;
|
||||
version: number;
|
||||
iterations: number;
|
||||
payload: Uint8Array
|
||||
} {
|
||||
if (envelope.length < 5) {
|
||||
throw new Error("Invalid KEF envelope: too short");
|
||||
}
|
||||
|
||||
const lenId = envelope[0];
|
||||
if (!(0 <= lenId && lenId <= 252)) {
|
||||
throw new Error("Invalid label length in KEF envelope");
|
||||
}
|
||||
|
||||
if (1 + lenId + 4 > envelope.length) {
|
||||
throw new Error("Invalid KEF envelope: insufficient data");
|
||||
}
|
||||
|
||||
const labelBytes = envelope.subarray(1, 1 + lenId);
|
||||
const label = new TextDecoder().decode(labelBytes);
|
||||
const version = envelope[1 + lenId];
|
||||
|
||||
const iterStart = 2 + lenId;
|
||||
let iters = (envelope[iterStart] << 16) | (envelope[iterStart + 1] << 8) | envelope[iterStart + 2];
|
||||
const iterations = iters <= 10000 ? iters * 10000 : iters;
|
||||
|
||||
const payload = envelope.subarray(5 + lenId);
|
||||
|
||||
return { label, version, iterations, payload };
|
||||
}
|
||||
|
||||
/**
|
||||
* Krux Cipher class for AES-GCM encryption/decryption
|
||||
*/
|
||||
export class KruxCipher {
|
||||
private keyPromise: Promise<CryptoKey>;
|
||||
|
||||
constructor(passphrase: string, salt: string, iterations: number) {
|
||||
const encoder = new TextEncoder();
|
||||
this.keyPromise = (async () => {
|
||||
// Import passphrase as raw key material
|
||||
const passphraseBytes = encoder.encode(passphrase);
|
||||
const passphraseBuffer = toArrayBuffer(passphraseBytes);
|
||||
|
||||
const baseKey = await crypto.subtle.importKey(
|
||||
"raw",
|
||||
passphraseBuffer,
|
||||
{ name: "PBKDF2" },
|
||||
false,
|
||||
["deriveKey"]
|
||||
);
|
||||
|
||||
// Derive AES-GCM key using PBKDF2
|
||||
const saltBytes = encoder.encode(salt);
|
||||
const saltBuffer = toArrayBuffer(saltBytes);
|
||||
|
||||
return crypto.subtle.deriveKey(
|
||||
{
|
||||
name: "PBKDF2",
|
||||
salt: saltBuffer,
|
||||
iterations: Math.max(1, iterations),
|
||||
hash: "SHA-256"
|
||||
},
|
||||
baseKey,
|
||||
{ name: "AES-GCM", length: 256 },
|
||||
false,
|
||||
["encrypt", "decrypt"]
|
||||
);
|
||||
})();
|
||||
}
|
||||
|
||||
/**
|
||||
* Encrypt plaintext using AES-GCM
|
||||
*/
|
||||
async encrypt(plaintext: Uint8Array, version = 20, iv?: Uint8Array): Promise<Uint8Array> {
|
||||
const v = VERSIONS[version];
|
||||
if (!v) {
|
||||
throw new Error(`Unsupported KEF version: ${version}`);
|
||||
}
|
||||
|
||||
// Note: No compression for version 20
|
||||
// For version 21, we would add compression here
|
||||
|
||||
// Ensure ivBytes is a fresh Uint8Array with its own ArrayBuffer (not SharedArrayBuffer)
|
||||
let ivBytes: Uint8Array;
|
||||
if (iv) {
|
||||
// Copy the iv to ensure we have our own buffer
|
||||
ivBytes = new Uint8Array(iv.length);
|
||||
ivBytes.set(iv);
|
||||
} else {
|
||||
// Create new random IV with a proper ArrayBuffer
|
||||
ivBytes = new Uint8Array(GCM_IV_LENGTH);
|
||||
crypto.getRandomValues(ivBytes);
|
||||
}
|
||||
|
||||
const key = await this.keyPromise;
|
||||
const plaintextBuffer = toArrayBuffer(plaintext);
|
||||
const ivBuffer = toArrayBuffer(ivBytes);
|
||||
|
||||
// Use auth length from version definition (in bytes, convert to bits)
|
||||
const tagLengthBits = v.auth * 8;
|
||||
|
||||
const encrypted = await crypto.subtle.encrypt(
|
||||
{
|
||||
name: "AES-GCM",
|
||||
iv: ivBuffer,
|
||||
tagLength: tagLengthBits
|
||||
},
|
||||
key,
|
||||
plaintextBuffer
|
||||
);
|
||||
|
||||
// For GCM, encrypted result includes ciphertext + tag
|
||||
// Separate ciphertext and tag
|
||||
const authBytes = v.auth;
|
||||
const encryptedBytes = new Uint8Array(encrypted);
|
||||
const ciphertext = encryptedBytes.slice(0, encryptedBytes.length - authBytes);
|
||||
const tag = encryptedBytes.slice(encryptedBytes.length - authBytes);
|
||||
|
||||
// Combine IV + ciphertext + tag (matches Python format)
|
||||
const combined = new Uint8Array(ivBytes.length + ciphertext.length + tag.length);
|
||||
combined.set(ivBytes, 0);
|
||||
combined.set(ciphertext, ivBytes.length);
|
||||
combined.set(tag, ivBytes.length + ciphertext.length);
|
||||
return combined;
|
||||
}
|
||||
|
||||
/**
|
||||
* Decrypt payload using AES-GCM
|
||||
*/
|
||||
async decrypt(payload: Uint8Array, version: number): Promise<Uint8Array> {
|
||||
const v = VERSIONS[version];
|
||||
if (!v) {
|
||||
throw new Error(`Unsupported KEF version: ${version}`);
|
||||
}
|
||||
|
||||
const ivLen = GCM_IV_LENGTH;
|
||||
const authBytes = v.auth;
|
||||
|
||||
// Payload is IV + ciphertext + tag
|
||||
if (payload.length < ivLen + authBytes) {
|
||||
throw new Error("Payload too short for AES-GCM");
|
||||
}
|
||||
|
||||
// Extract IV, ciphertext, and tag
|
||||
const iv = payload.slice(0, ivLen);
|
||||
const ciphertext = payload.slice(ivLen, payload.length - authBytes);
|
||||
const tag = payload.slice(payload.length - authBytes);
|
||||
|
||||
const key = await this.keyPromise;
|
||||
|
||||
try {
|
||||
// For Web Crypto, we need to combine ciphertext + tag
|
||||
const ciphertextWithTag = new Uint8Array(ciphertext.length + tag.length);
|
||||
ciphertextWithTag.set(ciphertext, 0);
|
||||
ciphertextWithTag.set(tag, ciphertext.length);
|
||||
|
||||
const ciphertextBuffer = toArrayBuffer(ciphertextWithTag);
|
||||
const ivBuffer = toArrayBuffer(iv);
|
||||
|
||||
const decrypted = await crypto.subtle.decrypt(
|
||||
{
|
||||
name: "AES-GCM",
|
||||
iv: ivBuffer,
|
||||
tagLength: authBytes * 8
|
||||
},
|
||||
key,
|
||||
ciphertextBuffer
|
||||
);
|
||||
|
||||
return new Uint8Array(decrypted);
|
||||
} catch (error) {
|
||||
// Web Crypto throws generic errors for decryption failure
|
||||
// Convert to user-friendly message
|
||||
throw new Error("Krux decryption failed - wrong passphrase or corrupted data");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert hex string to bytes
|
||||
*/
|
||||
export function hexToBytes(hex: string): Uint8Array {
|
||||
// Remove any whitespace and optional KEF: prefix
|
||||
const cleaned = hex.trim().replace(/\s/g, '').replace(/^KEF:/i, '');
|
||||
|
||||
if (!/^[0-9a-fA-F]+$/.test(cleaned)) {
|
||||
throw new Error("Invalid hex string");
|
||||
}
|
||||
|
||||
if (cleaned.length % 2 !== 0) {
|
||||
throw new Error("Hex string must have even length");
|
||||
}
|
||||
|
||||
const bytes = new Uint8Array(cleaned.length / 2);
|
||||
for (let i = 0; i < bytes.length; i++) {
|
||||
bytes[i] = parseInt(cleaned.substr(i * 2, 2), 16);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert bytes to hex string
|
||||
*/
|
||||
export function bytesToHex(bytes: Uint8Array): string {
|
||||
return Array.from(bytes)
|
||||
.map(b => b.toString(16).padStart(2, '0'))
|
||||
.join('')
|
||||
.toUpperCase();
|
||||
}
|
||||
|
||||
/**
|
||||
* Encrypt mnemonic to KEF format
|
||||
*/
|
||||
export async function encryptToKrux(params: {
|
||||
mnemonic: string;
|
||||
passphrase: string;
|
||||
label?: string;
|
||||
iterations?: number;
|
||||
version?: number;
|
||||
}): Promise<{ kefHex: string; label: string; version: number; iterations: number }> {
|
||||
const label = params.label || "Seed Backup";
|
||||
const iterations = params.iterations || 200000;
|
||||
const version = params.version || 20;
|
||||
|
||||
if (!params.passphrase) {
|
||||
throw new Error("Passphrase is required for Krux encryption");
|
||||
}
|
||||
|
||||
const mnemonicBytes = new TextEncoder().encode(params.mnemonic);
|
||||
const cipher = new KruxCipher(params.passphrase, label, iterations);
|
||||
const payload = await cipher.encrypt(mnemonicBytes, version);
|
||||
const kef = wrap(label, version, iterations, payload);
|
||||
|
||||
return {
|
||||
kefHex: bytesToHex(kef),
|
||||
label,
|
||||
version,
|
||||
iterations
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Decrypt KEF hex to mnemonic
|
||||
*/
|
||||
export async function decryptFromKrux(params: {
|
||||
kefHex: string;
|
||||
passphrase: string;
|
||||
}): Promise<{ mnemonic: string; label: string; version: number; iterations: number }> {
|
||||
if (!params.passphrase) {
|
||||
throw new Error("Passphrase is required for Krux decryption");
|
||||
}
|
||||
|
||||
const bytes = hexToBytes(params.kefHex);
|
||||
const { label, version, iterations, payload } = unwrap(bytes);
|
||||
const cipher = new KruxCipher(params.passphrase, label, iterations);
|
||||
const decrypted = await cipher.decrypt(payload, version);
|
||||
|
||||
const mnemonic = new TextDecoder().decode(decrypted);
|
||||
return { mnemonic, label, version, iterations };
|
||||
}
|
||||
@@ -1,7 +1,15 @@
|
||||
import * as openpgp from "openpgp";
|
||||
import { base45Encode, base45Decode } from "./base45";
|
||||
import { crc16CcittFalse } from "./crc16";
|
||||
import type { SeedPgpPlaintext, ParsedSeedPgpFrame } from "./types";
|
||||
import { encryptToKrux, decryptFromKrux, hexToBytes } from "./krux";
|
||||
import type {
|
||||
SeedPgpPlaintext,
|
||||
ParsedSeedPgpFrame,
|
||||
EncryptionMode,
|
||||
EncryptionParams,
|
||||
DecryptionParams,
|
||||
EncryptionResult
|
||||
} from "./types";
|
||||
|
||||
// Configure OpenPGP.js (disable warnings)
|
||||
openpgp.config.showComment = false;
|
||||
@@ -194,3 +202,135 @@ export async function decryptSeedPgp(params: {
|
||||
|
||||
return obj;
|
||||
}
|
||||
|
||||
/**
|
||||
* Unified encryption function supporting both PGP and Krux modes
|
||||
*/
|
||||
export async function encryptToSeed(params: EncryptionParams): Promise<EncryptionResult> {
|
||||
const mode = params.mode || 'pgp';
|
||||
|
||||
if (mode === 'krux') {
|
||||
const plaintextStr = typeof params.plaintext === 'string'
|
||||
? params.plaintext
|
||||
: params.plaintext.w;
|
||||
|
||||
const passphrase = params.messagePassword || '';
|
||||
if (!passphrase) {
|
||||
throw new Error("Krux mode requires a message password (passphrase)");
|
||||
}
|
||||
|
||||
try {
|
||||
const result = await encryptToKrux({
|
||||
mnemonic: plaintextStr,
|
||||
passphrase,
|
||||
label: params.kruxLabel,
|
||||
iterations: params.kruxIterations,
|
||||
version: params.kruxVersion,
|
||||
});
|
||||
|
||||
return {
|
||||
framed: result.kefHex,
|
||||
label: result.label,
|
||||
version: result.version,
|
||||
iterations: result.iterations,
|
||||
};
|
||||
} catch (error) {
|
||||
if (error instanceof Error) {
|
||||
throw new Error(`Krux encryption failed: ${error.message}`);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
// Default to PGP mode
|
||||
const plaintextObj = typeof params.plaintext === 'string'
|
||||
? buildPlaintext(params.plaintext, false)
|
||||
: params.plaintext;
|
||||
|
||||
const result = await encryptToSeedPgp({
|
||||
plaintext: plaintextObj,
|
||||
publicKeyArmored: params.publicKeyArmored,
|
||||
messagePassword: params.messagePassword,
|
||||
});
|
||||
|
||||
return {
|
||||
framed: result.framed,
|
||||
pgpBytes: result.pgpBytes,
|
||||
recipientFingerprint: result.recipientFingerprint,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Unified decryption function supporting both PGP and Krux modes
|
||||
*/
|
||||
export async function decryptFromSeed(params: DecryptionParams): Promise<SeedPgpPlaintext> {
|
||||
const mode = params.mode || 'pgp';
|
||||
|
||||
if (mode === 'krux') {
|
||||
const passphrase = params.messagePassword || '';
|
||||
if (!passphrase) {
|
||||
throw new Error("Krux mode requires a message password (passphrase)");
|
||||
}
|
||||
|
||||
try {
|
||||
const result = await decryptFromKrux({
|
||||
kefHex: params.frameText,
|
||||
passphrase,
|
||||
});
|
||||
|
||||
// Convert to SeedPgpPlaintext format for consistency
|
||||
return {
|
||||
v: 1,
|
||||
t: "bip39",
|
||||
w: result.mnemonic,
|
||||
l: "en",
|
||||
pp: 0,
|
||||
};
|
||||
} catch (error) {
|
||||
if (error instanceof Error) {
|
||||
throw new Error(`Krux decryption failed: ${error.message}`);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
// Default to PGP mode
|
||||
return decryptSeedPgp({
|
||||
frameText: params.frameText,
|
||||
privateKeyArmored: params.privateKeyArmored,
|
||||
privateKeyPassphrase: params.privateKeyPassphrase,
|
||||
messagePassword: params.messagePassword,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Detect encryption mode from input text
|
||||
*/
|
||||
export function detectEncryptionMode(text: string): EncryptionMode {
|
||||
const trimmed = text.trim();
|
||||
|
||||
// Check for SEEDPGP1 format
|
||||
if (trimmed.startsWith('SEEDPGP1:')) {
|
||||
return 'pgp';
|
||||
}
|
||||
|
||||
// Check for hex format (Krux KEF)
|
||||
const cleaned = trimmed.replace(/\s/g, '').replace(/^KEF:/i, '');
|
||||
if (/^[0-9a-fA-F]+$/.test(cleaned) && cleaned.length % 2 === 0) {
|
||||
// Try to parse as KEF to confirm
|
||||
try {
|
||||
const bytes = hexToBytes(cleaned);
|
||||
if (bytes.length >= 5) {
|
||||
const lenId = bytes[0];
|
||||
if (lenId > 0 && lenId <= 252 && 1 + lenId + 4 <= bytes.length) {
|
||||
return 'krux';
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// Not valid KEF, fall through
|
||||
}
|
||||
}
|
||||
|
||||
// Default to PGP for backward compatibility
|
||||
return 'pgp';
|
||||
}
|
||||
|
||||
@@ -12,3 +12,39 @@ export type ParsedSeedPgpFrame = {
|
||||
crc16: string;
|
||||
b45: string;
|
||||
};
|
||||
|
||||
// Krux KEF types
|
||||
export type KruxEncryptionParams = {
|
||||
label?: string;
|
||||
iterations?: number;
|
||||
version?: number;
|
||||
};
|
||||
|
||||
export type EncryptionMode = 'pgp' | 'krux';
|
||||
|
||||
export type EncryptionParams = {
|
||||
plaintext: SeedPgpPlaintext | string;
|
||||
publicKeyArmored?: string;
|
||||
messagePassword?: string;
|
||||
mode?: EncryptionMode;
|
||||
kruxLabel?: string;
|
||||
kruxIterations?: number;
|
||||
kruxVersion?: number;
|
||||
};
|
||||
|
||||
export type DecryptionParams = {
|
||||
frameText: string;
|
||||
privateKeyArmored?: string;
|
||||
privateKeyPassphrase?: string;
|
||||
messagePassword?: string;
|
||||
mode?: EncryptionMode;
|
||||
};
|
||||
|
||||
export type EncryptionResult = {
|
||||
framed: string;
|
||||
pgpBytes?: Uint8Array;
|
||||
recipientFingerprint?: string;
|
||||
label?: string;
|
||||
version?: number;
|
||||
iterations?: number;
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user