131 lines
3.6 KiB
TypeScript
131 lines
3.6 KiB
TypeScript
// TODO: Consider whether we should shuffle this to Stack Util (as opposed to Primitive).
|
|
// It is async which breaks from our Primitive patterns.
|
|
|
|
import { generateRandomBytes, utf8ToBin } from '@bitauth/libauth';
|
|
|
|
// NOTE: We need to provide a default salt otherwise we would be deriving a key per each operation.
|
|
// This would be far too computationally expensive.
|
|
// TODO: Allow the salt to be customized in an options argument to the constructor.
|
|
export const DEFAULT_XO_SALT =
|
|
'cash.xo.default_salt_for_encryption_aabbccddeeff00112233445566778899';
|
|
|
|
export type EncrypterOpts = {
|
|
algorithm: string;
|
|
keyLength: number;
|
|
salt: Uint8Array;
|
|
ivLength: number;
|
|
iterations: number;
|
|
};
|
|
|
|
export class Encrypter {
|
|
constructor(
|
|
private key: CryptoKey,
|
|
public opts: EncrypterOpts,
|
|
) {}
|
|
|
|
static async fromBytes(key: Uint8Array, opts: Partial<EncrypterOpts> = {}) {
|
|
// Merge the provided options into our default options.
|
|
const encryptionOpts = {
|
|
algorithm: 'AES-GCM',
|
|
keyLength: 256,
|
|
salt: utf8ToBin(DEFAULT_XO_SALT),
|
|
// NOTE: IV of length 96 bits (12 bytes) is recommended length as per https://csrc.nist.gov/pubs/sp/800/38/d/final.
|
|
// This is both secure - and avoids additional compute incurred by hashing.
|
|
ivLength: 12,
|
|
iterations: 100_000,
|
|
...opts,
|
|
};
|
|
|
|
// Create a key derivation key
|
|
const keyMaterialBase = await crypto.subtle.importKey(
|
|
'raw',
|
|
key,
|
|
'PBKDF2',
|
|
false,
|
|
['deriveBits', 'deriveKey'],
|
|
);
|
|
|
|
// Derive the actual encryption key
|
|
const derivedKey = await crypto.subtle.deriveKey(
|
|
{
|
|
name: 'PBKDF2',
|
|
salt: encryptionOpts.salt,
|
|
iterations: encryptionOpts.iterations,
|
|
hash: 'SHA-256',
|
|
},
|
|
keyMaterialBase,
|
|
{
|
|
name: encryptionOpts.algorithm,
|
|
length: encryptionOpts.keyLength,
|
|
},
|
|
false,
|
|
['encrypt', 'decrypt'],
|
|
);
|
|
|
|
return new Encrypter(derivedKey, encryptionOpts);
|
|
}
|
|
|
|
static async fromPassphrase(
|
|
passphrase: string,
|
|
opts: Partial<EncrypterOpts> = {},
|
|
) {
|
|
const key = utf8ToBin(passphrase);
|
|
|
|
return this.fromBytes(key, opts);
|
|
}
|
|
|
|
static async generateRandom(opts: Partial<EncrypterOpts> = {}) {
|
|
const key = generateRandomBytes(32);
|
|
|
|
return this.fromBytes(key, opts);
|
|
}
|
|
|
|
async encrypt(payload: Uint8Array | string): Promise<Uint8Array> {
|
|
// Convert string payload to Uint8Array if needed
|
|
const data = typeof payload === 'string' ? utf8ToBin(payload) : payload;
|
|
|
|
// Generate random IV
|
|
const iv = crypto.getRandomValues(new Uint8Array(this.opts.ivLength));
|
|
|
|
// Encrypt the data
|
|
const encryptedData = await crypto.subtle.encrypt(
|
|
{
|
|
name: this.opts.algorithm,
|
|
iv,
|
|
},
|
|
this.key,
|
|
data,
|
|
);
|
|
|
|
// Combine IV and encrypted data
|
|
const result = new Uint8Array(iv.length + encryptedData.byteLength);
|
|
result.set(iv);
|
|
result.set(new Uint8Array(encryptedData), iv.length);
|
|
|
|
return result;
|
|
}
|
|
|
|
async decrypt(payload: Uint8Array | string): Promise<Uint8Array> {
|
|
// Ensure payload is Uint8Array
|
|
if (typeof payload === 'string') {
|
|
throw new Error('Encrypted payload must be Uint8Array');
|
|
}
|
|
|
|
// Extract IV and encrypted data
|
|
const iv = payload.slice(0, this.opts.ivLength);
|
|
const encryptedData = payload.slice(this.opts.ivLength);
|
|
|
|
// Decrypt the data
|
|
const decryptedData = await crypto.subtle.decrypt(
|
|
{
|
|
name: this.opts.algorithm,
|
|
iv,
|
|
},
|
|
this.key,
|
|
encryptedData,
|
|
);
|
|
|
|
return new Uint8Array(decryptedData);
|
|
}
|
|
}
|