90 lines
2.4 KiB
TypeScript
90 lines
2.4 KiB
TypeScript
export class Hex {
|
|
static encode(buffer: ArrayBuffer): string {
|
|
let s = ''
|
|
for (const i of new Uint8Array(buffer)) {
|
|
s += i.toString(16).padStart(2, '0')
|
|
}
|
|
return s
|
|
}
|
|
|
|
static decode(s: string): ArrayBuffer {
|
|
const size = s.length / 2
|
|
const buffer = new Uint8Array(size)
|
|
for (let i = 0; i < size; i++) {
|
|
const idx = i * 2
|
|
const segment = s.slice(idx, idx + 2)
|
|
buffer[i] = parseInt(segment, 16)
|
|
}
|
|
return buffer
|
|
}
|
|
}
|
|
|
|
export class ArrayBufferUtils {
|
|
static async toString(buffer: ArrayBuffer): Promise<string> {
|
|
const reader = new window.FileReader()
|
|
reader.readAsDataURL(new Blob([buffer]))
|
|
return new Promise((resolve) => {
|
|
reader.onloadend = () => resolve(reader.result as string)
|
|
})
|
|
}
|
|
|
|
static async fromString(s: string): Promise<ArrayBuffer> {
|
|
return fetch(s)
|
|
.then((r) => r.blob())
|
|
.then((b) => b.arrayBuffer())
|
|
}
|
|
}
|
|
|
|
export class Keys {
|
|
public static async generateKey(size: 128 | 192 | 256 = 256): Promise<CryptoKey> {
|
|
const key = await window.crypto.subtle.generateKey(
|
|
{
|
|
name: 'AES-GCM',
|
|
length: size,
|
|
},
|
|
true,
|
|
['encrypt', 'decrypt']
|
|
)
|
|
return key
|
|
}
|
|
|
|
public static async export(key: CryptoKey): Promise<string> {
|
|
return Hex.encode(await window.crypto.subtle.exportKey('raw', key))
|
|
}
|
|
|
|
public static async import(key: string): Promise<CryptoKey> {
|
|
return window.crypto.subtle.importKey('raw', Hex.decode(key), { name: 'AES-GCM' }, true, [
|
|
'encrypt',
|
|
'decrypt',
|
|
])
|
|
}
|
|
}
|
|
|
|
export class Crypto {
|
|
private static ALG = 'AES-GCM'
|
|
private static DELIMITER = ':::'
|
|
|
|
public static getRandomBytes(size: number): Uint8Array {
|
|
return window.crypto.getRandomValues(new Uint8Array(size))
|
|
}
|
|
|
|
public static async encrypt(plaintext: ArrayBuffer, key: CryptoKey): Promise<string> {
|
|
const iv = this.getRandomBytes(12) // AES-GCM needs a 96bit IV
|
|
const encrypted: ArrayBuffer = await window.crypto.subtle.encrypt(
|
|
{ name: this.ALG, iv },
|
|
key,
|
|
plaintext
|
|
)
|
|
const data = [Hex.encode(iv), await ArrayBufferUtils.toString(encrypted)].join(this.DELIMITER)
|
|
return data
|
|
}
|
|
|
|
public static async decrypt(ciphertext: string, key: CryptoKey): Promise<ArrayBuffer> {
|
|
const splitted = ciphertext.split(this.DELIMITER)
|
|
const iv = Hex.decode(splitted[0])
|
|
const encrypted = await ArrayBufferUtils.fromString(splitted[1])
|
|
const plaintext = await window.crypto.subtle.decrypt({ name: this.ALG, iv }, key, encrypted)
|
|
return plaintext
|
|
}
|
|
}
|