anonyma 1.0.0 → 1.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +273 -144
- package/README.md +427 -143
- package/dist/ai/index.cjs +522 -0
- package/dist/ai/index.cjs.map +1 -0
- package/dist/ai/index.d.cts +322 -0
- package/dist/ai/index.d.ts +322 -0
- package/dist/ai/index.js +505 -0
- package/dist/ai/index.js.map +1 -0
- package/dist/audit/index.cjs +359 -0
- package/dist/audit/index.cjs.map +1 -0
- package/dist/audit/index.d.cts +287 -0
- package/dist/audit/index.d.ts +287 -0
- package/dist/audit/index.js +340 -0
- package/dist/audit/index.js.map +1 -0
- package/dist/chunk-26IHMQHL.cjs +662 -0
- package/dist/chunk-26IHMQHL.cjs.map +1 -0
- package/dist/chunk-2F2GWGTB.js +174 -0
- package/dist/chunk-2F2GWGTB.js.map +1 -0
- package/dist/chunk-2NNMJ55L.cjs +45 -0
- package/dist/chunk-2NNMJ55L.cjs.map +1 -0
- package/dist/chunk-2YG7R4KJ.cjs +114 -0
- package/dist/chunk-2YG7R4KJ.cjs.map +1 -0
- package/dist/chunk-2ZZHLCEJ.js +237 -0
- package/dist/chunk-2ZZHLCEJ.js.map +1 -0
- package/dist/chunk-3CY6ATKS.cjs +308 -0
- package/dist/chunk-3CY6ATKS.cjs.map +1 -0
- package/dist/chunk-3D5ZCJ7R.js +268 -0
- package/dist/chunk-3D5ZCJ7R.js.map +1 -0
- package/dist/chunk-6LDAIJBL.js +103 -0
- package/dist/chunk-6LDAIJBL.js.map +1 -0
- package/dist/chunk-7HK2V5Q4.js +111 -0
- package/dist/chunk-7HK2V5Q4.js.map +1 -0
- package/dist/chunk-AAP472NG.js +177 -0
- package/dist/chunk-AAP472NG.js.map +1 -0
- package/dist/chunk-AP4JIUNW.js +42 -0
- package/dist/chunk-AP4JIUNW.js.map +1 -0
- package/dist/chunk-BBJPQPGP.js +457 -0
- package/dist/chunk-BBJPQPGP.js.map +1 -0
- package/dist/chunk-CRXRJZEV.cjs +82 -0
- package/dist/chunk-CRXRJZEV.cjs.map +1 -0
- package/dist/chunk-E3PICZYI.js +20 -0
- package/dist/chunk-E3PICZYI.js.map +1 -0
- package/dist/chunk-F7O2FA3F.cjs +1255 -0
- package/dist/chunk-F7O2FA3F.cjs.map +1 -0
- package/dist/chunk-FB56NAAH.cjs +243 -0
- package/dist/chunk-FB56NAAH.cjs.map +1 -0
- package/dist/chunk-G4AN7FND.js +1063 -0
- package/dist/chunk-G4AN7FND.js.map +1 -0
- package/dist/chunk-GS3FRH4K.js +294 -0
- package/dist/chunk-GS3FRH4K.js.map +1 -0
- package/dist/chunk-GYMG5OI3.cjs +186 -0
- package/dist/chunk-GYMG5OI3.cjs.map +1 -0
- package/dist/chunk-IHEIYZPL.cjs +301 -0
- package/dist/chunk-IHEIYZPL.cjs.map +1 -0
- package/dist/chunk-IJAMLYOT.cjs +1087 -0
- package/dist/chunk-IJAMLYOT.cjs.map +1 -0
- package/dist/chunk-ISL5B4LU.cjs +181 -0
- package/dist/chunk-ISL5B4LU.cjs.map +1 -0
- package/dist/chunk-JKW36IPT.js +179 -0
- package/dist/chunk-JKW36IPT.js.map +1 -0
- package/dist/chunk-KOCQBDI4.cjs +179 -0
- package/dist/chunk-KOCQBDI4.cjs.map +1 -0
- package/dist/chunk-OGNLB2KA.js +79 -0
- package/dist/chunk-OGNLB2KA.js.map +1 -0
- package/dist/chunk-PKHZ7CVI.js +28 -0
- package/dist/chunk-PKHZ7CVI.js.map +1 -0
- package/dist/chunk-QYD4F6T7.cjs +114 -0
- package/dist/chunk-QYD4F6T7.cjs.map +1 -0
- package/dist/chunk-RCW5IPPR.js +1288 -0
- package/dist/chunk-RCW5IPPR.js.map +1 -0
- package/dist/chunk-RMMKYHUN.cjs +35 -0
- package/dist/chunk-RMMKYHUN.cjs.map +1 -0
- package/dist/chunk-S4BJ2ADB.cjs +22 -0
- package/dist/chunk-S4BJ2ADB.cjs.map +1 -0
- package/dist/chunk-S7NH6CHY.cjs +462 -0
- package/dist/chunk-S7NH6CHY.cjs.map +1 -0
- package/dist/chunk-SIHPDZXA.js +176 -0
- package/dist/chunk-SIHPDZXA.js.map +1 -0
- package/dist/chunk-TW7PM3UJ.cjs +30 -0
- package/dist/chunk-TW7PM3UJ.cjs.map +1 -0
- package/dist/chunk-UA3EOFBS.cjs +1322 -0
- package/dist/chunk-UA3EOFBS.cjs.map +1 -0
- package/dist/chunk-VE4CCW7W.js +32 -0
- package/dist/chunk-VE4CCW7W.js.map +1 -0
- package/dist/chunk-W6RBCHYF.js +651 -0
- package/dist/chunk-W6RBCHYF.js.map +1 -0
- package/dist/chunk-WLJN7GIS.cjs +189 -0
- package/dist/chunk-WLJN7GIS.cjs.map +1 -0
- package/dist/chunk-YMLR375Z.js +1244 -0
- package/dist/chunk-YMLR375Z.js.map +1 -0
- package/dist/compliance/index.cjs +88 -0
- package/dist/compliance/index.cjs.map +1 -0
- package/dist/compliance/index.d.cts +277 -0
- package/dist/compliance/index.d.ts +277 -0
- package/dist/compliance/index.js +47 -0
- package/dist/compliance/index.js.map +1 -0
- package/dist/crypto.cjs +12 -136
- package/dist/crypto.cjs.map +1 -1
- package/dist/crypto.d.cts +4 -3
- package/dist/crypto.d.ts +4 -3
- package/dist/crypto.js +3 -137
- package/dist/crypto.js.map +1 -1
- package/dist/detectors/index.cjs +146 -1483
- package/dist/detectors/index.cjs.map +1 -1
- package/dist/detectors/index.d.cts +1 -1
- package/dist/detectors/index.d.ts +1 -1
- package/dist/detectors/index.js +3 -1449
- package/dist/detectors/index.js.map +1 -1
- package/dist/engine/index.cjs +441 -0
- package/dist/engine/index.cjs.map +1 -0
- package/dist/engine/index.d.cts +728 -0
- package/dist/engine/index.d.ts +728 -0
- package/dist/engine/index.js +189 -0
- package/dist/engine/index.js.map +1 -0
- package/dist/hash-2PSYNDMM.cjs +14 -0
- package/dist/hash-2PSYNDMM.cjs.map +1 -0
- package/dist/hash-CELLDNKN.js +5 -0
- package/dist/hash-CELLDNKN.js.map +1 -0
- package/dist/index.cjs +153 -2816
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +93 -11
- package/dist/index.d.ts +93 -11
- package/dist/index.js +13 -2791
- package/dist/index.js.map +1 -1
- package/dist/json-CKDvlRtl.d.ts +147 -0
- package/dist/json-s8ny-RCo.d.cts +147 -0
- package/dist/mcp/index.cjs +751 -0
- package/dist/mcp/index.cjs.map +1 -0
- package/dist/mcp/index.d.cts +226 -0
- package/dist/mcp/index.d.ts +226 -0
- package/dist/mcp/index.js +744 -0
- package/dist/mcp/index.js.map +1 -0
- package/dist/middleware/express.cjs +93 -0
- package/dist/middleware/express.cjs.map +1 -0
- package/dist/middleware/express.d.cts +90 -0
- package/dist/middleware/express.d.ts +90 -0
- package/dist/middleware/express.js +91 -0
- package/dist/middleware/express.js.map +1 -0
- package/dist/middleware/hono.cjs +58 -0
- package/dist/middleware/hono.cjs.map +1 -0
- package/dist/middleware/hono.d.cts +75 -0
- package/dist/middleware/hono.d.ts +75 -0
- package/dist/middleware/hono.js +56 -0
- package/dist/middleware/hono.js.map +1 -0
- package/dist/middleware/index.cjs +24 -0
- package/dist/middleware/index.cjs.map +1 -0
- package/dist/middleware/index.d.cts +106 -0
- package/dist/middleware/index.d.ts +106 -0
- package/dist/middleware/index.js +15 -0
- package/dist/middleware/index.js.map +1 -0
- package/dist/schemas.cjs +5 -5
- package/dist/schemas.cjs.map +1 -1
- package/dist/schemas.d.cts +20 -10
- package/dist/schemas.d.ts +20 -10
- package/dist/schemas.js +5 -5
- package/dist/schemas.js.map +1 -1
- package/dist/session-BdRftyZ5.d.cts +102 -0
- package/dist/session-Cs2zlNQp.d.ts +102 -0
- package/dist/stream.cjs +13 -2262
- package/dist/stream.cjs.map +1 -1
- package/dist/stream.d.cts +1 -1
- package/dist/stream.d.ts +1 -1
- package/dist/stream.js +6 -2255
- package/dist/stream.js.map +1 -1
- package/dist/types--tPm_AjY.d.ts +199 -0
- package/dist/types-0BJH_wqc.d.cts +199 -0
- package/dist/types-CPUhjvl8.d.cts +629 -0
- package/dist/types-Dtht33aq.d.ts +629 -0
- package/dist/{types-D-9HzVuy.d.cts → types-EJTj_BKY.d.cts} +38 -7
- package/dist/{types-D-9HzVuy.d.ts → types-EJTj_BKY.d.ts} +38 -7
- package/dist/types-Zt_bZvwS.d.cts +182 -0
- package/dist/types-Zt_bZvwS.d.ts +182 -0
- package/dist/validators.cjs +39 -181
- package/dist/validators.cjs.map +1 -1
- package/dist/validators.js +1 -174
- package/dist/validators.js.map +1 -1
- package/dist/vault/index.cjs +688 -0
- package/dist/vault/index.cjs.map +1 -0
- package/dist/vault/index.d.cts +385 -0
- package/dist/vault/index.d.ts +385 -0
- package/dist/vault/index.js +669 -0
- package/dist/vault/index.js.map +1 -0
- package/package.json +128 -11
|
@@ -0,0 +1,669 @@
|
|
|
1
|
+
export { restoreTokens, tokenizeWith } from '../chunk-AP4JIUNW.js';
|
|
2
|
+
import { randomBytes, isWellFormed, fromBase64Url, utf8, toBase64Url, toBase32, encodeText, decodeText, concatBytes } from '../chunk-6LDAIJBL.js';
|
|
3
|
+
import { isKeyId, prefixResolver, PREFIX_SOURCE, KEY_ID_SOURCE } from '../chunk-2ZZHLCEJ.js';
|
|
4
|
+
export { createSessionTokenizer } from '../chunk-2ZZHLCEJ.js';
|
|
5
|
+
import { webCrypto } from '../chunk-PKHZ7CVI.js';
|
|
6
|
+
import { KeyManagementError, ValidationError, TokenVaultError } from '../chunk-2F2GWGTB.js';
|
|
7
|
+
|
|
8
|
+
// src/vault/keyring.ts
|
|
9
|
+
var DEFAULT_PBKDF2_ITERATIONS = 6e5;
|
|
10
|
+
var MIN_PBKDF2_ITERATIONS = 1e5;
|
|
11
|
+
var MIN_RAW_BYTES = 32;
|
|
12
|
+
var SALT_BYTES = 32;
|
|
13
|
+
var MIN_SALT_BYTES = 16;
|
|
14
|
+
var STATES = /* @__PURE__ */ new Set(["active", "retired", "destroyed"]);
|
|
15
|
+
async function importBase(crypto, id, material, salt, iterations) {
|
|
16
|
+
let keyingMaterial;
|
|
17
|
+
if (material.kind === "raw") {
|
|
18
|
+
if (!(material.bytes instanceof Uint8Array) || material.bytes.length < MIN_RAW_BYTES) {
|
|
19
|
+
throw new KeyManagementError(
|
|
20
|
+
`raw key material must be at least ${String(MIN_RAW_BYTES)} bytes`,
|
|
21
|
+
id
|
|
22
|
+
);
|
|
23
|
+
}
|
|
24
|
+
keyingMaterial = new Uint8Array(material.bytes);
|
|
25
|
+
} else {
|
|
26
|
+
if (typeof material.passphrase !== "string" || material.passphrase.length === 0) {
|
|
27
|
+
throw new KeyManagementError("the passphrase must not be empty", id);
|
|
28
|
+
}
|
|
29
|
+
const passphraseKey = await crypto.subtle.importKey(
|
|
30
|
+
"raw",
|
|
31
|
+
utf8(material.passphrase),
|
|
32
|
+
"PBKDF2",
|
|
33
|
+
false,
|
|
34
|
+
["deriveBits"]
|
|
35
|
+
);
|
|
36
|
+
const bits = await crypto.subtle.deriveBits(
|
|
37
|
+
{
|
|
38
|
+
name: "PBKDF2",
|
|
39
|
+
hash: "SHA-256",
|
|
40
|
+
salt,
|
|
41
|
+
iterations: iterations ?? DEFAULT_PBKDF2_ITERATIONS
|
|
42
|
+
},
|
|
43
|
+
passphraseKey,
|
|
44
|
+
256
|
|
45
|
+
);
|
|
46
|
+
keyingMaterial = new Uint8Array(bits);
|
|
47
|
+
}
|
|
48
|
+
return crypto.subtle.importKey("raw", keyingMaterial, "HKDF", false, ["deriveKey"]);
|
|
49
|
+
}
|
|
50
|
+
function resolveIterations(id, material, fromManifest) {
|
|
51
|
+
if (material.kind !== "passphrase") return void 0;
|
|
52
|
+
if (fromManifest !== void 0 && material.iterations !== void 0 && material.iterations !== fromManifest) {
|
|
53
|
+
throw new KeyManagementError(
|
|
54
|
+
"the iteration count differs from the one this version was created with",
|
|
55
|
+
id
|
|
56
|
+
);
|
|
57
|
+
}
|
|
58
|
+
const iterations = fromManifest ?? material.iterations ?? DEFAULT_PBKDF2_ITERATIONS;
|
|
59
|
+
if (!Number.isInteger(iterations) || iterations < MIN_PBKDF2_ITERATIONS) {
|
|
60
|
+
throw new KeyManagementError(
|
|
61
|
+
`PBKDF2 needs at least ${String(MIN_PBKDF2_ITERATIONS)} iterations`,
|
|
62
|
+
id
|
|
63
|
+
);
|
|
64
|
+
}
|
|
65
|
+
return iterations;
|
|
66
|
+
}
|
|
67
|
+
async function generateKeyMaterial() {
|
|
68
|
+
return { kind: "raw", bytes: randomBytes(await webCrypto(), MIN_RAW_BYTES) };
|
|
69
|
+
}
|
|
70
|
+
async function createKeyRing(options) {
|
|
71
|
+
const { namespace, keys, manifest } = options;
|
|
72
|
+
const now = options.now ?? Date.now;
|
|
73
|
+
if (typeof namespace !== "string" || namespace.length === 0 || !isWellFormed(namespace)) {
|
|
74
|
+
throw new KeyManagementError("the namespace must be a non-empty, well-formed string");
|
|
75
|
+
}
|
|
76
|
+
const crypto = await webCrypto();
|
|
77
|
+
const versions = /* @__PURE__ */ new Map();
|
|
78
|
+
const derived = /* @__PURE__ */ new Map();
|
|
79
|
+
let active;
|
|
80
|
+
let mac = "";
|
|
81
|
+
const supplied = /* @__PURE__ */ new Map();
|
|
82
|
+
for (const { id, material } of keys) {
|
|
83
|
+
if (!isKeyId(id)) {
|
|
84
|
+
throw new KeyManagementError("key identifiers are 1-16 characters of A-Z, a-z and 0-9");
|
|
85
|
+
}
|
|
86
|
+
if (supplied.has(id)) throw new KeyManagementError("the identifier is used more than once", id);
|
|
87
|
+
supplied.set(id, material);
|
|
88
|
+
}
|
|
89
|
+
if (manifest === void 0) {
|
|
90
|
+
for (const [id, material] of supplied) await add(id, material);
|
|
91
|
+
if (active === void 0)
|
|
92
|
+
throw new KeyManagementError("a key ring needs one active key version");
|
|
93
|
+
mac = await sign();
|
|
94
|
+
} else {
|
|
95
|
+
const infos = readManifest(manifest, namespace);
|
|
96
|
+
for (const info of infos) {
|
|
97
|
+
const material = supplied.get(info.id);
|
|
98
|
+
supplied.delete(info.id);
|
|
99
|
+
const salt = fromBase64Url(info.salt) ?? new Uint8Array(0);
|
|
100
|
+
if (info.state === "destroyed") {
|
|
101
|
+
versions.set(info.id, { ...info, salt, iterations: info.iterations, base: void 0 });
|
|
102
|
+
continue;
|
|
103
|
+
}
|
|
104
|
+
if (material === void 0) {
|
|
105
|
+
throw new KeyManagementError("no key material was supplied for a live version", info.id);
|
|
106
|
+
}
|
|
107
|
+
if (material.kind === "raw" !== (info.kdf === "hkdf")) {
|
|
108
|
+
throw new KeyManagementError("the key material does not match the manifest", info.id);
|
|
109
|
+
}
|
|
110
|
+
const iterations = resolveIterations(info.id, material, info.iterations);
|
|
111
|
+
versions.set(info.id, {
|
|
112
|
+
id: info.id,
|
|
113
|
+
state: info.state,
|
|
114
|
+
createdAt: info.createdAt,
|
|
115
|
+
kdf: info.kdf,
|
|
116
|
+
salt,
|
|
117
|
+
iterations,
|
|
118
|
+
base: await importBase(crypto, info.id, material, salt, iterations)
|
|
119
|
+
});
|
|
120
|
+
}
|
|
121
|
+
const [unlisted] = supplied.keys();
|
|
122
|
+
if (unlisted !== void 0) {
|
|
123
|
+
throw new KeyManagementError(
|
|
124
|
+
"the manifest does not list this key version; add new versions with rotate()",
|
|
125
|
+
unlisted
|
|
126
|
+
);
|
|
127
|
+
}
|
|
128
|
+
active = manifest.activeKeyId;
|
|
129
|
+
const expected = fromBase64Url(typeof manifest.mac === "string" ? manifest.mac : "");
|
|
130
|
+
const genuine = expected !== void 0 && await crypto.subtle.verify("HMAC", await macKey(), expected, utf8(macInput()));
|
|
131
|
+
if (!genuine) {
|
|
132
|
+
throw new KeyManagementError(
|
|
133
|
+
"the manifest failed authentication: it was edited, or the key material is not the one it was created with"
|
|
134
|
+
);
|
|
135
|
+
}
|
|
136
|
+
mac = manifest.mac;
|
|
137
|
+
}
|
|
138
|
+
function macKey() {
|
|
139
|
+
return derive(activeKeyId(), "manifest-mac");
|
|
140
|
+
}
|
|
141
|
+
function macInput() {
|
|
142
|
+
return JSON.stringify([
|
|
143
|
+
1,
|
|
144
|
+
namespace,
|
|
145
|
+
activeKeyId(),
|
|
146
|
+
[...versions.values()].map((version) => [
|
|
147
|
+
version.id,
|
|
148
|
+
version.state === "active",
|
|
149
|
+
version.createdAt,
|
|
150
|
+
version.kdf,
|
|
151
|
+
toBase64Url(version.salt),
|
|
152
|
+
version.iterations ?? null
|
|
153
|
+
])
|
|
154
|
+
]);
|
|
155
|
+
}
|
|
156
|
+
async function sign() {
|
|
157
|
+
const signature = await crypto.subtle.sign("HMAC", await macKey(), utf8(macInput()));
|
|
158
|
+
return toBase64Url(new Uint8Array(signature));
|
|
159
|
+
}
|
|
160
|
+
async function add(id, material) {
|
|
161
|
+
const salt = randomBytes(crypto, SALT_BYTES);
|
|
162
|
+
const iterations = resolveIterations(id, material);
|
|
163
|
+
const base = await importBase(crypto, id, material, salt, iterations);
|
|
164
|
+
const previous = active === void 0 ? void 0 : versions.get(active);
|
|
165
|
+
if (previous !== void 0) previous.state = "retired";
|
|
166
|
+
versions.set(id, {
|
|
167
|
+
id,
|
|
168
|
+
state: "active",
|
|
169
|
+
createdAt: now(),
|
|
170
|
+
kdf: material.kind === "raw" ? "hkdf" : "pbkdf2-hkdf",
|
|
171
|
+
salt,
|
|
172
|
+
iterations,
|
|
173
|
+
base
|
|
174
|
+
});
|
|
175
|
+
active = id;
|
|
176
|
+
}
|
|
177
|
+
function activeKeyId() {
|
|
178
|
+
if (active === void 0) throw new KeyManagementError("the key ring has no active version");
|
|
179
|
+
return active;
|
|
180
|
+
}
|
|
181
|
+
function describe(version) {
|
|
182
|
+
return Object.freeze({
|
|
183
|
+
id: version.id,
|
|
184
|
+
state: version.state,
|
|
185
|
+
createdAt: version.createdAt,
|
|
186
|
+
kdf: version.kdf,
|
|
187
|
+
salt: toBase64Url(version.salt),
|
|
188
|
+
...version.iterations !== void 0 ? { iterations: version.iterations } : {}
|
|
189
|
+
});
|
|
190
|
+
}
|
|
191
|
+
function derive(keyId, purpose) {
|
|
192
|
+
const version = versions.get(keyId);
|
|
193
|
+
if (version === void 0) {
|
|
194
|
+
return Promise.reject(
|
|
195
|
+
new KeyManagementError("unknown key version", isKeyId(keyId) ? keyId : void 0)
|
|
196
|
+
);
|
|
197
|
+
}
|
|
198
|
+
const base = version.base;
|
|
199
|
+
if (base === void 0) {
|
|
200
|
+
return Promise.reject(new KeyManagementError("the key version has been destroyed", keyId));
|
|
201
|
+
}
|
|
202
|
+
const cacheKey = `${keyId}/${purpose}`;
|
|
203
|
+
let key = derived.get(cacheKey);
|
|
204
|
+
if (key === void 0) {
|
|
205
|
+
key = crypto.subtle.deriveKey(
|
|
206
|
+
{
|
|
207
|
+
name: "HKDF",
|
|
208
|
+
hash: "SHA-256",
|
|
209
|
+
salt: version.salt,
|
|
210
|
+
info: utf8(`anonyma/v1/${purpose}\0${namespace}`)
|
|
211
|
+
},
|
|
212
|
+
base,
|
|
213
|
+
purpose === "token-seal" ? { name: "AES-GCM", length: 256 } : { name: "HMAC", hash: "SHA-256", length: 256 },
|
|
214
|
+
false,
|
|
215
|
+
purpose === "token-seal" ? ["encrypt", "decrypt"] : ["sign", "verify"]
|
|
216
|
+
);
|
|
217
|
+
derived.set(cacheKey, key);
|
|
218
|
+
}
|
|
219
|
+
return key;
|
|
220
|
+
}
|
|
221
|
+
const reserved = /* @__PURE__ */ new Set();
|
|
222
|
+
let rotations = Promise.resolve();
|
|
223
|
+
function rotate(version) {
|
|
224
|
+
const { id, material } = version;
|
|
225
|
+
if (!isKeyId(id)) {
|
|
226
|
+
return Promise.reject(
|
|
227
|
+
new KeyManagementError("key identifiers are 1-16 characters of A-Z, a-z and 0-9")
|
|
228
|
+
);
|
|
229
|
+
}
|
|
230
|
+
if (versions.has(id) || reserved.has(id)) {
|
|
231
|
+
return Promise.reject(new KeyManagementError("the identifier is already in use", id));
|
|
232
|
+
}
|
|
233
|
+
reserved.add(id);
|
|
234
|
+
const run = rotations.then(async () => {
|
|
235
|
+
try {
|
|
236
|
+
await add(id, material);
|
|
237
|
+
mac = await sign();
|
|
238
|
+
} finally {
|
|
239
|
+
reserved.delete(id);
|
|
240
|
+
}
|
|
241
|
+
});
|
|
242
|
+
rotations = run.catch(() => void 0);
|
|
243
|
+
return run;
|
|
244
|
+
}
|
|
245
|
+
function destroy(keyId) {
|
|
246
|
+
const version = versions.get(keyId);
|
|
247
|
+
if (version === void 0) {
|
|
248
|
+
throw new KeyManagementError("unknown key version", isKeyId(keyId) ? keyId : void 0);
|
|
249
|
+
}
|
|
250
|
+
if (version.state === "active") {
|
|
251
|
+
throw new KeyManagementError(
|
|
252
|
+
"the active key version cannot be destroyed; rotate first",
|
|
253
|
+
keyId
|
|
254
|
+
);
|
|
255
|
+
}
|
|
256
|
+
version.state = "destroyed";
|
|
257
|
+
version.base = void 0;
|
|
258
|
+
for (const cacheKey of [...derived.keys()]) {
|
|
259
|
+
if (cacheKey.startsWith(`${keyId}/`)) derived.delete(cacheKey);
|
|
260
|
+
}
|
|
261
|
+
}
|
|
262
|
+
return Object.freeze({
|
|
263
|
+
activeKeyId,
|
|
264
|
+
manifest: () => Object.freeze({
|
|
265
|
+
v: 1,
|
|
266
|
+
namespace,
|
|
267
|
+
activeKeyId: activeKeyId(),
|
|
268
|
+
versions: Object.freeze([...versions.values()].map(describe)),
|
|
269
|
+
mac
|
|
270
|
+
}),
|
|
271
|
+
deriveKey: (keyId, purpose) => derive(keyId, purpose),
|
|
272
|
+
rotate,
|
|
273
|
+
destroy
|
|
274
|
+
});
|
|
275
|
+
}
|
|
276
|
+
function readManifest(manifest, namespace) {
|
|
277
|
+
const malformed = new KeyManagementError("the manifest is malformed");
|
|
278
|
+
const candidate = manifest;
|
|
279
|
+
if (typeof manifest !== "object" || candidate["v"] !== 1 || !Array.isArray(candidate["versions"])) {
|
|
280
|
+
throw malformed;
|
|
281
|
+
}
|
|
282
|
+
if (candidate["namespace"] !== namespace) {
|
|
283
|
+
throw new KeyManagementError("the manifest belongs to a different namespace");
|
|
284
|
+
}
|
|
285
|
+
const seen = /* @__PURE__ */ new Set();
|
|
286
|
+
let activeCount = 0;
|
|
287
|
+
for (const entry of candidate["versions"]) {
|
|
288
|
+
if (typeof entry !== "object" || entry === null) throw malformed;
|
|
289
|
+
const info = entry;
|
|
290
|
+
const { id, state, createdAt, kdf, salt, iterations } = info;
|
|
291
|
+
const saltBytes = typeof salt === "string" ? fromBase64Url(salt) : void 0;
|
|
292
|
+
if (!isKeyId(id) || seen.has(id) || !STATES.has(state) || typeof createdAt !== "number" || !Number.isFinite(createdAt) || kdf !== "hkdf" && kdf !== "pbkdf2-hkdf" || saltBytes === void 0 || saltBytes.length < MIN_SALT_BYTES || (kdf === "hkdf" ? iterations !== void 0 : typeof iterations !== "number")) {
|
|
293
|
+
throw malformed;
|
|
294
|
+
}
|
|
295
|
+
seen.add(id);
|
|
296
|
+
if (state === "active") {
|
|
297
|
+
activeCount++;
|
|
298
|
+
if (id !== candidate["activeKeyId"]) throw malformed;
|
|
299
|
+
}
|
|
300
|
+
}
|
|
301
|
+
if (activeCount !== 1) throw malformed;
|
|
302
|
+
return manifest.versions;
|
|
303
|
+
}
|
|
304
|
+
|
|
305
|
+
// src/vault/seal.ts
|
|
306
|
+
var IV_BYTES = 12;
|
|
307
|
+
var TAG_BYTES = 16;
|
|
308
|
+
async function macOf(crypto, key, category, value) {
|
|
309
|
+
const input = concatBytes(encodeText(category), new Uint8Array(1), encodeText(value));
|
|
310
|
+
return new Uint8Array(await crypto.subtle.sign("HMAC", key, input));
|
|
311
|
+
}
|
|
312
|
+
async function seal(crypto, key, value, additionalData, iv = randomBytes(crypto, IV_BYTES)) {
|
|
313
|
+
const sealed = await crypto.subtle.encrypt(
|
|
314
|
+
{ name: "AES-GCM", iv, additionalData: utf8(additionalData), tagLength: TAG_BYTES * 8 },
|
|
315
|
+
key,
|
|
316
|
+
encodeText(value)
|
|
317
|
+
);
|
|
318
|
+
return toBase64Url(concatBytes(iv, new Uint8Array(sealed)));
|
|
319
|
+
}
|
|
320
|
+
async function unseal(crypto, key, sealed, additionalData) {
|
|
321
|
+
const bytes = fromBase64Url(sealed);
|
|
322
|
+
if (bytes === void 0 || bytes.length < IV_BYTES + TAG_BYTES) return void 0;
|
|
323
|
+
try {
|
|
324
|
+
const plain = await crypto.subtle.decrypt(
|
|
325
|
+
{
|
|
326
|
+
name: "AES-GCM",
|
|
327
|
+
iv: bytes.subarray(0, IV_BYTES),
|
|
328
|
+
additionalData: utf8(additionalData),
|
|
329
|
+
tagLength: TAG_BYTES * 8
|
|
330
|
+
},
|
|
331
|
+
key,
|
|
332
|
+
bytes.subarray(IV_BYTES)
|
|
333
|
+
);
|
|
334
|
+
return decodeText(new Uint8Array(plain));
|
|
335
|
+
} catch {
|
|
336
|
+
return void 0;
|
|
337
|
+
}
|
|
338
|
+
}
|
|
339
|
+
|
|
340
|
+
// src/vault/keyed.ts
|
|
341
|
+
var MAX_ATTEMPTS = 5;
|
|
342
|
+
async function subjectTagOf(keyring, keyId, subject) {
|
|
343
|
+
const key = await keyring.deriveKey(keyId, "subject-tag");
|
|
344
|
+
return toBase64Url(await macOf(await webCrypto(), key, "subject", subject));
|
|
345
|
+
}
|
|
346
|
+
function subjectContext(token) {
|
|
347
|
+
return `${token}\0subject`;
|
|
348
|
+
}
|
|
349
|
+
function valueContext(record) {
|
|
350
|
+
return `${record.token}\0${String(record.createdAt)}\0${String(record.expiresAt ?? "")}`;
|
|
351
|
+
}
|
|
352
|
+
function createKeyedTokenizer(options) {
|
|
353
|
+
const { keyring, vault, idKeyId, idLength = 12, ttlMs } = options;
|
|
354
|
+
const now = options.now ?? Date.now;
|
|
355
|
+
if (!Number.isInteger(idLength) || idLength < 8 || idLength > 26) {
|
|
356
|
+
throw new ValidationError("idLength", "must be an integer between 8 and 26");
|
|
357
|
+
}
|
|
358
|
+
if (idKeyId !== void 0 && !isKeyId(idKeyId)) {
|
|
359
|
+
throw new ValidationError("idKeyId", "is not a valid key version identifier");
|
|
360
|
+
}
|
|
361
|
+
if (ttlMs !== void 0 && !(ttlMs > 0)) {
|
|
362
|
+
throw new ValidationError("ttlMs", "must be a positive number");
|
|
363
|
+
}
|
|
364
|
+
const prefixOf = prefixResolver(options.prefixes);
|
|
365
|
+
const tokenSource = `\\[${PREFIX_SOURCE}_${KEY_ID_SOURCE}_[0-9A-HJKMNP-TV-Z]{${String(idLength)}}\\]`;
|
|
366
|
+
const wholeToken = new RegExp(`^${tokenSource}$`);
|
|
367
|
+
async function tokenize(value, context) {
|
|
368
|
+
if (typeof value !== "string") throw new ValidationError("value", "must be a string");
|
|
369
|
+
const crypto = await webCrypto();
|
|
370
|
+
const keyId = idKeyId ?? keyring.activeKeyId();
|
|
371
|
+
const mac = await macOf(
|
|
372
|
+
crypto,
|
|
373
|
+
await keyring.deriveKey(keyId, "token-id"),
|
|
374
|
+
context.category,
|
|
375
|
+
value
|
|
376
|
+
);
|
|
377
|
+
const token = `[${prefixOf(context.category)}_${keyId}_${toBase32(mac, idLength)}]`;
|
|
378
|
+
if (vault === void 0) return token;
|
|
379
|
+
const check = toBase64Url(mac);
|
|
380
|
+
for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
|
|
381
|
+
let existing = await vault.get(token);
|
|
382
|
+
if (existing === void 0) {
|
|
383
|
+
const record = await create(crypto, token, check, value, context);
|
|
384
|
+
existing = await vault.putIfAbsent(record);
|
|
385
|
+
if (existing.sealed === record.sealed && existing.check === check) return token;
|
|
386
|
+
}
|
|
387
|
+
const same = await holdsValue(crypto, existing, check, value);
|
|
388
|
+
if (same === void 0 || isExpired(existing)) {
|
|
389
|
+
const record = await create(crypto, token, check, value, context);
|
|
390
|
+
if (await vault.replace(record, existing)) return token;
|
|
391
|
+
continue;
|
|
392
|
+
}
|
|
393
|
+
if (!same) throw new TokenVaultError("token identifier collision; increase idLength");
|
|
394
|
+
if (context.subject === void 0) return token;
|
|
395
|
+
const tagged = await withSubject(crypto, existing, context.subject);
|
|
396
|
+
if (tagged === existing || await vault.replace(tagged, existing)) return token;
|
|
397
|
+
}
|
|
398
|
+
throw new TokenVaultError("the vault record kept changing; try again");
|
|
399
|
+
}
|
|
400
|
+
function isExpired(record) {
|
|
401
|
+
return record.expiresAt !== void 0 && record.expiresAt <= now();
|
|
402
|
+
}
|
|
403
|
+
async function create(crypto, token, check, value, context) {
|
|
404
|
+
const keyId = keyring.activeKeyId();
|
|
405
|
+
const sealKey = await keyring.deriveKey(keyId, "token-seal");
|
|
406
|
+
const createdAt = now();
|
|
407
|
+
const lifetime = {
|
|
408
|
+
token,
|
|
409
|
+
createdAt,
|
|
410
|
+
...ttlMs !== void 0 ? { expiresAt: createdAt + ttlMs } : {}
|
|
411
|
+
};
|
|
412
|
+
return {
|
|
413
|
+
...lifetime,
|
|
414
|
+
category: context.category,
|
|
415
|
+
keyId,
|
|
416
|
+
sealed: await seal(crypto, sealKey, value, valueContext(lifetime)),
|
|
417
|
+
check,
|
|
418
|
+
...context.subject !== void 0 ? { subjects: [await subjectReference(crypto, token, keyId, context.subject)] } : {}
|
|
419
|
+
};
|
|
420
|
+
}
|
|
421
|
+
async function subjectReference(crypto, token, keyId, subject) {
|
|
422
|
+
const sealKey = await keyring.deriveKey(keyId, "token-seal");
|
|
423
|
+
return {
|
|
424
|
+
tag: await subjectTagOf(keyring, keyId, subject),
|
|
425
|
+
sealed: await seal(crypto, sealKey, subject, subjectContext(token))
|
|
426
|
+
};
|
|
427
|
+
}
|
|
428
|
+
async function holdsValue(crypto, record, check, value) {
|
|
429
|
+
if (record.check !== void 0) {
|
|
430
|
+
return record.check === check;
|
|
431
|
+
}
|
|
432
|
+
try {
|
|
433
|
+
const key = await keyring.deriveKey(record.keyId, "token-seal");
|
|
434
|
+
return await unseal(crypto, key, record.sealed, valueContext(record)) === value;
|
|
435
|
+
} catch {
|
|
436
|
+
return void 0;
|
|
437
|
+
}
|
|
438
|
+
}
|
|
439
|
+
async function withSubject(crypto, record, subject) {
|
|
440
|
+
const subjects = record.subjects ?? [];
|
|
441
|
+
const tag = await subjectTagOf(keyring, record.keyId, subject);
|
|
442
|
+
if (subjects.some((entry) => entry.tag === tag)) return record;
|
|
443
|
+
const reference = await subjectReference(crypto, record.token, record.keyId, subject);
|
|
444
|
+
return { ...record, subjects: [...subjects, reference] };
|
|
445
|
+
}
|
|
446
|
+
async function detokenize(token) {
|
|
447
|
+
if (vault === void 0 || typeof token !== "string" || !wholeToken.test(token))
|
|
448
|
+
return void 0;
|
|
449
|
+
const record = await vault.get(token);
|
|
450
|
+
if (record === void 0 || isExpired(record)) return void 0;
|
|
451
|
+
let key;
|
|
452
|
+
try {
|
|
453
|
+
key = await keyring.deriveKey(record.keyId, "token-seal");
|
|
454
|
+
} catch {
|
|
455
|
+
return void 0;
|
|
456
|
+
}
|
|
457
|
+
return unseal(await webCrypto(), key, record.sealed, valueContext(record));
|
|
458
|
+
}
|
|
459
|
+
async function forgetToken(token) {
|
|
460
|
+
return vault === void 0 ? false : vault.delete(token);
|
|
461
|
+
}
|
|
462
|
+
async function forgetSubject(subject) {
|
|
463
|
+
if (typeof subject !== "string" || subject.length === 0) {
|
|
464
|
+
throw new ValidationError("subject", "must be a non-empty string");
|
|
465
|
+
}
|
|
466
|
+
const tags = /* @__PURE__ */ new Map();
|
|
467
|
+
for (const version of keyring.manifest().versions) {
|
|
468
|
+
if (version.state !== "destroyed") {
|
|
469
|
+
tags.set(version.id, await subjectTagOf(keyring, version.id, subject));
|
|
470
|
+
}
|
|
471
|
+
}
|
|
472
|
+
const isSubject = (record) => {
|
|
473
|
+
const tag = tags.get(record.keyId);
|
|
474
|
+
return tag !== void 0 && (record.subjects ?? []).some((entry) => entry.tag === tag);
|
|
475
|
+
};
|
|
476
|
+
let erased = 0;
|
|
477
|
+
const keyIds = /* @__PURE__ */ new Set();
|
|
478
|
+
if (vault !== void 0) {
|
|
479
|
+
const doomed = [];
|
|
480
|
+
for await (const record of vault.list()) {
|
|
481
|
+
if (isSubject(record)) doomed.push(record);
|
|
482
|
+
}
|
|
483
|
+
for (const record of doomed) {
|
|
484
|
+
if (await vault.delete(record.token)) {
|
|
485
|
+
erased++;
|
|
486
|
+
keyIds.add(record.keyId);
|
|
487
|
+
}
|
|
488
|
+
}
|
|
489
|
+
}
|
|
490
|
+
const activeTag = tags.get(keyring.activeKeyId());
|
|
491
|
+
return Object.freeze({
|
|
492
|
+
method: "vault-delete",
|
|
493
|
+
erased,
|
|
494
|
+
keyIds: Object.freeze([...keyIds].sort()),
|
|
495
|
+
...activeTag !== void 0 ? { subjectTag: activeTag } : {},
|
|
496
|
+
completedAt: now()
|
|
497
|
+
});
|
|
498
|
+
}
|
|
499
|
+
return Object.freeze({
|
|
500
|
+
scheme: "keyed",
|
|
501
|
+
reversible: vault !== void 0,
|
|
502
|
+
tokenPattern: new RegExp(tokenSource, "g"),
|
|
503
|
+
partialTokenPattern: /\[[A-Za-z0-9_]{0,80}$/,
|
|
504
|
+
maxTokenLength: 40 + 1 + 16 + 1 + idLength + 2,
|
|
505
|
+
tokenize,
|
|
506
|
+
detokenize,
|
|
507
|
+
forgetToken,
|
|
508
|
+
forgetSubject
|
|
509
|
+
});
|
|
510
|
+
}
|
|
511
|
+
|
|
512
|
+
// src/vault/sealed.ts
|
|
513
|
+
function createSealedTokenizer(options) {
|
|
514
|
+
const { keyring, maxValueBytes = 256 } = options;
|
|
515
|
+
if (!Number.isInteger(maxValueBytes) || maxValueBytes < 1) {
|
|
516
|
+
throw new ValidationError("maxValueBytes", "must be a positive integer");
|
|
517
|
+
}
|
|
518
|
+
const prefixOf = prefixResolver(options.prefixes);
|
|
519
|
+
const tokenSource = `\\[(${PREFIX_SOURCE})_(${KEY_ID_SOURCE})\\.([A-Za-z0-9_-]{38,})\\]`;
|
|
520
|
+
const wholeToken = new RegExp(`^${tokenSource}$`);
|
|
521
|
+
async function tokenize(value, context) {
|
|
522
|
+
if (typeof value !== "string") throw new ValidationError("value", "must be a string");
|
|
523
|
+
if (encodeText(value).length > maxValueBytes) {
|
|
524
|
+
throw new ValidationError("value", "is longer than maxValueBytes and cannot be sealed");
|
|
525
|
+
}
|
|
526
|
+
const crypto = await webCrypto();
|
|
527
|
+
const keyId = keyring.activeKeyId();
|
|
528
|
+
const header = `${prefixOf(context.category)}_${keyId}`;
|
|
529
|
+
const mac = await macOf(crypto, await keyring.deriveKey(keyId, "token-id"), header, value);
|
|
530
|
+
const sealed = await seal(
|
|
531
|
+
crypto,
|
|
532
|
+
await keyring.deriveKey(keyId, "token-seal"),
|
|
533
|
+
value,
|
|
534
|
+
header,
|
|
535
|
+
mac.slice(0, 12)
|
|
536
|
+
);
|
|
537
|
+
return `[${header}.${sealed}]`;
|
|
538
|
+
}
|
|
539
|
+
async function detokenize(token) {
|
|
540
|
+
if (typeof token !== "string") return void 0;
|
|
541
|
+
const match = wholeToken.exec(token);
|
|
542
|
+
const prefix = match?.[1];
|
|
543
|
+
const keyId = match?.[2];
|
|
544
|
+
const sealed = match?.[3];
|
|
545
|
+
if (prefix === void 0 || keyId === void 0 || sealed === void 0) return void 0;
|
|
546
|
+
let key;
|
|
547
|
+
try {
|
|
548
|
+
key = await keyring.deriveKey(keyId, "token-seal");
|
|
549
|
+
} catch {
|
|
550
|
+
return void 0;
|
|
551
|
+
}
|
|
552
|
+
return unseal(await webCrypto(), key, sealed, `${prefix}_${keyId}`);
|
|
553
|
+
}
|
|
554
|
+
return Object.freeze({
|
|
555
|
+
scheme: "sealed",
|
|
556
|
+
reversible: true,
|
|
557
|
+
tokenPattern: new RegExp(tokenSource.replace(/\((?!\?)/g, "(?:"), "g"),
|
|
558
|
+
partialTokenPattern: /\[[A-Za-z0-9_.-]*$/,
|
|
559
|
+
// prefix + "_" + key id + "." + base64url(12-byte nonce, value, 16-byte tag) + brackets
|
|
560
|
+
maxTokenLength: 2 + 40 + 1 + 16 + 1 + Math.ceil((12 + maxValueBytes + 16) * 4 / 3),
|
|
561
|
+
tokenize,
|
|
562
|
+
detokenize
|
|
563
|
+
});
|
|
564
|
+
}
|
|
565
|
+
|
|
566
|
+
// src/vault/memory-vault.ts
|
|
567
|
+
function sameRecord(a, b) {
|
|
568
|
+
if (a.keyId !== b.keyId || a.sealed !== b.sealed) return false;
|
|
569
|
+
const left = a.subjects ?? [];
|
|
570
|
+
const right = b.subjects ?? [];
|
|
571
|
+
return left.length === right.length && left.every((subject, index) => subject.tag === right[index]?.tag);
|
|
572
|
+
}
|
|
573
|
+
function createMemoryVault(records = []) {
|
|
574
|
+
const store = /* @__PURE__ */ new Map();
|
|
575
|
+
for (const record of records) store.set(record.token, Object.freeze({ ...record }));
|
|
576
|
+
return Object.freeze({
|
|
577
|
+
get: (token) => store.get(token),
|
|
578
|
+
putIfAbsent(record) {
|
|
579
|
+
const existing = store.get(record.token);
|
|
580
|
+
if (existing !== void 0) return existing;
|
|
581
|
+
const stored = Object.freeze({ ...record });
|
|
582
|
+
store.set(record.token, stored);
|
|
583
|
+
return stored;
|
|
584
|
+
},
|
|
585
|
+
replace(record, expected) {
|
|
586
|
+
const stored = store.get(record.token);
|
|
587
|
+
if (stored === void 0 || !sameRecord(stored, expected)) return false;
|
|
588
|
+
store.set(record.token, Object.freeze({ ...record }));
|
|
589
|
+
return true;
|
|
590
|
+
},
|
|
591
|
+
delete: (token) => store.delete(token),
|
|
592
|
+
list: () => [...store.values()],
|
|
593
|
+
size: () => store.size
|
|
594
|
+
});
|
|
595
|
+
}
|
|
596
|
+
|
|
597
|
+
// src/vault/rotation.ts
|
|
598
|
+
async function rewrapVault(vault, keyring) {
|
|
599
|
+
const crypto = await webCrypto();
|
|
600
|
+
const active = keyring.activeKeyId();
|
|
601
|
+
const activeKey = await keyring.deriveKey(active, "token-seal");
|
|
602
|
+
const stale = [];
|
|
603
|
+
let current = 0;
|
|
604
|
+
for await (const record of vault.list()) {
|
|
605
|
+
if (record.keyId === active) current++;
|
|
606
|
+
else stale.push(record);
|
|
607
|
+
}
|
|
608
|
+
let rewrapped = 0;
|
|
609
|
+
let unrecoverable = 0;
|
|
610
|
+
let skipped = 0;
|
|
611
|
+
for (const record of stale) {
|
|
612
|
+
let value;
|
|
613
|
+
const subjects = [];
|
|
614
|
+
try {
|
|
615
|
+
const oldKey = await keyring.deriveKey(record.keyId, "token-seal");
|
|
616
|
+
value = await unseal(crypto, oldKey, record.sealed, valueContext(record));
|
|
617
|
+
for (const entry of record.subjects ?? []) {
|
|
618
|
+
const subject = await unseal(crypto, oldKey, entry.sealed, subjectContext(record.token));
|
|
619
|
+
if (subject === void 0) value = void 0;
|
|
620
|
+
else subjects.push(subject);
|
|
621
|
+
}
|
|
622
|
+
} catch {
|
|
623
|
+
value = void 0;
|
|
624
|
+
}
|
|
625
|
+
if (value === void 0) {
|
|
626
|
+
unrecoverable++;
|
|
627
|
+
continue;
|
|
628
|
+
}
|
|
629
|
+
const references = [];
|
|
630
|
+
for (const subject of subjects) {
|
|
631
|
+
references.push({
|
|
632
|
+
tag: await subjectTagOf(keyring, active, subject),
|
|
633
|
+
sealed: await seal(crypto, activeKey, subject, subjectContext(record.token))
|
|
634
|
+
});
|
|
635
|
+
}
|
|
636
|
+
const next = {
|
|
637
|
+
...record,
|
|
638
|
+
keyId: active,
|
|
639
|
+
sealed: await seal(crypto, activeKey, value, valueContext(record)),
|
|
640
|
+
...references.length > 0 ? { subjects: references } : {}
|
|
641
|
+
};
|
|
642
|
+
if (await vault.replace(next, record)) rewrapped++;
|
|
643
|
+
else skipped++;
|
|
644
|
+
}
|
|
645
|
+
return { rewrapped, current, unrecoverable, skipped };
|
|
646
|
+
}
|
|
647
|
+
async function shredKey(keyring, keyId, vault, now = Date.now) {
|
|
648
|
+
keyring.destroy(keyId);
|
|
649
|
+
let erased = 0;
|
|
650
|
+
if (vault !== void 0) {
|
|
651
|
+
const doomed = [];
|
|
652
|
+
for await (const record of vault.list()) {
|
|
653
|
+
if (record.keyId === keyId) doomed.push(record.token);
|
|
654
|
+
}
|
|
655
|
+
for (const token of doomed) {
|
|
656
|
+
if (await vault.delete(token)) erased++;
|
|
657
|
+
}
|
|
658
|
+
}
|
|
659
|
+
return Object.freeze({
|
|
660
|
+
method: "crypto-shred",
|
|
661
|
+
erased,
|
|
662
|
+
keyIds: Object.freeze([keyId]),
|
|
663
|
+
completedAt: now()
|
|
664
|
+
});
|
|
665
|
+
}
|
|
666
|
+
|
|
667
|
+
export { createKeyRing, createKeyedTokenizer, createMemoryVault, createSealedTokenizer, generateKeyMaterial, rewrapVault, shredKey };
|
|
668
|
+
//# sourceMappingURL=index.js.map
|
|
669
|
+
//# sourceMappingURL=index.js.map
|