1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
import { describe, expect, it } from "bun:test";
describe("Web Crypto", () => {
it("has globals", () => {
expect(crypto.subtle !== undefined).toBe(true);
expect(CryptoKey.name).toBe("CryptoKey");
expect(SubtleCrypto.name).toBe("SubtleCrypto");
});
it("should encrypt and decrypt", async () => {
const key = await crypto.subtle.generateKey(
{
name: "AES-GCM",
length: 256,
},
true,
["encrypt", "decrypt"],
);
const iv = crypto.getRandomValues(new Uint8Array(12));
const data = new TextEncoder().encode("Hello World!");
const encrypted = await crypto.subtle.encrypt(
{
name: "AES-GCM",
iv,
},
key,
data,
);
const decrypted = await crypto.subtle.decrypt(
{
name: "AES-GCM",
iv,
},
key,
encrypted,
);
expect(new TextDecoder().decode(decrypted)).toBe("Hello World!");
});
it("should verify and sign", async () => {
async function importKey(secret) {
return await crypto.subtle.importKey(
"raw",
new TextEncoder().encode(secret),
{ name: "HMAC", hash: "SHA-256" },
false,
["sign", "verify"],
);
}
async function signResponse(message, secret) {
const key = await importKey(secret);
const signature = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(message));
// Convert ArrayBuffer to Base64
return btoa(String.fromCharCode(...new Uint8Array(signature)));
}
async function verifySignature(message, signature, secret) {
const key = await importKey(secret);
// Convert Base64 to Uint8Array
const sigBuf = Uint8Array.from(atob(signature), c => c.charCodeAt(0));
return await crypto.subtle.verify("HMAC", key, sigBuf, new TextEncoder().encode(message));
}
const msg = `hello world`;
const SECRET = "secret";
const signature = await signResponse(msg, SECRET);
const isSigValid = await verifySignature(msg, signature, SECRET);
expect(isSigValid).toBe(true);
});
});
describe("Ed25519", () => {
describe("generateKey", () => {
it("should return CryptoKeys without namedCurve in algorithm field", async () => {
const { publicKey, privateKey } = (await crypto.subtle.generateKey("Ed25519", true, [
"sign",
"verify",
])) as CryptoKeyPair;
expect(publicKey.algorithm!.name).toBe("Ed25519");
// @ts-ignore
expect(publicKey.algorithm!.namedCurve).toBe(undefined);
expect(privateKey.algorithm!.name).toBe("Ed25519");
// @ts-ignore
expect(privateKey.algorithm!.namedCurve).toBe(undefined);
});
});
});
|
