@preeternal/jws-verifier 0.0.0-stage → 0.0.1-rc.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 +13 -0
- package/LICENSE +21 -0
- package/README.md +85 -2
- package/dist/asn1/ber-reader.d.ts +57 -0
- package/dist/asn1/ber-reader.d.ts.map +1 -0
- package/dist/asn1/ber-reader.js +202 -0
- package/dist/asn1/der-reader.d.ts +68 -0
- package/dist/asn1/der-reader.d.ts.map +1 -0
- package/dist/asn1/der-reader.js +181 -0
- package/dist/index.d.ts +7 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +5 -0
- package/dist/jws/es256-signature.d.ts +3 -0
- package/dist/jws/es256-signature.d.ts.map +1 -0
- package/dist/jws/es256-signature.js +22 -0
- package/dist/jws/verifier.d.ts +94 -0
- package/dist/jws/verifier.d.ts.map +1 -0
- package/dist/jws/verifier.js +718 -0
- package/dist/ocsp/codec.d.ts +55 -0
- package/dist/ocsp/codec.d.ts.map +1 -0
- package/dist/ocsp/codec.js +465 -0
- package/dist/ocsp/transport.d.ts +6 -0
- package/dist/ocsp/transport.d.ts.map +1 -0
- package/dist/ocsp/transport.js +69 -0
- package/dist/receipt/utility.d.ts +27 -0
- package/dist/receipt/utility.d.ts.map +1 -0
- package/dist/receipt/utility.js +296 -0
- package/dist/types/index.d.ts +4 -0
- package/dist/types/index.d.ts.map +1 -0
- package/dist/types/index.js +1 -0
- package/dist/utils/formatting.d.ts +2 -0
- package/dist/utils/formatting.d.ts.map +1 -0
- package/dist/utils/formatting.js +9 -0
- package/dist/x509/certificate-metadata.d.ts +91 -0
- package/dist/x509/certificate-metadata.d.ts.map +1 -0
- package/dist/x509/certificate-metadata.js +588 -0
- package/dist/x509/prepared-certificates.d.ts +22 -0
- package/dist/x509/prepared-certificates.d.ts.map +1 -0
- package/dist/x509/prepared-certificates.js +27 -0
- package/package.json +81 -3
|
@@ -0,0 +1,588 @@
|
|
|
1
|
+
import { DEFAULT_DER_LIMITS, DerParseError, DerReader, derRange, } from "../asn1/der-reader.js";
|
|
2
|
+
const OIDS = Object.freeze({
|
|
3
|
+
authorityInfoAccess: "1.3.6.1.5.5.7.1.1",
|
|
4
|
+
basicConstraints: "2.5.29.19",
|
|
5
|
+
extendedKeyUsage: "2.5.29.37",
|
|
6
|
+
keyUsage: "2.5.29.15",
|
|
7
|
+
ocsp: "1.3.6.1.5.5.7.48.1",
|
|
8
|
+
ocspSigning: "1.3.6.1.5.5.7.3.9",
|
|
9
|
+
appleLeaf: "1.2.840.113635.100.6.11.1",
|
|
10
|
+
appleIntermediate: "1.2.840.113635.100.6.2.1",
|
|
11
|
+
});
|
|
12
|
+
const defaults = Object.freeze({
|
|
13
|
+
maxAiaEntries: 32,
|
|
14
|
+
maxExtensions: 64,
|
|
15
|
+
maxOidArcs: 64,
|
|
16
|
+
});
|
|
17
|
+
const universal = 0;
|
|
18
|
+
const contextSpecific = 2;
|
|
19
|
+
const decimalDigits = /^\d+$/;
|
|
20
|
+
const asciiDecoder = new TextDecoder();
|
|
21
|
+
const isTag = (element, tagClass, tagNumber, constructed) => element.tagClass === tagClass &&
|
|
22
|
+
element.tagNumber === tagNumber &&
|
|
23
|
+
(constructed === undefined || element.constructed === constructed);
|
|
24
|
+
const requireTag = (element, tagClass, tagNumber, name, constructed) => {
|
|
25
|
+
if (!isTag(element, tagClass, tagNumber, constructed)) {
|
|
26
|
+
throw new DerParseError("invalid-tag", `${name} has an unexpected DER tag`, element.start);
|
|
27
|
+
}
|
|
28
|
+
};
|
|
29
|
+
const requireSequence = (element, name) => {
|
|
30
|
+
requireTag(element, universal, 16, name, true);
|
|
31
|
+
};
|
|
32
|
+
const requireSet = (element, name) => {
|
|
33
|
+
requireTag(element, universal, 17, name, true);
|
|
34
|
+
};
|
|
35
|
+
const readOne = (reader, name) => {
|
|
36
|
+
const element = reader.readOptionalElement();
|
|
37
|
+
if (element === undefined) {
|
|
38
|
+
throw new DerParseError("unexpected-end", `Missing ${name}`, reader.end);
|
|
39
|
+
}
|
|
40
|
+
return element;
|
|
41
|
+
};
|
|
42
|
+
const parseOid = (element, name, maxOidArcs) => {
|
|
43
|
+
requireTag(element, universal, 6, name, false);
|
|
44
|
+
if (element.value.length === 0) {
|
|
45
|
+
throw new DerParseError("invalid-tag", `${name} cannot be empty`, element.start);
|
|
46
|
+
}
|
|
47
|
+
const components = [];
|
|
48
|
+
let index = 0;
|
|
49
|
+
while (index < element.value.length) {
|
|
50
|
+
const component = readOidComponent(element, index, name);
|
|
51
|
+
components.push(component.value);
|
|
52
|
+
index = component.next;
|
|
53
|
+
if (components.length > maxOidArcs) {
|
|
54
|
+
throw new DerParseError("limit-exceeded", `${name} has too many components`, element.start);
|
|
55
|
+
}
|
|
56
|
+
}
|
|
57
|
+
const first = components[0];
|
|
58
|
+
if (first === undefined) {
|
|
59
|
+
throw new DerParseError("invalid-tag", `${name} cannot be empty`, element.start);
|
|
60
|
+
}
|
|
61
|
+
const firstArc = first < 40n ? first : first < 80n ? 1n : 2n;
|
|
62
|
+
const secondArc = firstArc === 2n ? first - 80n : first % 40n;
|
|
63
|
+
const oid = [firstArc, secondArc, ...components.slice(1)].map(String).join(".");
|
|
64
|
+
return { oid, value: derRange(element.valueStart, element.value.length) };
|
|
65
|
+
};
|
|
66
|
+
const readOidComponent = (element, start, name) => {
|
|
67
|
+
let component = 0n;
|
|
68
|
+
let index = start;
|
|
69
|
+
let firstByte = true;
|
|
70
|
+
while (index < element.value.length) {
|
|
71
|
+
const byte = element.value[index] ?? 0;
|
|
72
|
+
index += 1;
|
|
73
|
+
if (firstByte && byte === 0x80) {
|
|
74
|
+
throw new DerParseError("invalid-tag", `${name} contains a non-canonical OID`, element.start);
|
|
75
|
+
}
|
|
76
|
+
firstByte = false;
|
|
77
|
+
component = component * 128n + BigInt(byte & 0x7f);
|
|
78
|
+
if (component > 0xffffffffffffffffn) {
|
|
79
|
+
throw new DerParseError("limit-exceeded", `${name} component is too large`, element.start);
|
|
80
|
+
}
|
|
81
|
+
if ((byte & 0x80) === 0) {
|
|
82
|
+
return { value: component, next: index };
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
throw new DerParseError("unexpected-end", `${name} is truncated`, element.end);
|
|
86
|
+
};
|
|
87
|
+
const parseBoolean = (element, name) => {
|
|
88
|
+
requireTag(element, universal, 1, name, false);
|
|
89
|
+
if (element.value.length !== 1 || (element.value[0] !== 0x00 && element.value[0] !== 0xff)) {
|
|
90
|
+
throw new DerParseError("invalid-tag", `${name} is not a canonical DER BOOLEAN`, element.start);
|
|
91
|
+
}
|
|
92
|
+
return element.value[0] === 0xff;
|
|
93
|
+
};
|
|
94
|
+
const requireNonNegativeInteger = (element, name) => {
|
|
95
|
+
requireTag(element, universal, 2, name, false);
|
|
96
|
+
if (element.value.length === 0 ||
|
|
97
|
+
(element.value.length > 1 && element.value[0] === 0x00 && (element.value[1] ?? 0) < 0x80)) {
|
|
98
|
+
throw new DerParseError("invalid-tag", `${name} is not a canonical DER INTEGER`, element.start);
|
|
99
|
+
}
|
|
100
|
+
if ((element.value[0] ?? 0) >= 0x80) {
|
|
101
|
+
throw new DerParseError("invalid-tag", `${name} must be non-negative`, element.start);
|
|
102
|
+
}
|
|
103
|
+
};
|
|
104
|
+
const parseNonNegativeInteger = (element, name) => {
|
|
105
|
+
requireNonNegativeInteger(element, name);
|
|
106
|
+
if (element.value.length > 7) {
|
|
107
|
+
throw new DerParseError("invalid-tag", `${name} exceeds the supported integer range`, element.start);
|
|
108
|
+
}
|
|
109
|
+
let value = 0;
|
|
110
|
+
for (const byte of element.value) {
|
|
111
|
+
value = value * 256 + byte;
|
|
112
|
+
}
|
|
113
|
+
if (!Number.isSafeInteger(value)) {
|
|
114
|
+
throw new DerParseError("invalid-tag", `${name} exceeds the supported integer range`, element.start);
|
|
115
|
+
}
|
|
116
|
+
return value;
|
|
117
|
+
};
|
|
118
|
+
const parseVersion = (element, limits) => {
|
|
119
|
+
requireTag(element, contextSpecific, 0, "certificate version", true);
|
|
120
|
+
let version = 0;
|
|
121
|
+
elementReader(element, limits, (reader) => {
|
|
122
|
+
const integer = readOne(reader, "certificate version value");
|
|
123
|
+
version = parseNonNegativeInteger(integer, "certificate version");
|
|
124
|
+
});
|
|
125
|
+
if (version === 0 || version > 2) {
|
|
126
|
+
throw new DerParseError("invalid-tag", "Unsupported X.509 certificate version", element.start);
|
|
127
|
+
}
|
|
128
|
+
return version;
|
|
129
|
+
};
|
|
130
|
+
const parseAlgorithmIdentifier = (element, limits, name) => {
|
|
131
|
+
requireSequence(element, name);
|
|
132
|
+
elementReader(element, limits, (reader) => {
|
|
133
|
+
parseOid(readOne(reader, `${name} OID`), `${name} OID`, limits.maxOidArcs);
|
|
134
|
+
reader.readOptionalElement();
|
|
135
|
+
if (reader.remaining !== 0) {
|
|
136
|
+
throw new DerParseError("trailing-data", `${name} has too many fields`, reader.start);
|
|
137
|
+
}
|
|
138
|
+
});
|
|
139
|
+
};
|
|
140
|
+
const parseName = (element, limits, name) => {
|
|
141
|
+
requireSequence(element, name);
|
|
142
|
+
elementReader(element, limits, (reader) => {
|
|
143
|
+
while (reader.remaining > 0) {
|
|
144
|
+
const relativeName = reader.readElement();
|
|
145
|
+
requireSet(relativeName, `${name} relative distinguished name`);
|
|
146
|
+
elementReader(relativeName, limits, (setReader) => {
|
|
147
|
+
while (setReader.remaining > 0) {
|
|
148
|
+
const attribute = setReader.readElement();
|
|
149
|
+
requireSequence(attribute, `${name} attribute`);
|
|
150
|
+
elementReader(attribute, limits, (attributeReader) => {
|
|
151
|
+
parseOid(readOne(attributeReader, `${name} attribute OID`), `${name} attribute OID`, limits.maxOidArcs);
|
|
152
|
+
readOne(attributeReader, `${name} attribute value`);
|
|
153
|
+
});
|
|
154
|
+
}
|
|
155
|
+
});
|
|
156
|
+
}
|
|
157
|
+
});
|
|
158
|
+
};
|
|
159
|
+
const parseTime = (element, name) => {
|
|
160
|
+
requireTag(element, universal, element.tagNumber, name, false);
|
|
161
|
+
const generalized = element.tagNumber === 24;
|
|
162
|
+
const expectedLength = generalized ? 15 : 13;
|
|
163
|
+
if ((!generalized && element.tagNumber !== 23) ||
|
|
164
|
+
element.value.length !== expectedLength ||
|
|
165
|
+
element.value[expectedLength - 1] !== 0x5a) {
|
|
166
|
+
throw new DerParseError("invalid-tag", `${name} is not a canonical UTC time`, element.start);
|
|
167
|
+
}
|
|
168
|
+
const text = asciiDecoder.decode(element.value);
|
|
169
|
+
const digit = (offset, length) => {
|
|
170
|
+
const value = Number.parseInt(text.slice(offset, offset + length), 10);
|
|
171
|
+
if (!Number.isInteger(value) || !decimalDigits.test(text.slice(offset, offset + length))) {
|
|
172
|
+
throw new DerParseError("invalid-tag", `${name} contains invalid time digits`, element.start);
|
|
173
|
+
}
|
|
174
|
+
return value;
|
|
175
|
+
};
|
|
176
|
+
const year = generalized
|
|
177
|
+
? digit(0, 4)
|
|
178
|
+
: (() => {
|
|
179
|
+
const shortYear = digit(0, 2);
|
|
180
|
+
return shortYear >= 50 ? 1900 + shortYear : 2000 + shortYear;
|
|
181
|
+
})();
|
|
182
|
+
const monthOffset = generalized ? 4 : 2;
|
|
183
|
+
const month = digit(monthOffset, 2);
|
|
184
|
+
const day = digit(monthOffset + 2, 2);
|
|
185
|
+
const hour = digit(monthOffset + 4, 2);
|
|
186
|
+
const minute = digit(monthOffset + 6, 2);
|
|
187
|
+
const second = digit(monthOffset + 8, 2);
|
|
188
|
+
const date = new Date(0);
|
|
189
|
+
date.setUTCFullYear(year, month - 1, day);
|
|
190
|
+
date.setUTCHours(hour, minute, second, 0);
|
|
191
|
+
if (date.getUTCFullYear() !== year ||
|
|
192
|
+
date.getUTCMonth() !== month - 1 ||
|
|
193
|
+
date.getUTCDate() !== day ||
|
|
194
|
+
date.getUTCHours() !== hour ||
|
|
195
|
+
date.getUTCMinutes() !== minute ||
|
|
196
|
+
date.getUTCSeconds() !== second) {
|
|
197
|
+
throw new DerParseError("invalid-tag", `${name} contains an invalid date`, element.start);
|
|
198
|
+
}
|
|
199
|
+
return date.getTime();
|
|
200
|
+
};
|
|
201
|
+
const parseValidity = (element, limits) => {
|
|
202
|
+
requireSequence(element, "certificate validity");
|
|
203
|
+
let notBefore;
|
|
204
|
+
let notAfter;
|
|
205
|
+
elementReader(element, limits, (reader) => {
|
|
206
|
+
notBefore = readOne(reader, "notBefore");
|
|
207
|
+
notAfter = readOne(reader, "notAfter");
|
|
208
|
+
});
|
|
209
|
+
if (notBefore === undefined || notAfter === undefined) {
|
|
210
|
+
throw new DerParseError("unexpected-end", "Certificate validity is incomplete", element.start);
|
|
211
|
+
}
|
|
212
|
+
const notBeforeMs = parseTime(notBefore, "notBefore");
|
|
213
|
+
const notAfterMs = parseTime(notAfter, "notAfter");
|
|
214
|
+
if (notBeforeMs > notAfterMs) {
|
|
215
|
+
throw new DerParseError("invalid-tag", "Certificate validity is reversed", element.start);
|
|
216
|
+
}
|
|
217
|
+
return Object.freeze({
|
|
218
|
+
notBefore: derRange(notBefore.start, notBefore.end - notBefore.start),
|
|
219
|
+
notBeforeMs,
|
|
220
|
+
notAfter: derRange(notAfter.start, notAfter.end - notAfter.start),
|
|
221
|
+
notAfterMs,
|
|
222
|
+
});
|
|
223
|
+
};
|
|
224
|
+
const parseBitString = (element, name) => {
|
|
225
|
+
requireTag(element, universal, 3, name, false);
|
|
226
|
+
if (element.value.length === 0) {
|
|
227
|
+
throw new DerParseError("invalid-tag", `${name} is missing the unused-bits count`, element.start);
|
|
228
|
+
}
|
|
229
|
+
const unusedBits = element.value[0] ?? 0;
|
|
230
|
+
if (unusedBits > 7 || (element.value.length === 1 && unusedBits !== 0)) {
|
|
231
|
+
throw new DerParseError("invalid-tag", `${name} has an invalid unused-bits count`, element.start);
|
|
232
|
+
}
|
|
233
|
+
const last = element.value[element.value.length - 1] ?? 0;
|
|
234
|
+
if (unusedBits > 0 && (last & ((1 << unusedBits) - 1)) !== 0) {
|
|
235
|
+
throw new DerParseError("invalid-tag", `${name} has non-zero unused bits`, element.start);
|
|
236
|
+
}
|
|
237
|
+
return Object.freeze({
|
|
238
|
+
bitString: derRange(element.start, element.end - element.start),
|
|
239
|
+
value: derRange(element.valueStart + 1, element.value.length - 1),
|
|
240
|
+
unusedBits,
|
|
241
|
+
});
|
|
242
|
+
};
|
|
243
|
+
const parseSubjectPublicKeyInfo = (element, limits) => {
|
|
244
|
+
requireSequence(element, "SPKI");
|
|
245
|
+
let bitString;
|
|
246
|
+
elementReader(element, limits, (reader) => {
|
|
247
|
+
parseAlgorithmIdentifier(readOne(reader, "SPKI algorithm"), limits, "SPKI algorithm");
|
|
248
|
+
bitString = readOne(reader, "SPKI key");
|
|
249
|
+
});
|
|
250
|
+
if (bitString === undefined) {
|
|
251
|
+
throw new DerParseError("unexpected-end", "SPKI is missing its key", element.end);
|
|
252
|
+
}
|
|
253
|
+
return parseBitString(bitString, "SPKI key");
|
|
254
|
+
};
|
|
255
|
+
const parseImplicitBitString = (element, name) => {
|
|
256
|
+
requireTag(element, contextSpecific, element.tagNumber, name, false);
|
|
257
|
+
if (element.value.length === 0 || (element.value[0] ?? 0) > 7) {
|
|
258
|
+
throw new DerParseError("invalid-tag", `${name} has an invalid bit string`, element.start);
|
|
259
|
+
}
|
|
260
|
+
const unusedBits = element.value[0] ?? 0;
|
|
261
|
+
const last = element.value[element.value.length - 1] ?? 0;
|
|
262
|
+
if (unusedBits > 0 && (last & ((1 << unusedBits) - 1)) !== 0) {
|
|
263
|
+
throw new DerParseError("invalid-tag", `${name} has non-zero unused bits`, element.start);
|
|
264
|
+
}
|
|
265
|
+
};
|
|
266
|
+
const parseBasicConstraints = (element, limits) => {
|
|
267
|
+
requireSequence(element, "basicConstraints");
|
|
268
|
+
let ca = false;
|
|
269
|
+
let pathLenConstraint;
|
|
270
|
+
elementReader(element, limits, (reader) => {
|
|
271
|
+
const first = reader.readOptionalElement();
|
|
272
|
+
if (first === undefined) {
|
|
273
|
+
return;
|
|
274
|
+
}
|
|
275
|
+
if (isTag(first, universal, 1, false)) {
|
|
276
|
+
ca = parseBoolean(first, "basicConstraints cA");
|
|
277
|
+
const path = reader.readOptionalElement();
|
|
278
|
+
if (path !== undefined) {
|
|
279
|
+
const value = parseNonNegativeInteger(path, "basicConstraints pathLenConstraint");
|
|
280
|
+
if (!ca) {
|
|
281
|
+
throw new DerParseError("invalid-tag", "Invalid basicConstraints pathLenConstraint", path.start);
|
|
282
|
+
}
|
|
283
|
+
pathLenConstraint = value;
|
|
284
|
+
}
|
|
285
|
+
return;
|
|
286
|
+
}
|
|
287
|
+
throw new DerParseError("invalid-tag", "Invalid basicConstraints pathLenConstraint", first.start);
|
|
288
|
+
});
|
|
289
|
+
return Object.freeze({ ca, ...(pathLenConstraint === undefined ? {} : { pathLenConstraint }) });
|
|
290
|
+
};
|
|
291
|
+
const keyUsageNames = [
|
|
292
|
+
"digitalSignature",
|
|
293
|
+
"contentCommitment",
|
|
294
|
+
"keyEncipherment",
|
|
295
|
+
"dataEncipherment",
|
|
296
|
+
"keyAgreement",
|
|
297
|
+
"keyCertSign",
|
|
298
|
+
"cRLSign",
|
|
299
|
+
"encipherOnly",
|
|
300
|
+
"decipherOnly",
|
|
301
|
+
];
|
|
302
|
+
const parseKeyUsage = (element) => {
|
|
303
|
+
parseBitString(element, "keyUsage");
|
|
304
|
+
const value = element.value;
|
|
305
|
+
const names = keyUsageNames.filter((_, index) => {
|
|
306
|
+
const byte = value[1 + Math.floor(index / 8)] ?? 0;
|
|
307
|
+
return (byte & (0x80 >>> (index % 8))) !== 0;
|
|
308
|
+
});
|
|
309
|
+
if (value.length > 3 || (value.length === 3 && value[2] !== 0x80)) {
|
|
310
|
+
throw new DerParseError("invalid-tag", "keyUsage contains unsupported bits", element.start);
|
|
311
|
+
}
|
|
312
|
+
return Object.freeze({ names: Object.freeze(names) });
|
|
313
|
+
};
|
|
314
|
+
const parseExtendedKeyUsage = (element, limits) => {
|
|
315
|
+
requireSequence(element, "extendedKeyUsage");
|
|
316
|
+
const oids = [];
|
|
317
|
+
elementReader(element, limits, (reader) => {
|
|
318
|
+
while (reader.remaining > 0) {
|
|
319
|
+
const oid = parseOid(reader.readElement(), "extendedKeyUsage OID", limits.maxOidArcs).oid;
|
|
320
|
+
if (oids.includes(oid)) {
|
|
321
|
+
throw new DerParseError("invalid-tag", "Duplicate extendedKeyUsage OID", reader.start);
|
|
322
|
+
}
|
|
323
|
+
oids.push(oid);
|
|
324
|
+
}
|
|
325
|
+
});
|
|
326
|
+
return Object.freeze({ oids: Object.freeze(oids), ocspSigning: oids.includes(OIDS.ocspSigning) });
|
|
327
|
+
};
|
|
328
|
+
const parseAuthorityInfoAccess = (element, limits) => {
|
|
329
|
+
requireSequence(element, "authorityInfoAccess");
|
|
330
|
+
const ocspUrls = [];
|
|
331
|
+
let entries = 0;
|
|
332
|
+
elementReader(element, limits, (reader) => {
|
|
333
|
+
while (reader.remaining > 0) {
|
|
334
|
+
entries += 1;
|
|
335
|
+
if (entries > limits.maxAiaEntries) {
|
|
336
|
+
throw new DerParseError("limit-exceeded", "Too many authorityInfoAccess entries", reader.start);
|
|
337
|
+
}
|
|
338
|
+
const accessDescription = reader.readElement();
|
|
339
|
+
requireSequence(accessDescription, "authorityInfoAccess entry");
|
|
340
|
+
elementReader(accessDescription, limits, (entryReader) => {
|
|
341
|
+
const method = parseOid(readOne(entryReader, "authorityInfoAccess method"), "authorityInfoAccess method", limits.maxOidArcs).oid;
|
|
342
|
+
const location = readOne(entryReader, "authorityInfoAccess location");
|
|
343
|
+
if (method === OIDS.ocsp) {
|
|
344
|
+
requireTag(location, contextSpecific, 6, "authorityInfoAccess OCSP URI", false);
|
|
345
|
+
if (location.value.length === 0 || location.value.some((byte) => byte > 0x7f)) {
|
|
346
|
+
throw new DerParseError("invalid-tag", "authorityInfoAccess OCSP URI is not IA5", location.start);
|
|
347
|
+
}
|
|
348
|
+
ocspUrls.push(Object.freeze({
|
|
349
|
+
value: asciiDecoder.decode(location.value),
|
|
350
|
+
range: derRange(location.valueStart, location.value.length),
|
|
351
|
+
}));
|
|
352
|
+
}
|
|
353
|
+
else if (location.tagClass !== contextSpecific) {
|
|
354
|
+
throw new DerParseError("invalid-tag", "authorityInfoAccess location is not a GeneralName", location.start);
|
|
355
|
+
}
|
|
356
|
+
});
|
|
357
|
+
}
|
|
358
|
+
});
|
|
359
|
+
return Object.freeze({ ocspUrls: Object.freeze(ocspUrls) });
|
|
360
|
+
};
|
|
361
|
+
const parseExtensionValue = (oid, element, limits) => {
|
|
362
|
+
let parsed;
|
|
363
|
+
const inner = new DerReader(element.context.input, limits, element.valueStart, element.end, element.context.depth + 1, element.context.state);
|
|
364
|
+
const value = inner.readElement();
|
|
365
|
+
inner.assertEnd();
|
|
366
|
+
if (oid === OIDS.authorityInfoAccess) {
|
|
367
|
+
parsed = Object.freeze({
|
|
368
|
+
kind: "authorityInfoAccess",
|
|
369
|
+
value: parseAuthorityInfoAccess(value, limits),
|
|
370
|
+
});
|
|
371
|
+
}
|
|
372
|
+
else if (oid === OIDS.basicConstraints) {
|
|
373
|
+
parsed = Object.freeze({
|
|
374
|
+
kind: "basicConstraints",
|
|
375
|
+
value: parseBasicConstraints(value, limits),
|
|
376
|
+
});
|
|
377
|
+
}
|
|
378
|
+
else if (oid === OIDS.extendedKeyUsage) {
|
|
379
|
+
parsed = Object.freeze({
|
|
380
|
+
kind: "extendedKeyUsage",
|
|
381
|
+
value: parseExtendedKeyUsage(value, limits),
|
|
382
|
+
});
|
|
383
|
+
}
|
|
384
|
+
else if (oid === OIDS.keyUsage) {
|
|
385
|
+
parsed = Object.freeze({ kind: "keyUsage", value: parseKeyUsage(value) });
|
|
386
|
+
}
|
|
387
|
+
return parsed;
|
|
388
|
+
};
|
|
389
|
+
const parseExtensions = (element, limits) => {
|
|
390
|
+
requireTag(element, contextSpecific, 3, "certificate extensions", true);
|
|
391
|
+
const extensions = [];
|
|
392
|
+
const seen = new Set();
|
|
393
|
+
elementReader(element, limits, (explicitReader) => {
|
|
394
|
+
const sequence = readOne(explicitReader, "certificate extensions sequence");
|
|
395
|
+
requireSequence(sequence, "certificate extensions sequence");
|
|
396
|
+
if (sequence.value.length === 0) {
|
|
397
|
+
throw new DerParseError("invalid-tag", "Certificate extensions cannot be empty", sequence.start);
|
|
398
|
+
}
|
|
399
|
+
elementReader(sequence, limits, (extensionReader) => {
|
|
400
|
+
while (extensionReader.remaining > 0) {
|
|
401
|
+
if (extensions.length >= limits.maxExtensions) {
|
|
402
|
+
throw new DerParseError("limit-exceeded", "Too many certificate extensions", extensionReader.start);
|
|
403
|
+
}
|
|
404
|
+
extensions.push(parseExtension(extensionReader.readElement(), limits, seen));
|
|
405
|
+
}
|
|
406
|
+
});
|
|
407
|
+
});
|
|
408
|
+
return Object.freeze(extensions);
|
|
409
|
+
};
|
|
410
|
+
const parseExtension = (extension, limits, seen) => {
|
|
411
|
+
requireSequence(extension, "certificate extension");
|
|
412
|
+
let oid = "";
|
|
413
|
+
let oidValue;
|
|
414
|
+
let critical = false;
|
|
415
|
+
let value;
|
|
416
|
+
elementReader(extension, limits, (fields) => {
|
|
417
|
+
const parsedOid = parseOid(readOne(fields, "certificate extension OID"), "certificate extension OID", limits.maxOidArcs);
|
|
418
|
+
oid = parsedOid.oid;
|
|
419
|
+
oidValue = parsedOid.value;
|
|
420
|
+
const maybeCritical = fields.readOptionalElement();
|
|
421
|
+
if (maybeCritical !== undefined && isTag(maybeCritical, universal, 1, false)) {
|
|
422
|
+
critical = parseBoolean(maybeCritical, "certificate extension critical");
|
|
423
|
+
}
|
|
424
|
+
else if (maybeCritical !== undefined) {
|
|
425
|
+
value = maybeCritical;
|
|
426
|
+
}
|
|
427
|
+
value ??= readOne(fields, "certificate extension value");
|
|
428
|
+
});
|
|
429
|
+
if (seen.has(oid)) {
|
|
430
|
+
throw new DerParseError("invalid-tag", `Duplicate certificate extension ${oid}`, extension.start);
|
|
431
|
+
}
|
|
432
|
+
seen.add(oid);
|
|
433
|
+
if (oidValue === undefined || value === undefined) {
|
|
434
|
+
throw new DerParseError("unexpected-end", "Certificate extension is incomplete", extension.start);
|
|
435
|
+
}
|
|
436
|
+
requireTag(value, universal, 4, "certificate extension value", false);
|
|
437
|
+
const parsed = parseExtensionValue(oid, value, limits);
|
|
438
|
+
return Object.freeze({
|
|
439
|
+
oid,
|
|
440
|
+
oidValue,
|
|
441
|
+
critical,
|
|
442
|
+
tlv: derRange(extension.start, extension.end - extension.start),
|
|
443
|
+
value: derRange(value.valueStart, value.value.length),
|
|
444
|
+
...(parsed === undefined ? {} : { parsed }),
|
|
445
|
+
});
|
|
446
|
+
};
|
|
447
|
+
const elementReader = (element, limits, callback) => {
|
|
448
|
+
const reader = new DerReader(element.context.input, limits, element.valueStart, element.end, element.context.depth + 1, element.context.state);
|
|
449
|
+
callback(reader);
|
|
450
|
+
reader.assertEnd();
|
|
451
|
+
};
|
|
452
|
+
const parseTbsCertificate = (element, limits) => {
|
|
453
|
+
requireSequence(element, "tbsCertificate");
|
|
454
|
+
let version = 0;
|
|
455
|
+
let serialElement;
|
|
456
|
+
let issuer;
|
|
457
|
+
let subject;
|
|
458
|
+
let validity;
|
|
459
|
+
let subjectPublicKey;
|
|
460
|
+
let extensions = [];
|
|
461
|
+
elementReader(element, limits, (reader) => {
|
|
462
|
+
const core = parseTbsCore(reader, limits);
|
|
463
|
+
version = core.version;
|
|
464
|
+
serialElement = core.serialElement;
|
|
465
|
+
issuer = core.issuer;
|
|
466
|
+
subject = core.subject;
|
|
467
|
+
validity = core.validity;
|
|
468
|
+
subjectPublicKey = core.subjectPublicKey;
|
|
469
|
+
extensions = parseTbsOptionalFields(reader, limits, version);
|
|
470
|
+
});
|
|
471
|
+
if (serialElement === undefined ||
|
|
472
|
+
issuer === undefined ||
|
|
473
|
+
subject === undefined ||
|
|
474
|
+
validity === undefined ||
|
|
475
|
+
subjectPublicKey === undefined) {
|
|
476
|
+
throw new DerParseError("unexpected-end", "tbsCertificate is incomplete", element.start);
|
|
477
|
+
}
|
|
478
|
+
const serial = Object.freeze({
|
|
479
|
+
tlv: derRange(serialElement.start, serialElement.end - serialElement.start),
|
|
480
|
+
value: derRange(serialElement.valueStart, serialElement.value.length),
|
|
481
|
+
});
|
|
482
|
+
const extensionOids = Object.freeze(extensions.map(({ oid }) => oid));
|
|
483
|
+
let authorityInfoAccess;
|
|
484
|
+
let basicConstraints;
|
|
485
|
+
let keyUsage;
|
|
486
|
+
let extendedKeyUsage;
|
|
487
|
+
for (const extension of extensions) {
|
|
488
|
+
const parsed = extension.parsed;
|
|
489
|
+
if (parsed?.kind === "authorityInfoAccess") {
|
|
490
|
+
authorityInfoAccess = parsed.value;
|
|
491
|
+
}
|
|
492
|
+
else if (parsed?.kind === "basicConstraints") {
|
|
493
|
+
basicConstraints = parsed.value;
|
|
494
|
+
}
|
|
495
|
+
else if (parsed?.kind === "keyUsage") {
|
|
496
|
+
keyUsage = parsed.value;
|
|
497
|
+
}
|
|
498
|
+
else if (parsed?.kind === "extendedKeyUsage") {
|
|
499
|
+
extendedKeyUsage = parsed.value;
|
|
500
|
+
}
|
|
501
|
+
}
|
|
502
|
+
return {
|
|
503
|
+
version,
|
|
504
|
+
issuer: derRange(issuer.start, issuer.end - issuer.start),
|
|
505
|
+
subject: derRange(subject.start, subject.end - subject.start),
|
|
506
|
+
serial,
|
|
507
|
+
validity,
|
|
508
|
+
subjectPublicKey,
|
|
509
|
+
extensions,
|
|
510
|
+
extensionOids,
|
|
511
|
+
...(authorityInfoAccess === undefined ? {} : { authorityInfoAccess }),
|
|
512
|
+
...(basicConstraints === undefined ? {} : { basicConstraints }),
|
|
513
|
+
...(keyUsage === undefined ? {} : { keyUsage }),
|
|
514
|
+
...(extendedKeyUsage === undefined ? {} : { extendedKeyUsage }),
|
|
515
|
+
};
|
|
516
|
+
};
|
|
517
|
+
const parseTbsOptionalFields = (reader, limits, version) => {
|
|
518
|
+
let extensions = Object.freeze([]);
|
|
519
|
+
let previousTag = 0;
|
|
520
|
+
while (reader.remaining > 0) {
|
|
521
|
+
const field = reader.readElement();
|
|
522
|
+
const tag = field.tagNumber;
|
|
523
|
+
if (field.tagClass !== contextSpecific || tag <= previousTag || tag > 3) {
|
|
524
|
+
throw new DerParseError("invalid-tag", "Unexpected or out-of-order tbsCertificate field", field.start);
|
|
525
|
+
}
|
|
526
|
+
if (version === 0 || (tag === 3 && version !== 2)) {
|
|
527
|
+
throw new DerParseError("invalid-tag", "Field is not allowed in this certificate version", field.start);
|
|
528
|
+
}
|
|
529
|
+
previousTag = tag;
|
|
530
|
+
if (tag === 3) {
|
|
531
|
+
extensions = parseExtensions(field, limits);
|
|
532
|
+
}
|
|
533
|
+
else {
|
|
534
|
+
parseImplicitBitString(field, tag === 1 ? "issuerUniqueID" : "subjectUniqueID");
|
|
535
|
+
}
|
|
536
|
+
}
|
|
537
|
+
return extensions;
|
|
538
|
+
};
|
|
539
|
+
const parseTbsCore = (reader, limits) => {
|
|
540
|
+
let version = 0;
|
|
541
|
+
let serialElement = readOne(reader, "certificate serial number or version");
|
|
542
|
+
if (isTag(serialElement, contextSpecific, 0, true)) {
|
|
543
|
+
version = parseVersion(serialElement, limits);
|
|
544
|
+
serialElement = readOne(reader, "certificate serial number");
|
|
545
|
+
}
|
|
546
|
+
requireNonNegativeInteger(serialElement, "certificate serial number");
|
|
547
|
+
parseAlgorithmIdentifier(readOne(reader, "certificate signature algorithm"), limits, "certificate signature algorithm");
|
|
548
|
+
const issuer = readOne(reader, "certificate issuer");
|
|
549
|
+
parseName(issuer, limits, "certificate issuer");
|
|
550
|
+
const validity = parseValidity(readOne(reader, "certificate validity"), limits);
|
|
551
|
+
const subject = readOne(reader, "certificate subject");
|
|
552
|
+
parseName(subject, limits, "certificate subject");
|
|
553
|
+
const subjectPublicKey = parseSubjectPublicKeyInfo(readOne(reader, "SPKI"), limits);
|
|
554
|
+
return { version, serialElement, issuer, subject, validity, subjectPublicKey };
|
|
555
|
+
};
|
|
556
|
+
export const parseX509CertificateMetadata = (input, options = {}) => {
|
|
557
|
+
const limits = {
|
|
558
|
+
...defaults,
|
|
559
|
+
...options,
|
|
560
|
+
maxDepth: options.maxDepth ?? DEFAULT_DER_LIMITS.maxDepth,
|
|
561
|
+
maxElements: options.maxElements ?? DEFAULT_DER_LIMITS.maxElements,
|
|
562
|
+
maxInputBytes: options.maxInputBytes ?? DEFAULT_DER_LIMITS.maxInputBytes,
|
|
563
|
+
maxWorkBytes: options.maxWorkBytes ?? DEFAULT_DER_LIMITS.maxWorkBytes,
|
|
564
|
+
};
|
|
565
|
+
const reader = new DerReader(input, limits);
|
|
566
|
+
const certificate = reader.readElement();
|
|
567
|
+
reader.assertEnd();
|
|
568
|
+
requireSequence(certificate, "certificate");
|
|
569
|
+
let tbsCertificate;
|
|
570
|
+
elementReader(certificate, limits, (certificateReader) => {
|
|
571
|
+
tbsCertificate = readOne(certificateReader, "tbsCertificate");
|
|
572
|
+
parseAlgorithmIdentifier(readOne(certificateReader, "certificate signature algorithm"), limits, "certificate signature algorithm");
|
|
573
|
+
parseBitString(readOne(certificateReader, "certificate signature"), "certificate signature");
|
|
574
|
+
});
|
|
575
|
+
if (tbsCertificate === undefined) {
|
|
576
|
+
throw new DerParseError("unexpected-end", "Certificate is missing tbsCertificate", certificate.start);
|
|
577
|
+
}
|
|
578
|
+
const parsed = parseTbsCertificate(tbsCertificate, limits);
|
|
579
|
+
const extensionOids = new Set(parsed.extensionOids);
|
|
580
|
+
return Object.freeze({
|
|
581
|
+
...parsed,
|
|
582
|
+
apple: Object.freeze({
|
|
583
|
+
leaf: extensionOids.has(OIDS.appleLeaf),
|
|
584
|
+
intermediate: extensionOids.has(OIDS.appleIntermediate),
|
|
585
|
+
}),
|
|
586
|
+
});
|
|
587
|
+
};
|
|
588
|
+
export { OIDS as X509_EXTENSION_OIDS };
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
import { X509Certificate } from "node:crypto";
|
|
2
|
+
import { type X509CertificateMetadata } from "./certificate-metadata.js";
|
|
3
|
+
export interface PreparedCertificate {
|
|
4
|
+
/** Owned DER bytes. Internal consumers must treat these as read-only. */
|
|
5
|
+
readonly der: Uint8Array;
|
|
6
|
+
readonly certificate: X509Certificate;
|
|
7
|
+
readonly metadata: X509CertificateMetadata;
|
|
8
|
+
}
|
|
9
|
+
export interface PreparedChain {
|
|
10
|
+
readonly leaf: PreparedCertificate;
|
|
11
|
+
readonly intermediate: PreparedCertificate;
|
|
12
|
+
readonly roots: readonly PreparedCertificate[];
|
|
13
|
+
}
|
|
14
|
+
export declare const prepareCertificate: (input: Uint8Array) => PreparedCertificate;
|
|
15
|
+
/** Owns the prepared trust anchors for one verifier configuration. */
|
|
16
|
+
export declare class CertificatePreparation {
|
|
17
|
+
readonly roots: readonly PreparedCertificate[];
|
|
18
|
+
constructor(trustedRoots: readonly Uint8Array[]);
|
|
19
|
+
/** Prepare once on a cache miss and pass the same result to chain and OCSP checks. */
|
|
20
|
+
prepareChain(leaf: Uint8Array, intermediate: Uint8Array): PreparedChain;
|
|
21
|
+
}
|
|
22
|
+
//# sourceMappingURL=prepared-certificates.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"prepared-certificates.d.ts","sourceRoot":"","sources":["../../source/x509/prepared-certificates.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAG9C,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,2BAA2B,CAAC;AAEnC,MAAM,WAAW,mBAAmB;IAClC,yEAAyE;IACzE,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,eAAe,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,CAAC;CAC5C;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,QAAQ,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAChD;AAED,eAAO,MAAM,kBAAkB,GAAI,OAAO,UAAU,KAAG,mBAOtD,CAAC;AAEF,sEAAsE;AACtE,qBAAa,sBAAsB;IACjC,QAAQ,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,CAAC;gBAEnC,YAAY,EAAE,SAAS,UAAU,EAAE;IAI/C,sFAAsF;IACtF,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,GAAG,aAAa;CAOxE"}
|
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
// biome-ignore lint/correctness/noNodejsModules: Native certificate operations belong in this adapter.
|
|
2
|
+
import { X509Certificate } from "node:crypto";
|
|
3
|
+
import { DEFAULT_DER_LIMITS, DerParseError } from "../asn1/der-reader.js";
|
|
4
|
+
import { parseX509CertificateMetadata, } from "./certificate-metadata.js";
|
|
5
|
+
export const prepareCertificate = (input) => {
|
|
6
|
+
if (input.byteLength > DEFAULT_DER_LIMITS.maxInputBytes) {
|
|
7
|
+
throw new DerParseError("input-too-large", "DER input exceeds the configured limit", 0);
|
|
8
|
+
}
|
|
9
|
+
const der = new Uint8Array(input);
|
|
10
|
+
const metadata = parseX509CertificateMetadata(der);
|
|
11
|
+
return Object.freeze({ der, certificate: new X509Certificate(der), metadata });
|
|
12
|
+
};
|
|
13
|
+
/** Owns the prepared trust anchors for one verifier configuration. */
|
|
14
|
+
export class CertificatePreparation {
|
|
15
|
+
roots;
|
|
16
|
+
constructor(trustedRoots) {
|
|
17
|
+
this.roots = Object.freeze(trustedRoots.map(prepareCertificate));
|
|
18
|
+
}
|
|
19
|
+
/** Prepare once on a cache miss and pass the same result to chain and OCSP checks. */
|
|
20
|
+
prepareChain(leaf, intermediate) {
|
|
21
|
+
return Object.freeze({
|
|
22
|
+
leaf: prepareCertificate(leaf),
|
|
23
|
+
intermediate: prepareCertificate(intermediate),
|
|
24
|
+
roots: this.roots,
|
|
25
|
+
});
|
|
26
|
+
}
|
|
27
|
+
}
|