Harmonized behaviour when point length is invalid.
[BearSSL] / src / x509 / x509_minimal.c
1 /* Automatically generated code; do not modify directly. */
2
3 #include <stddef.h>
4 #include <stdint.h>
5
6 typedef struct {
7 uint32_t *dp;
8 uint32_t *rp;
9 const unsigned char *ip;
10 } t0_context;
11
12 static uint32_t
13 t0_parse7E_unsigned(const unsigned char **p)
14 {
15 uint32_t x;
16
17 x = 0;
18 for (;;) {
19 unsigned y;
20
21 y = *(*p) ++;
22 x = (x << 7) | (uint32_t)(y & 0x7F);
23 if (y < 0x80) {
24 return x;
25 }
26 }
27 }
28
29 static int32_t
30 t0_parse7E_signed(const unsigned char **p)
31 {
32 int neg;
33 uint32_t x;
34
35 neg = ((**p) >> 6) & 1;
36 x = (uint32_t)-neg;
37 for (;;) {
38 unsigned y;
39
40 y = *(*p) ++;
41 x = (x << 7) | (uint32_t)(y & 0x7F);
42 if (y < 0x80) {
43 if (neg) {
44 return -(int32_t)~x - 1;
45 } else {
46 return (int32_t)x;
47 }
48 }
49 }
50 }
51
52 #define T0_VBYTE(x, n) (unsigned char)((((uint32_t)(x) >> (n)) & 0x7F) | 0x80)
53 #define T0_FBYTE(x, n) (unsigned char)(((uint32_t)(x) >> (n)) & 0x7F)
54 #define T0_SBYTE(x) (unsigned char)((((uint32_t)(x) >> 28) + 0xF8) ^ 0xF8)
55 #define T0_INT1(x) T0_FBYTE(x, 0)
56 #define T0_INT2(x) T0_VBYTE(x, 7), T0_FBYTE(x, 0)
57 #define T0_INT3(x) T0_VBYTE(x, 14), T0_VBYTE(x, 7), T0_FBYTE(x, 0)
58 #define T0_INT4(x) T0_VBYTE(x, 21), T0_VBYTE(x, 14), T0_VBYTE(x, 7), T0_FBYTE(x, 0)
59 #define T0_INT5(x) T0_SBYTE(x), T0_VBYTE(x, 21), T0_VBYTE(x, 14), T0_VBYTE(x, 7), T0_FBYTE(x, 0)
60
61 /* static const unsigned char t0_datablock[]; */
62
63
64 void br_x509_minimal_init_main(void *t0ctx);
65
66 void br_x509_minimal_run(void *t0ctx);
67
68
69
70 #include "inner.h"
71
72
73
74
75
76 #include "inner.h"
77
78 /*
79 * Implementation Notes
80 * --------------------
81 *
82 * The C code pushes the data by chunks; all decoding is done in the
83 * T0 code. The cert_length value is set to the certificate length when
84 * a new certificate is started; the T0 code picks it up as outer limit,
85 * and decoding functions use it to ensure that no attempt is made at
86 * reading past it. The T0 code also checks that once the certificate is
87 * decoded, there are no trailing bytes.
88 *
89 * The T0 code sets cert_length to 0 when the certificate is fully
90 * decoded.
91 *
92 * The C code must still perform two checks:
93 *
94 * -- If the certificate length is 0, then the T0 code will not be
95 * invoked at all. This invalid condition must thus be reported by the
96 * C code.
97 *
98 * -- When reaching the end of certificate, the C code must verify that
99 * the certificate length has been set to 0, thereby signaling that
100 * the T0 code properly decoded a certificate.
101 *
102 * Processing of a chain works in the following way:
103 *
104 * -- The error flag is set to a non-zero value when validation is
105 * finished. The value is either BR_ERR_X509_OK (validation is
106 * successful) or another non-zero error code. When a non-zero error
107 * code is obtained, the remaining bytes in the current certificate and
108 * the subsequent certificates (if any) are completely ignored.
109 *
110 * -- Each certificate is decoded in due course, with the following
111 * "interesting points":
112 *
113 * -- Start of the TBS: the multihash engine is reset and activated.
114 *
115 * -- Start of the issuer DN: the secondary hash engine is started,
116 * to process the encoded issuer DN.
117 *
118 * -- End of the issuer DN: the secondary hash engine is stopped. The
119 * resulting hash value is computed and then copied into the
120 * next_dn_hash[] buffer.
121 *
122 * -- Start of the subject DN: the secondary hash engine is started,
123 * to process the encoded subject DN.
124 *
125 * -- For the EE certificate only: the Common Name, if any, is matched
126 * against the expected server name.
127 *
128 * -- End of the subject DN: the secondary hash engine is stopped. The
129 * resulting hash value is computed into the pad. It is then processed:
130 *
131 * -- If this is the EE certificate, then the hash is ignored
132 * (except for direct trust processing, see later; the hash is
133 * simply left in current_dn_hash[]).
134 *
135 * -- Otherwise, the hashed subject DN is compared with the saved
136 * hash value (in saved_dn_hash[]). They must match.
137 *
138 * Either way, the next_dn_hash[] value is then copied into the
139 * saved_dn_hash[] value. Thus, at that point, saved_dn_hash[]
140 * contains the hash of the issuer DN for the current certificate,
141 * and current_dn_hash[] contains the hash of the subject DN for the
142 * current certificate.
143 *
144 * -- Public key: it is decoded into the cert_pkey[] buffer. Unknown
145 * key types are reported at that point.
146 *
147 * -- If this is the EE certificate, then the key type is compared
148 * with the expected key type (initialization parameter). The public
149 * key data is copied to ee_pkey_data[]. The key and hashed subject
150 * DN are also compared with the "direct trust" keys; if the key
151 * and DN are matched, then validation ends with a success.
152 *
153 * -- Otherwise, the saved signature (cert_sig[]) is verified
154 * against the saved TBS hash (tbs_hash[]) and that freshly
155 * decoded public key. Failure here ends validation with an error.
156 *
157 * -- Extensions: extension values are processed in due order.
158 *
159 * -- Basic Constraints: for all certificates except EE, must be
160 * present, indicate a CA, and have a path legnth compatible with
161 * the chain length so far.
162 *
163 * -- Key Usage: for the EE, if present, must allow signatures
164 * or encryption/key exchange, as required for the cipher suite.
165 * For non-EE, if present, must have the "certificate sign" bit.
166 *
167 * -- Subject Alt Name: for the EE, dNSName names are matched
168 * against the server name. Ignored for non-EE.
169 *
170 * -- Authority Key Identifier, Subject Key Identifier, Issuer
171 * Alt Name, Subject Directory Attributes, CRL Distribution Points
172 * Freshest CRL, Authority Info Access and Subject Info Access
173 * extensions are always ignored: they either contain only
174 * informative data, or they relate to revocation processing, which
175 * we explicitly do not support.
176 *
177 * -- All other extensions are ignored if non-critical. If a
178 * critical extension other than the ones above is encountered,
179 * then a failure is reported.
180 *
181 * -- End of the TBS: the multihash engine is stopped.
182 *
183 * -- Signature algorithm: the signature algorithm on the
184 * certificate is decoded. A failure is reported if that algorithm
185 * is unknown. The hashed TBS corresponding to the signature hash
186 * function is computed and stored in tbs_hash[] (if not supported,
187 * then a failure is reported). The hash OID and length are stored
188 * in cert_sig_hash_oid and cert_sig_hash_len.
189 *
190 * -- Signature value: the signature value is copied into the
191 * cert_sig[] array.
192 *
193 * -- Certificate end: the hashed issuer DN (saved_dn_hash[]) is
194 * looked up in the trust store (CA trust anchors only); for all
195 * that match, the signature (cert_sig[]) is verified against the
196 * anchor public key (hashed TBS is in tbs_hash[]). If one of these
197 * signatures is valid, then validation ends with a success.
198 *
199 * -- If the chain end is reached without obtaining a validation success,
200 * then validation is reported as failed.
201 */
202
203 #if BR_USE_UNIX_TIME
204 #include <time.h>
205 #endif
206
207 #if BR_USE_WIN32_TIME
208 #include <windows.h>
209 #endif
210
211 /*
212 * The T0 compiler will produce these prototypes declarations in the
213 * header.
214 *
215 void br_x509_minimal_init_main(void *ctx);
216 void br_x509_minimal_run(void *ctx);
217 */
218
219 /* see bearssl_x509.h */
220 void
221 br_x509_minimal_init(br_x509_minimal_context *ctx,
222 const br_hash_class *dn_hash_impl,
223 const br_x509_trust_anchor *trust_anchors, size_t trust_anchors_num)
224 {
225 memset(ctx, 0, sizeof *ctx);
226 ctx->vtable = &br_x509_minimal_vtable;
227 ctx->dn_hash_impl = dn_hash_impl;
228 ctx->trust_anchors = trust_anchors;
229 ctx->trust_anchors_num = trust_anchors_num;
230 }
231
232 static void
233 xm_start_chain(const br_x509_class **ctx, const char *server_name)
234 {
235 br_x509_minimal_context *cc;
236 size_t u;
237
238 cc = (br_x509_minimal_context *)(void *)ctx;
239 for (u = 0; u < cc->num_name_elts; u ++) {
240 cc->name_elts[u].status = 0;
241 cc->name_elts[u].buf[0] = 0;
242 }
243 memset(&cc->pkey, 0, sizeof cc->pkey);
244 cc->num_certs = 0;
245 cc->err = 0;
246 cc->cpu.dp = cc->dp_stack;
247 cc->cpu.rp = cc->rp_stack;
248 br_x509_minimal_init_main(&cc->cpu);
249 if (server_name == NULL || *server_name == 0) {
250 cc->server_name = NULL;
251 } else {
252 cc->server_name = server_name;
253 }
254 }
255
256 static void
257 xm_start_cert(const br_x509_class **ctx, uint32_t length)
258 {
259 br_x509_minimal_context *cc;
260
261 cc = (br_x509_minimal_context *)(void *)ctx;
262 if (cc->err != 0) {
263 return;
264 }
265 if (length == 0) {
266 cc->err = BR_ERR_X509_TRUNCATED;
267 return;
268 }
269 cc->cert_length = length;
270 }
271
272 static void
273 xm_append(const br_x509_class **ctx, const unsigned char *buf, size_t len)
274 {
275 br_x509_minimal_context *cc;
276
277 cc = (br_x509_minimal_context *)(void *)ctx;
278 if (cc->err != 0) {
279 return;
280 }
281 cc->hbuf = buf;
282 cc->hlen = len;
283 br_x509_minimal_run(&cc->cpu);
284 }
285
286 static void
287 xm_end_cert(const br_x509_class **ctx)
288 {
289 br_x509_minimal_context *cc;
290
291 cc = (br_x509_minimal_context *)(void *)ctx;
292 if (cc->err == 0 && cc->cert_length != 0) {
293 cc->err = BR_ERR_X509_TRUNCATED;
294 }
295 cc->num_certs ++;
296 }
297
298 static unsigned
299 xm_end_chain(const br_x509_class **ctx)
300 {
301 br_x509_minimal_context *cc;
302
303 cc = (br_x509_minimal_context *)(void *)ctx;
304 if (cc->err == 0) {
305 if (cc->num_certs == 0) {
306 cc->err = BR_ERR_X509_EMPTY_CHAIN;
307 } else {
308 cc->err = BR_ERR_X509_NOT_TRUSTED;
309 }
310 } else if (cc->err == BR_ERR_X509_OK) {
311 return 0;
312 }
313 return (unsigned)cc->err;
314 }
315
316 static const br_x509_pkey *
317 xm_get_pkey(const br_x509_class *const *ctx, unsigned *usages)
318 {
319 br_x509_minimal_context *cc;
320
321 cc = (br_x509_minimal_context *)(void *)ctx;
322 if (cc->err == BR_ERR_X509_OK
323 || cc->err == BR_ERR_X509_NOT_TRUSTED)
324 {
325 if (usages != NULL) {
326 *usages = cc->key_usages;
327 }
328 return &((br_x509_minimal_context *)(void *)ctx)->pkey;
329 } else {
330 return NULL;
331 }
332 }
333
334 /* see bearssl_x509.h */
335 const br_x509_class br_x509_minimal_vtable = {
336 sizeof(br_x509_minimal_context),
337 xm_start_chain,
338 xm_start_cert,
339 xm_append,
340 xm_end_cert,
341 xm_end_chain,
342 xm_get_pkey
343 };
344
345 #define CTX ((br_x509_minimal_context *)(void *)((unsigned char *)t0ctx - offsetof(br_x509_minimal_context, cpu)))
346 #define CONTEXT_NAME br_x509_minimal_context
347
348 #define DNHASH_LEN ((CTX->dn_hash_impl->desc >> BR_HASHDESC_OUT_OFF) & BR_HASHDESC_OUT_MASK)
349
350 /*
351 * Hash a DN (from a trust anchor) into the provided buffer. This uses the
352 * DN hash implementation and context structure from the X.509 engine
353 * context.
354 */
355 static void
356 hash_dn(br_x509_minimal_context *ctx, const void *dn, size_t len,
357 unsigned char *out)
358 {
359 ctx->dn_hash_impl->init(&ctx->dn_hash.vtable);
360 ctx->dn_hash_impl->update(&ctx->dn_hash.vtable, dn, len);
361 ctx->dn_hash_impl->out(&ctx->dn_hash.vtable, out);
362 }
363
364 /*
365 * Compare two big integers for equality. The integers use unsigned big-endian
366 * encoding; extra leading bytes (of value 0) are allowed.
367 */
368 static int
369 eqbigint(const unsigned char *b1, size_t len1,
370 const unsigned char *b2, size_t len2)
371 {
372 while (len1 > 0 && *b1 == 0) {
373 b1 ++;
374 len1 --;
375 }
376 while (len2 > 0 && *b2 == 0) {
377 b2 ++;
378 len2 --;
379 }
380 if (len1 != len2) {
381 return 0;
382 }
383 return memcmp(b1, b2, len1) == 0;
384 }
385
386 /*
387 * Compare two strings for equality, in a case-insensitive way. This
388 * function handles casing only for ASCII letters.
389 */
390 static int
391 eqnocase(const void *s1, const void *s2, size_t len)
392 {
393 const unsigned char *buf1, *buf2;
394
395 buf1 = s1;
396 buf2 = s2;
397 while (len -- > 0) {
398 int x1, x2;
399
400 x1 = *buf1 ++;
401 x2 = *buf2 ++;
402 if (x1 >= 'A' && x1 <= 'Z') {
403 x1 += 'a' - 'A';
404 }
405 if (x2 >= 'A' && x2 <= 'Z') {
406 x2 += 'a' - 'A';
407 }
408 if (x1 != x2) {
409 return 0;
410 }
411 }
412 return 1;
413 }
414
415 static int verify_signature(br_x509_minimal_context *ctx,
416 const br_x509_pkey *pk);
417
418
419
420 static const unsigned char t0_datablock[] = {
421 0x00, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x09,
422 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x09, 0x2A, 0x86,
423 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0E, 0x09, 0x2A, 0x86, 0x48, 0x86,
424 0xF7, 0x0D, 0x01, 0x01, 0x0B, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D,
425 0x01, 0x01, 0x0C, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01,
426 0x0D, 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A, 0x09, 0x60, 0x86, 0x48, 0x01,
427 0x65, 0x03, 0x04, 0x02, 0x04, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
428 0x04, 0x02, 0x01, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02,
429 0x02, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x07,
430 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01, 0x08, 0x2A, 0x86, 0x48, 0xCE,
431 0x3D, 0x03, 0x01, 0x07, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x22, 0x05, 0x2B,
432 0x81, 0x04, 0x00, 0x23, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x01,
433 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x01, 0x08, 0x2A, 0x86,
434 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D,
435 0x04, 0x03, 0x03, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x04,
436 0x03, 0x55, 0x04, 0x03, 0x00, 0x1F, 0x03, 0xFC, 0x07, 0x7F, 0x0B, 0x5E,
437 0x0F, 0x1F, 0x12, 0xFE, 0x16, 0xBF, 0x1A, 0x9F, 0x1E, 0x7E, 0x22, 0x3F,
438 0x26, 0x1E, 0x29, 0xDF, 0x00, 0x1F, 0x03, 0xFD, 0x07, 0x9F, 0x0B, 0x7E,
439 0x0F, 0x3F, 0x13, 0x1E, 0x16, 0xDF, 0x1A, 0xBF, 0x1E, 0x9E, 0x22, 0x5F,
440 0x26, 0x3E, 0x29, 0xFF, 0x03, 0x55, 0x1D, 0x13, 0x03, 0x55, 0x1D, 0x0F,
441 0x03, 0x55, 0x1D, 0x11, 0x03, 0x55, 0x1D, 0x20, 0x08, 0x2B, 0x06, 0x01,
442 0x05, 0x05, 0x07, 0x02, 0x01, 0x03, 0x55, 0x1D, 0x23, 0x03, 0x55, 0x1D,
443 0x0E, 0x03, 0x55, 0x1D, 0x12, 0x03, 0x55, 0x1D, 0x09, 0x03, 0x55, 0x1D,
444 0x1F, 0x03, 0x55, 0x1D, 0x2E, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07,
445 0x01, 0x01, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x0B
446 };
447
448 static const unsigned char t0_codeblock[] = {
449 0x00, 0x01, 0x00, 0x0D, 0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x01,
450 0x00, 0x11, 0x00, 0x00, 0x01, 0x01, 0x09, 0x00, 0x00, 0x01, 0x01, 0x0A,
451 0x00, 0x00, 0x24, 0x24, 0x00, 0x00, 0x01,
452 T0_INT1(BR_ERR_X509_BAD_BOOLEAN), 0x00, 0x00, 0x01,
453 T0_INT1(BR_ERR_X509_BAD_DN), 0x00, 0x00, 0x01,
454 T0_INT1(BR_ERR_X509_BAD_SERVER_NAME), 0x00, 0x00, 0x01,
455 T0_INT1(BR_ERR_X509_BAD_TAG_CLASS), 0x00, 0x00, 0x01,
456 T0_INT1(BR_ERR_X509_BAD_TAG_VALUE), 0x00, 0x00, 0x01,
457 T0_INT1(BR_ERR_X509_BAD_TIME), 0x00, 0x00, 0x01,
458 T0_INT1(BR_ERR_X509_CRITICAL_EXTENSION), 0x00, 0x00, 0x01,
459 T0_INT1(BR_ERR_X509_DN_MISMATCH), 0x00, 0x00, 0x01,
460 T0_INT1(BR_ERR_X509_EXPIRED), 0x00, 0x00, 0x01,
461 T0_INT1(BR_ERR_X509_EXTRA_ELEMENT), 0x00, 0x00, 0x01,
462 T0_INT1(BR_ERR_X509_FORBIDDEN_KEY_USAGE), 0x00, 0x00, 0x01,
463 T0_INT1(BR_ERR_X509_INDEFINITE_LENGTH), 0x00, 0x00, 0x01,
464 T0_INT1(BR_ERR_X509_INNER_TRUNC), 0x00, 0x00, 0x01,
465 T0_INT1(BR_ERR_X509_LIMIT_EXCEEDED), 0x00, 0x00, 0x01,
466 T0_INT1(BR_ERR_X509_NOT_CA), 0x00, 0x00, 0x01,
467 T0_INT1(BR_ERR_X509_NOT_CONSTRUCTED), 0x00, 0x00, 0x01,
468 T0_INT1(BR_ERR_X509_NOT_PRIMITIVE), 0x00, 0x00, 0x01,
469 T0_INT1(BR_ERR_X509_OVERFLOW), 0x00, 0x00, 0x01,
470 T0_INT1(BR_ERR_X509_PARTIAL_BYTE), 0x00, 0x00, 0x01,
471 T0_INT1(BR_ERR_X509_UNEXPECTED), 0x00, 0x00, 0x01,
472 T0_INT1(BR_ERR_X509_UNSUPPORTED), 0x00, 0x00, 0x01,
473 T0_INT1(BR_ERR_X509_WEAK_PUBLIC_KEY), 0x00, 0x00, 0x01,
474 T0_INT1(BR_KEYTYPE_EC), 0x00, 0x00, 0x01, T0_INT1(BR_KEYTYPE_RSA),
475 0x00, 0x00, 0x01, T0_INT2(offsetof(CONTEXT_NAME, cert_length)), 0x00,
476 0x00, 0x01, T0_INT2(offsetof(CONTEXT_NAME, cert_sig)), 0x00, 0x00,
477 0x01, T0_INT2(offsetof(CONTEXT_NAME, cert_sig_hash_len)), 0x00, 0x00,
478 0x01, T0_INT2(offsetof(CONTEXT_NAME, cert_sig_hash_oid)), 0x00, 0x00,
479 0x01, T0_INT2(offsetof(CONTEXT_NAME, cert_sig_len)), 0x00, 0x00, 0x01,
480 T0_INT2(offsetof(CONTEXT_NAME, cert_signer_key_type)), 0x00, 0x00,
481 0x01, T0_INT2(offsetof(CONTEXT_NAME, current_dn_hash)), 0x00, 0x00,
482 0x01, T0_INT2(offsetof(CONTEXT_NAME, key_usages)), 0x00, 0x00, 0x01,
483 T0_INT2(offsetof(br_x509_minimal_context, pkey_data)), 0x01,
484 T0_INT2(BR_X509_BUFSIZE_KEY), 0x00, 0x00, 0x01,
485 T0_INT2(offsetof(CONTEXT_NAME, min_rsa_size)), 0x00, 0x00, 0x01,
486 T0_INT2(offsetof(CONTEXT_NAME, next_dn_hash)), 0x00, 0x00, 0x01,
487 T0_INT2(offsetof(CONTEXT_NAME, num_certs)), 0x00, 0x00, 0x01,
488 T0_INT2(offsetof(CONTEXT_NAME, pad)), 0x00, 0x00, 0x01,
489 T0_INT2(offsetof(CONTEXT_NAME, saved_dn_hash)), 0x00, 0x00, 0xC9, 0x71,
490 0x00, 0x00, 0x01, 0x80, 0x73, 0x00, 0x00, 0x01, 0x80, 0x7C, 0x00, 0x00,
491 0x01, 0x81, 0x02, 0x00, 0x00, 0x92, 0x05, 0x05, 0x34, 0x42, 0x01, 0x00,
492 0x00, 0x34, 0x01, 0x0A, 0x0E, 0x09, 0x01, 0x9A, 0xFF, 0xB8, 0x00, 0x0A,
493 0x00, 0x00, 0x01, 0x82, 0x19, 0x00, 0x00, 0x01, 0x82, 0x01, 0x00, 0x00,
494 0x01, 0x81, 0x68, 0x00, 0x04, 0x03, 0x00, 0x03, 0x01, 0x03, 0x02, 0x03,
495 0x03, 0x02, 0x03, 0x02, 0x01, 0x11, 0x06, 0x07, 0x02, 0x02, 0x02, 0x00,
496 0x0D, 0x04, 0x05, 0x02, 0x03, 0x02, 0x01, 0x0D, 0x00, 0x02, 0x03, 0x00,
497 0x03, 0x01, 0x25, 0x02, 0x01, 0x13, 0x3B, 0x02, 0x00, 0x0F, 0x15, 0x00,
498 0x00, 0x01, 0x81, 0x74, 0x00, 0x00, 0x05, 0x02, 0x52, 0x28, 0x00, 0x00,
499 0x06, 0x02, 0x53, 0x28, 0x00, 0x00, 0x01, 0x10, 0x77, 0x00, 0x00, 0x11,
500 0x05, 0x02, 0x56, 0x28, 0x74, 0x00, 0x00, 0x11, 0x05, 0x02, 0x56, 0x28,
501 0x75, 0x00, 0x00, 0x06, 0x02, 0x4C, 0x28, 0x00, 0x00, 0x01, 0x82, 0x11,
502 0x00, 0x00, 0x25, 0x20, 0x01, 0x08, 0x0E, 0x3B, 0x40, 0x20, 0x09, 0x00,
503 0x09, 0x03, 0x00, 0x5B, 0x2B, 0xAF, 0x39, 0xAF, 0xB3, 0x25, 0x01, 0x20,
504 0x11, 0x06, 0x11, 0x24, 0x74, 0xAD, 0xB3, 0x01, 0x02, 0x78, 0xB0, 0x01,
505 0x02, 0x12, 0x06, 0x02, 0x57, 0x28, 0x79, 0xB3, 0x01, 0x02, 0x78, 0xAE,
506 0xAF, 0xC2, 0x9C, 0x65, 0x61, 0x21, 0x16, 0xAF, 0xA7, 0x29, 0x69, 0x06,
507 0x02, 0x4B, 0x28, 0xA7, 0x29, 0x71, 0x06, 0x02, 0x4B, 0x28, 0x79, 0x02,
508 0x00, 0x06, 0x05, 0x9D, 0x03, 0x01, 0x04, 0x09, 0x9C, 0x61, 0x68, 0x21,
509 0x27, 0x05, 0x02, 0x4A, 0x28, 0x68, 0x65, 0x21, 0x16, 0xAF, 0xAF, 0x9E,
510 0x05, 0x02, 0x57, 0x28, 0xBC, 0x26, 0x06, 0x27, 0xC2, 0xA4, 0xAF, 0x63,
511 0xAA, 0x03, 0x03, 0x63, 0x3B, 0x02, 0x03, 0x09, 0x3B, 0x02, 0x03, 0x0A,
512 0xAA, 0x03, 0x04, 0x79, 0x64, 0x2A, 0x01, 0x81, 0x00, 0x09, 0x02, 0x03,
513 0x12, 0x06, 0x02, 0x58, 0x28, 0x79, 0x5A, 0x03, 0x02, 0x04, 0x3A, 0x88,
514 0x26, 0x06, 0x34, 0x9E, 0x05, 0x02, 0x57, 0x28, 0x6A, 0x26, 0x06, 0x04,
515 0x01, 0x17, 0x04, 0x12, 0x6B, 0x26, 0x06, 0x04, 0x01, 0x18, 0x04, 0x0A,
516 0x6C, 0x26, 0x06, 0x04, 0x01, 0x19, 0x04, 0x02, 0x57, 0x28, 0x03, 0x05,
517 0x79, 0xA4, 0x25, 0x03, 0x06, 0x25, 0x63, 0x34, 0x0D, 0x06, 0x02, 0x50,
518 0x28, 0xA5, 0x59, 0x03, 0x02, 0x04, 0x02, 0x57, 0x28, 0x79, 0x02, 0x00,
519 0x06, 0x21, 0x02, 0x02, 0x5A, 0x30, 0x11, 0x06, 0x08, 0x24, 0x02, 0x03,
520 0x02, 0x04, 0x1D, 0x04, 0x10, 0x59, 0x30, 0x11, 0x06, 0x08, 0x24, 0x02,
521 0x05, 0x02, 0x06, 0x1C, 0x04, 0x03, 0x57, 0x28, 0x24, 0x04, 0x24, 0x02,
522 0x02, 0x5A, 0x30, 0x11, 0x06, 0x08, 0x24, 0x02, 0x03, 0x02, 0x04, 0x23,
523 0x04, 0x10, 0x59, 0x30, 0x11, 0x06, 0x08, 0x24, 0x02, 0x05, 0x02, 0x06,
524 0x22, 0x04, 0x03, 0x57, 0x28, 0x24, 0x25, 0x06, 0x01, 0x28, 0x24, 0x01,
525 0x00, 0x03, 0x07, 0xB4, 0x01, 0x21, 0x8F, 0x01, 0x22, 0x8F, 0x25, 0x01,
526 0x23, 0x11, 0x06, 0x81, 0x26, 0x24, 0x74, 0xAD, 0xAF, 0x25, 0x06, 0x81,
527 0x1A, 0x01, 0x00, 0x03, 0x08, 0xAF, 0x9E, 0x24, 0xB3, 0x25, 0x01, 0x01,
528 0x11, 0x06, 0x04, 0xA6, 0x03, 0x08, 0xB3, 0x01, 0x04, 0x78, 0xAD, 0x70,
529 0x26, 0x06, 0x0F, 0x02, 0x00, 0x06, 0x03, 0xC3, 0x04, 0x05, 0x99, 0x01,
530 0x7F, 0x03, 0x07, 0x04, 0x80, 0x6C, 0x91, 0x26, 0x06, 0x06, 0x02, 0x00,
531 0x9B, 0x04, 0x80, 0x62, 0xC5, 0x26, 0x06, 0x11, 0x02, 0x00, 0x06, 0x09,
532 0x01, 0x00, 0x03, 0x01, 0x98, 0x03, 0x01, 0x04, 0x01, 0xC3, 0x04, 0x80,
533 0x4D, 0x73, 0x26, 0x06, 0x0A, 0x02, 0x08, 0x06, 0x03, 0x9A, 0x04, 0x01,
534 0xC3, 0x04, 0x3F, 0x6F, 0x26, 0x06, 0x03, 0xC3, 0x04, 0x38, 0xC8, 0x26,
535 0x06, 0x03, 0xC3, 0x04, 0x31, 0x90, 0x26, 0x06, 0x03, 0xC3, 0x04, 0x2A,
536 0xC6, 0x26, 0x06, 0x03, 0xC3, 0x04, 0x23, 0x7A, 0x26, 0x06, 0x03, 0xC3,
537 0x04, 0x1C, 0x85, 0x26, 0x06, 0x03, 0xC3, 0x04, 0x15, 0x6E, 0x26, 0x06,
538 0x03, 0xC3, 0x04, 0x0E, 0xC7, 0x26, 0x06, 0x03, 0xC3, 0x04, 0x07, 0x02,
539 0x08, 0x06, 0x02, 0x49, 0x28, 0xC3, 0x79, 0x79, 0x04, 0xFE, 0x62, 0x79,
540 0x79, 0x04, 0x08, 0x01, 0x7F, 0x11, 0x05, 0x02, 0x56, 0x28, 0x24, 0x79,
541 0x3A, 0x02, 0x00, 0x06, 0x08, 0x02, 0x01, 0x3C, 0x2F, 0x05, 0x02, 0x45,
542 0x28, 0x02, 0x00, 0x06, 0x01, 0x17, 0x02, 0x00, 0x02, 0x07, 0x2F, 0x05,
543 0x02, 0x51, 0x28, 0xB3, 0x76, 0xAD, 0x9E, 0x06, 0x80, 0x77, 0xBD, 0x26,
544 0x06, 0x07, 0x01, 0x02, 0x5A, 0x8A, 0x04, 0x80, 0x5E, 0xBE, 0x26, 0x06,
545 0x07, 0x01, 0x03, 0x5A, 0x8B, 0x04, 0x80, 0x53, 0xBF, 0x26, 0x06, 0x07,
546 0x01, 0x04, 0x5A, 0x8C, 0x04, 0x80, 0x48, 0xC0, 0x26, 0x06, 0x06, 0x01,
547 0x05, 0x5A, 0x8D, 0x04, 0x3E, 0xC1, 0x26, 0x06, 0x06, 0x01, 0x06, 0x5A,
548 0x8E, 0x04, 0x34, 0x7F, 0x26, 0x06, 0x06, 0x01, 0x02, 0x59, 0x8A, 0x04,
549 0x2A, 0x80, 0x26, 0x06, 0x06, 0x01, 0x03, 0x59, 0x8B, 0x04, 0x20, 0x81,
550 0x26, 0x06, 0x06, 0x01, 0x04, 0x59, 0x8C, 0x04, 0x16, 0x82, 0x26, 0x06,
551 0x06, 0x01, 0x05, 0x59, 0x8D, 0x04, 0x0C, 0x83, 0x26, 0x06, 0x06, 0x01,
552 0x06, 0x59, 0x8E, 0x04, 0x02, 0x57, 0x28, 0x5E, 0x35, 0x60, 0x37, 0x1B,
553 0x25, 0x05, 0x02, 0x57, 0x28, 0x5D, 0x37, 0x04, 0x02, 0x57, 0x28, 0xC2,
554 0xA4, 0x25, 0x01, T0_INT2(BR_X509_BUFSIZE_SIG), 0x12, 0x06, 0x02, 0x50,
555 0x28, 0x25, 0x5F, 0x35, 0x5C, 0xA5, 0x79, 0x79, 0x01, 0x00, 0x5B, 0x36,
556 0x18, 0x00, 0x00, 0x01, 0x30, 0x0A, 0x25, 0x01, 0x00, 0x01, 0x09, 0x72,
557 0x05, 0x02, 0x48, 0x28, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x01, 0x81,
558 0x08, 0x00, 0x00, 0x01, 0x81, 0x10, 0x00, 0x00, 0x01, 0x81, 0x19, 0x00,
559 0x00, 0x01, 0x81, 0x22, 0x00, 0x00, 0x01, 0x81, 0x2B, 0x00, 0x01, 0x7E,
560 0x01, 0x01, 0x11, 0x3B, 0x01, 0x83, 0xFD, 0x7F, 0x11, 0x15, 0x06, 0x03,
561 0x3B, 0x24, 0x00, 0x3B, 0x25, 0x03, 0x00, 0x25, 0xCA, 0x05, 0x04, 0x42,
562 0x01, 0x00, 0x00, 0x25, 0x01, 0x81, 0x00, 0x0D, 0x06, 0x04, 0x96, 0x04,
563 0x80, 0x49, 0x25, 0x01, 0x90, 0x00, 0x0D, 0x06, 0x0F, 0x01, 0x06, 0x14,
564 0x01, 0x81, 0x40, 0x2F, 0x96, 0x02, 0x00, 0x01, 0x00, 0x97, 0x04, 0x33,
565 0x25, 0x01, 0x83, 0xFF, 0x7F, 0x0D, 0x06, 0x14, 0x01, 0x0C, 0x14, 0x01,
566 0x81, 0x60, 0x2F, 0x96, 0x02, 0x00, 0x01, 0x06, 0x97, 0x02, 0x00, 0x01,
567 0x00, 0x97, 0x04, 0x17, 0x01, 0x12, 0x14, 0x01, 0x81, 0x70, 0x2F, 0x96,
568 0x02, 0x00, 0x01, 0x0C, 0x97, 0x02, 0x00, 0x01, 0x06, 0x97, 0x02, 0x00,
569 0x01, 0x00, 0x97, 0x00, 0x00, 0x01, 0x82, 0x15, 0x00, 0x00, 0x25, 0x01,
570 0x83, 0xB0, 0x00, 0x01, 0x83, 0xB7, 0x7F, 0x72, 0x00, 0x00, 0x01, 0x81,
571 0x34, 0x00, 0x00, 0x01, 0x80, 0x6B, 0x00, 0x00, 0x01, 0x81, 0x78, 0x00,
572 0x00, 0x01, 0x3D, 0x00, 0x00, 0x01, 0x80, 0x43, 0x00, 0x00, 0x01, 0x80,
573 0x4D, 0x00, 0x00, 0x01, 0x80, 0x57, 0x00, 0x00, 0x01, 0x80, 0x61, 0x00,
574 0x00, 0x30, 0x11, 0x06, 0x04, 0x42, 0xAD, 0xC2, 0xB4, 0x00, 0x00, 0x01,
575 0x82, 0x09, 0x00, 0x00, 0x01, 0x81, 0x6C, 0x00, 0x00, 0x25, 0x01, 0x83,
576 0xB8, 0x00, 0x01, 0x83, 0xBF, 0x7F, 0x72, 0x00, 0x00, 0x01, 0x30, 0x62,
577 0x37, 0x01, 0x7F, 0x7C, 0x19, 0x01, 0x00, 0x7C, 0x19, 0x04, 0x7A, 0x00,
578 0x01, 0x81, 0x38, 0x00, 0x01, 0x7E, 0x0D, 0x06, 0x02, 0x4F, 0x28, 0x25,
579 0x03, 0x00, 0x0A, 0x02, 0x00, 0x00, 0x00, 0x30, 0x25, 0x3F, 0x3B, 0x01,
580 0x82, 0x00, 0x13, 0x2F, 0x06, 0x04, 0x42, 0x01, 0x00, 0x00, 0x30, 0x67,
581 0x09, 0x37, 0x40, 0x00, 0x00, 0x14, 0x01, 0x3F, 0x15, 0x01, 0x81, 0x00,
582 0x2F, 0x96, 0x00, 0x02, 0x01, 0x00, 0x03, 0x00, 0xAF, 0x25, 0x06, 0x80,
583 0x59, 0xB3, 0x01, 0x20, 0x30, 0x11, 0x06, 0x17, 0x24, 0x74, 0xAD, 0x9E,
584 0x24, 0x01, 0x7F, 0x2E, 0x03, 0x01, 0xB3, 0x01, 0x20, 0x77, 0xAD, 0xB2,
585 0x02, 0x01, 0x1F, 0x79, 0x79, 0x04, 0x38, 0x01, 0x21, 0x30, 0x11, 0x06,
586 0x08, 0x24, 0x75, 0xB6, 0x01, 0x01, 0x1E, 0x04, 0x2A, 0x01, 0x22, 0x30,
587 0x11, 0x06, 0x11, 0x24, 0x75, 0xB6, 0x25, 0x06, 0x06, 0x2C, 0x02, 0x00,
588 0x2F, 0x03, 0x00, 0x01, 0x02, 0x1E, 0x04, 0x13, 0x01, 0x26, 0x30, 0x11,
589 0x06, 0x08, 0x24, 0x75, 0xB6, 0x01, 0x06, 0x1E, 0x04, 0x05, 0x42, 0xAE,
590 0x01, 0x00, 0x24, 0x04, 0xFF, 0x23, 0x79, 0x02, 0x00, 0x00, 0x00, 0xAF,
591 0xB4, 0x25, 0x01, 0x01, 0x11, 0x06, 0x08, 0xA6, 0x05, 0x02, 0x51, 0x28,
592 0xB4, 0x04, 0x02, 0x51, 0x28, 0x25, 0x01, 0x02, 0x11, 0x06, 0x0C, 0x24,
593 0x75, 0xB0, 0x66, 0x2B, 0x41, 0x0D, 0x06, 0x02, 0x51, 0x28, 0xB4, 0x01,
594 0x7F, 0x10, 0x06, 0x02, 0x56, 0x28, 0x24, 0x79, 0x00, 0x00, 0xAF, 0x25,
595 0x06, 0x1A, 0xAF, 0x9E, 0x24, 0x25, 0x06, 0x11, 0xAF, 0x25, 0x06, 0x0C,
596 0xAF, 0x9E, 0x24, 0x89, 0x26, 0x05, 0x02, 0x49, 0x28, 0xC2, 0x04, 0x71,
597 0x79, 0x79, 0x04, 0x63, 0x79, 0x00, 0x02, 0x03, 0x00, 0xB3, 0x01, 0x03,
598 0x78, 0xAD, 0xBA, 0x03, 0x01, 0x02, 0x01, 0x01, 0x07, 0x12, 0x06, 0x02,
599 0x56, 0x28, 0x25, 0x01, 0x00, 0x30, 0x11, 0x06, 0x05, 0x24, 0x4D, 0x28,
600 0x04, 0x15, 0x01, 0x01, 0x30, 0x11, 0x06, 0x0A, 0x24, 0xBA, 0x02, 0x01,
601 0x14, 0x02, 0x01, 0x0E, 0x04, 0x05, 0x24, 0xBA, 0x01, 0x00, 0x24, 0x02,
602 0x00, 0x06, 0x19, 0x01, 0x00, 0x30, 0x01, 0x38, 0x15, 0x06, 0x03, 0x01,
603 0x10, 0x2F, 0x3B, 0x01, 0x81, 0x40, 0x15, 0x06, 0x03, 0x01, 0x20, 0x2F,
604 0x62, 0x37, 0x04, 0x07, 0x01, 0x04, 0x15, 0x05, 0x02, 0x4D, 0x28, 0xC2,
605 0x00, 0x00, 0x38, 0xAF, 0xC2, 0x1A, 0x00, 0x03, 0x01, 0x00, 0x03, 0x00,
606 0x38, 0xAF, 0x25, 0x06, 0x30, 0xB3, 0x01, 0x11, 0x77, 0xAD, 0x25, 0x05,
607 0x02, 0x44, 0x28, 0x25, 0x06, 0x20, 0xAF, 0x9E, 0x24, 0x87, 0x26, 0x03,
608 0x01, 0x01, 0x00, 0x2E, 0x03, 0x02, 0xB2, 0x25, 0x02, 0x01, 0x15, 0x06,
609 0x07, 0x2C, 0x06, 0x04, 0x01, 0x7F, 0x03, 0x00, 0x02, 0x02, 0x1F, 0x79,
610 0x04, 0x5D, 0x79, 0x04, 0x4D, 0x79, 0x1A, 0x02, 0x00, 0x00, 0x00, 0xB3,
611 0x01, 0x06, 0x78, 0xB1, 0x00, 0x00, 0xB8, 0x86, 0x06, 0x0E, 0x3B, 0x25,
612 0x05, 0x06, 0x42, 0x01, 0x00, 0x01, 0x00, 0x00, 0xB8, 0x6D, 0x04, 0x08,
613 0x92, 0x06, 0x05, 0x24, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0xB9, 0x86,
614 0x06, 0x0E, 0x3B, 0x25, 0x05, 0x06, 0x42, 0x01, 0x00, 0x01, 0x00, 0x00,
615 0xB9, 0x6D, 0x04, 0x08, 0x92, 0x06, 0x05, 0x24, 0x01, 0x00, 0x04, 0x00,
616 0x00, 0x00, 0xBA, 0x25, 0x01, 0x81, 0x00, 0x0D, 0x06, 0x04, 0x00, 0x04,
617 0x80, 0x55, 0x25, 0x01, 0x81, 0x40, 0x0D, 0x06, 0x07, 0x24, 0x01, 0x00,
618 0x00, 0x04, 0x80, 0x47, 0x25, 0x01, 0x81, 0x60, 0x0D, 0x06, 0x0E, 0x01,
619 0x1F, 0x15, 0x01, 0x01, 0xA3, 0x01, 0x81, 0x00, 0x01, 0x8F, 0x7F, 0x04,
620 0x32, 0x25, 0x01, 0x81, 0x70, 0x0D, 0x06, 0x0F, 0x01, 0x0F, 0x15, 0x01,
621 0x02, 0xA3, 0x01, 0x90, 0x00, 0x01, 0x83, 0xFF, 0x7F, 0x04, 0x1C, 0x25,
622 0x01, 0x81, 0x78, 0x0D, 0x06, 0x11, 0x01, 0x07, 0x15, 0x01, 0x03, 0xA3,
623 0x01, 0x84, 0x80, 0x00, 0x01, 0x80, 0xC3, 0xFF, 0x7F, 0x04, 0x04, 0x24,
624 0x01, 0x00, 0x00, 0x72, 0x05, 0x03, 0x24, 0x01, 0x00, 0x00, 0x00, 0x3B,
625 0x25, 0x05, 0x06, 0x42, 0x01, 0x00, 0x01, 0x7F, 0x00, 0xBA, 0x34, 0x25,
626 0x3D, 0x06, 0x03, 0x3B, 0x24, 0x00, 0x01, 0x06, 0x0E, 0x3B, 0x25, 0x01,
627 0x06, 0x14, 0x01, 0x02, 0x10, 0x06, 0x04, 0x42, 0x01, 0x7F, 0x00, 0x01,
628 0x3F, 0x15, 0x09, 0x00, 0x00, 0x25, 0x06, 0x06, 0x0B, 0xA2, 0x34, 0x41,
629 0x04, 0x77, 0x24, 0x25, 0x00, 0x00, 0xB3, 0x01, 0x03, 0x78, 0xAD, 0xBA,
630 0x06, 0x02, 0x55, 0x28, 0x00, 0x00, 0x3B, 0x25, 0x06, 0x07, 0x31, 0x25,
631 0x06, 0x01, 0x19, 0x04, 0x76, 0x42, 0x00, 0x00, 0x01, 0x01, 0x78, 0xAC,
632 0x01, 0x01, 0x10, 0x06, 0x02, 0x43, 0x28, 0xBA, 0x3E, 0x00, 0x04, 0xB3,
633 0x25, 0x01, 0x17, 0x01, 0x18, 0x72, 0x05, 0x02, 0x48, 0x28, 0x01, 0x18,
634 0x11, 0x03, 0x00, 0x75, 0xAD, 0xA8, 0x02, 0x00, 0x06, 0x0C, 0x01, 0x80,
635 0x64, 0x08, 0x03, 0x01, 0xA8, 0x02, 0x01, 0x09, 0x04, 0x0E, 0x25, 0x01,
636 0x32, 0x0D, 0x06, 0x04, 0x01, 0x80, 0x64, 0x09, 0x01, 0x8E, 0x6C, 0x09,
637 0x03, 0x01, 0x02, 0x01, 0x01, 0x82, 0x6D, 0x08, 0x02, 0x01, 0x01, 0x03,
638 0x09, 0x01, 0x04, 0x0C, 0x09, 0x02, 0x01, 0x01, 0x80, 0x63, 0x09, 0x01,
639 0x80, 0x64, 0x0C, 0x0A, 0x02, 0x01, 0x01, 0x83, 0x0F, 0x09, 0x01, 0x83,
640 0x10, 0x0C, 0x09, 0x03, 0x03, 0x01, 0x01, 0x01, 0x0C, 0xA9, 0x41, 0x01,
641 0x01, 0x0E, 0x02, 0x01, 0x01, 0x04, 0x07, 0x3F, 0x02, 0x01, 0x01, 0x80,
642 0x64, 0x07, 0x3E, 0x02, 0x01, 0x01, 0x83, 0x10, 0x07, 0x3F, 0x2F, 0x15,
643 0x06, 0x03, 0x01, 0x18, 0x09, 0x94, 0x09, 0x7B, 0x25, 0x01, 0x05, 0x14,
644 0x02, 0x03, 0x09, 0x03, 0x03, 0x01, 0x1F, 0x15, 0x01, 0x01, 0x3B, 0xA9,
645 0x02, 0x03, 0x09, 0x41, 0x03, 0x03, 0x01, 0x00, 0x01, 0x17, 0xA9, 0x01,
646 0x9C, 0x10, 0x08, 0x03, 0x02, 0x01, 0x00, 0x01, 0x3B, 0xA9, 0x01, 0x3C,
647 0x08, 0x02, 0x02, 0x09, 0x03, 0x02, 0x01, 0x00, 0x01, 0x3C, 0xA9, 0x02,
648 0x02, 0x09, 0x03, 0x02, 0xBA, 0x25, 0x01, 0x2E, 0x11, 0x06, 0x0D, 0x24,
649 0xBA, 0x25, 0x01, 0x30, 0x01, 0x39, 0x72, 0x06, 0x03, 0x24, 0x04, 0x74,
650 0x01, 0x80, 0x5A, 0x10, 0x06, 0x02, 0x48, 0x28, 0x79, 0x02, 0x03, 0x02,
651 0x02, 0x00, 0x01, 0xBA, 0x7D, 0x01, 0x0A, 0x08, 0x03, 0x00, 0xBA, 0x7D,
652 0x02, 0x00, 0x09, 0x00, 0x02, 0x03, 0x00, 0x03, 0x01, 0xA8, 0x25, 0x02,
653 0x01, 0x02, 0x00, 0x72, 0x05, 0x02, 0x48, 0x28, 0x00, 0x00, 0x34, 0xB3,
654 0x01, 0x02, 0x78, 0x0B, 0xAB, 0x00, 0x03, 0x25, 0x03, 0x00, 0x03, 0x01,
655 0x03, 0x02, 0xAD, 0xBA, 0x25, 0x01, 0x81, 0x00, 0x13, 0x06, 0x02, 0x54,
656 0x28, 0x25, 0x01, 0x00, 0x11, 0x06, 0x0B, 0x24, 0x25, 0x05, 0x04, 0x24,
657 0x01, 0x00, 0x00, 0xBA, 0x04, 0x6F, 0x02, 0x01, 0x25, 0x05, 0x02, 0x50,
658 0x28, 0x41, 0x03, 0x01, 0x02, 0x02, 0x37, 0x02, 0x02, 0x40, 0x03, 0x02,
659 0x25, 0x06, 0x03, 0xBA, 0x04, 0x68, 0x24, 0x02, 0x00, 0x02, 0x01, 0x0A,
660 0x00, 0x01, 0xBA, 0x25, 0x01, 0x81, 0x00, 0x0D, 0x06, 0x01, 0x00, 0x01,
661 0x81, 0x00, 0x0A, 0x25, 0x05, 0x02, 0x4E, 0x28, 0x03, 0x00, 0x01, 0x00,
662 0x02, 0x00, 0x01, 0x00, 0x12, 0x06, 0x19, 0x02, 0x00, 0x41, 0x03, 0x00,
663 0x25, 0x01, 0x83, 0xFF, 0xFF, 0x7F, 0x12, 0x06, 0x02, 0x4F, 0x28, 0x01,
664 0x08, 0x0E, 0x3B, 0xBA, 0x34, 0x09, 0x04, 0x60, 0x00, 0x00, 0xAC, 0x95,
665 0x00, 0x00, 0xAD, 0xC2, 0x00, 0x00, 0xB3, 0x76, 0xAD, 0x00, 0x01, 0xAD,
666 0x25, 0x05, 0x02, 0x54, 0x28, 0xBA, 0x25, 0x01, 0x81, 0x00, 0x13, 0x06,
667 0x02, 0x54, 0x28, 0x03, 0x00, 0x25, 0x06, 0x16, 0xBA, 0x02, 0x00, 0x25,
668 0x01, 0x87, 0xFF, 0xFF, 0x7F, 0x13, 0x06, 0x02, 0x54, 0x28, 0x01, 0x08,
669 0x0E, 0x09, 0x03, 0x00, 0x04, 0x67, 0x24, 0x02, 0x00, 0x00, 0x00, 0xAD,
670 0x25, 0x01, 0x81, 0x7F, 0x12, 0x06, 0x08, 0xC2, 0x01, 0x00, 0x67, 0x37,
671 0x01, 0x00, 0x00, 0x25, 0x67, 0x37, 0x67, 0x40, 0xA5, 0x01, 0x7F, 0x00,
672 0x00, 0xB3, 0x01, 0x0C, 0x30, 0x11, 0x06, 0x05, 0x24, 0x75, 0xB6, 0x04,
673 0x3E, 0x01, 0x12, 0x30, 0x11, 0x06, 0x05, 0x24, 0x75, 0xB7, 0x04, 0x33,
674 0x01, 0x13, 0x30, 0x11, 0x06, 0x05, 0x24, 0x75, 0xB7, 0x04, 0x28, 0x01,
675 0x14, 0x30, 0x11, 0x06, 0x05, 0x24, 0x75, 0xB7, 0x04, 0x1D, 0x01, 0x16,
676 0x30, 0x11, 0x06, 0x05, 0x24, 0x75, 0xB7, 0x04, 0x12, 0x01, 0x1E, 0x30,
677 0x11, 0x06, 0x05, 0x24, 0x75, 0xB5, 0x04, 0x07, 0x42, 0xAE, 0x01, 0x00,
678 0x01, 0x00, 0x24, 0x00, 0x01, 0xBA, 0x03, 0x00, 0x02, 0x00, 0x01, 0x05,
679 0x14, 0x01, 0x01, 0x15, 0x2D, 0x02, 0x00, 0x01, 0x06, 0x14, 0x25, 0x01,
680 0x01, 0x15, 0x06, 0x02, 0x46, 0x28, 0x01, 0x04, 0x0E, 0x02, 0x00, 0x01,
681 0x1F, 0x15, 0x25, 0x01, 0x1F, 0x11, 0x06, 0x02, 0x47, 0x28, 0x09, 0x00,
682 0x00, 0x25, 0x05, 0x05, 0x01, 0x00, 0x01, 0x7F, 0x00, 0xB3, 0x00, 0x01,
683 0xAD, 0x25, 0x05, 0x05, 0x67, 0x37, 0x01, 0x7F, 0x00, 0x01, 0x01, 0x03,
684 0x00, 0x9F, 0x25, 0x01, 0x83, 0xFF, 0x7E, 0x11, 0x06, 0x16, 0x24, 0x25,
685 0x06, 0x10, 0xA0, 0x25, 0x05, 0x05, 0x24, 0xC2, 0x01, 0x00, 0x00, 0x02,
686 0x00, 0x84, 0x03, 0x00, 0x04, 0x6D, 0x04, 0x1B, 0x25, 0x05, 0x05, 0x24,
687 0xC2, 0x01, 0x00, 0x00, 0x02, 0x00, 0x84, 0x03, 0x00, 0x25, 0x06, 0x0B,
688 0x9F, 0x25, 0x05, 0x05, 0x24, 0xC2, 0x01, 0x00, 0x00, 0x04, 0x6D, 0x24,
689 0x02, 0x00, 0x25, 0x05, 0x01, 0x00, 0x41, 0x67, 0x37, 0x01, 0x7F, 0x00,
690 0x01, 0xAD, 0x01, 0x01, 0x03, 0x00, 0x25, 0x06, 0x10, 0xA1, 0x25, 0x05,
691 0x05, 0x24, 0xC2, 0x01, 0x00, 0x00, 0x02, 0x00, 0x84, 0x03, 0x00, 0x04,
692 0x6D, 0x24, 0x02, 0x00, 0x25, 0x05, 0x01, 0x00, 0x41, 0x67, 0x37, 0x01,
693 0x7F, 0x00, 0x01, 0xAD, 0x01, 0x01, 0x03, 0x00, 0x25, 0x06, 0x10, 0xBA,
694 0x25, 0x05, 0x05, 0x24, 0xC2, 0x01, 0x00, 0x00, 0x02, 0x00, 0x84, 0x03,
695 0x00, 0x04, 0x6D, 0x24, 0x02, 0x00, 0x25, 0x05, 0x01, 0x00, 0x41, 0x67,
696 0x37, 0x01, 0x7F, 0x00, 0x00, 0xBA, 0x01, 0x08, 0x0E, 0x3B, 0xBA, 0x34,
697 0x09, 0x00, 0x00, 0xBA, 0x3B, 0xBA, 0x01, 0x08, 0x0E, 0x34, 0x09, 0x00,
698 0x00, 0x25, 0x05, 0x02, 0x4F, 0x28, 0x41, 0xBB, 0x00, 0x00, 0x32, 0x25,
699 0x01, 0x00, 0x13, 0x06, 0x01, 0x00, 0x24, 0x19, 0x04, 0x74, 0x00, 0x01,
700 0x01, 0x00, 0x00, 0x01, 0x0B, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01,
701 0x1F, 0x00, 0x00, 0x01, 0x29, 0x00, 0x00, 0x01, 0x33, 0x00, 0x00, 0xC3,
702 0x24, 0x00, 0x00, 0x25, 0x06, 0x07, 0xC4, 0x25, 0x06, 0x01, 0x19, 0x04,
703 0x76, 0x00, 0x00, 0x01, 0x00, 0x30, 0x31, 0x0B, 0x42, 0x00, 0x00, 0x01,
704 0x81, 0x70, 0x00, 0x00, 0x01, 0x82, 0x0D, 0x00, 0x00, 0x01, 0x82, 0x22,
705 0x00, 0x00, 0x01, 0x82, 0x05, 0x00, 0x00, 0x01, 0x03, 0x33, 0x01, 0x03,
706 0x33, 0x00, 0x00, 0x25, 0x01, 0x83, 0xFB, 0x50, 0x01, 0x83, 0xFB, 0x6F,
707 0x72, 0x06, 0x04, 0x24, 0x01, 0x00, 0x00, 0x25, 0x01, 0x83, 0xB0, 0x00,
708 0x01, 0x83, 0xBF, 0x7F, 0x72, 0x06, 0x04, 0x24, 0x01, 0x00, 0x00, 0x01,
709 0x83, 0xFF, 0x7F, 0x15, 0x01, 0x83, 0xFF, 0x7E, 0x0D, 0x00
710 };
711
712 static const uint16_t t0_caddr[] = {
713 0,
714 5,
715 10,
716 15,
717 20,
718 25,
719 29,
720 33,
721 37,
722 41,
723 45,
724 49,
725 53,
726 57,
727 61,
728 65,
729 69,
730 73,
731 77,
732 81,
733 85,
734 89,
735 93,
736 97,
737 101,
738 105,
739 109,
740 113,
741 117,
742 121,
743 125,
744 130,
745 135,
746 140,
747 145,
748 150,
749 155,
750 160,
751 165,
752 173,
753 178,
754 183,
755 188,
756 193,
757 198,
758 202,
759 207,
760 212,
761 217,
762 238,
763 243,
764 248,
765 253,
766 282,
767 297,
768 302,
769 308,
770 314,
771 319,
772 327,
773 335,
774 341,
775 346,
776 357,
777 992,
778 1007,
779 1011,
780 1016,
781 1021,
782 1026,
783 1031,
784 1036,
785 1150,
786 1155,
787 1167,
788 1172,
789 1177,
790 1182,
791 1186,
792 1191,
793 1196,
794 1201,
795 1206,
796 1216,
797 1221,
798 1226,
799 1238,
800 1253,
801 1258,
802 1272,
803 1294,
804 1305,
805 1408,
806 1455,
807 1488,
808 1579,
809 1585,
810 1648,
811 1655,
812 1683,
813 1711,
814 1816,
815 1858,
816 1871,
817 1883,
818 1897,
819 1912,
820 2132,
821 2146,
822 2163,
823 2172,
824 2239,
825 2295,
826 2299,
827 2303,
828 2308,
829 2356,
830 2382,
831 2458,
832 2502,
833 2513,
834 2598,
835 2636,
836 2674,
837 2684,
838 2694,
839 2703,
840 2716,
841 2720,
842 2724,
843 2728,
844 2732,
845 2736,
846 2740,
847 2744,
848 2756,
849 2764,
850 2769,
851 2774,
852 2779,
853 2784,
854 2792
855 };
856
857 #define T0_INTERPRETED 61
858
859 #define T0_ENTER(ip, rp, slot) do { \
860 const unsigned char *t0_newip; \
861 uint32_t t0_lnum; \
862 t0_newip = &t0_codeblock[t0_caddr[(slot) - T0_INTERPRETED]]; \
863 t0_lnum = t0_parse7E_unsigned(&t0_newip); \
864 (rp) += t0_lnum; \
865 *((rp) ++) = (uint32_t)((ip) - &t0_codeblock[0]) + (t0_lnum << 16); \
866 (ip) = t0_newip; \
867 } while (0)
868
869 #define T0_DEFENTRY(name, slot) \
870 void \
871 name(void *ctx) \
872 { \
873 t0_context *t0ctx = ctx; \
874 t0ctx->ip = &t0_codeblock[0]; \
875 T0_ENTER(t0ctx->ip, t0ctx->rp, slot); \
876 }
877
878 T0_DEFENTRY(br_x509_minimal_init_main, 147)
879
880 #define T0_NEXT(t0ipp) (*(*(t0ipp)) ++)
881
882 void
883 br_x509_minimal_run(void *t0ctx)
884 {
885 uint32_t *dp, *rp;
886 const unsigned char *ip;
887
888 #define T0_LOCAL(x) (*(rp - 2 - (x)))
889 #define T0_POP() (*-- dp)
890 #define T0_POPi() (*(int32_t *)(-- dp))
891 #define T0_PEEK(x) (*(dp - 1 - (x)))
892 #define T0_PEEKi(x) (*(int32_t *)(dp - 1 - (x)))
893 #define T0_PUSH(v) do { *dp = (v); dp ++; } while (0)
894 #define T0_PUSHi(v) do { *(int32_t *)dp = (v); dp ++; } while (0)
895 #define T0_RPOP() (*-- rp)
896 #define T0_RPOPi() (*(int32_t *)(-- rp))
897 #define T0_RPUSH(v) do { *rp = (v); rp ++; } while (0)
898 #define T0_RPUSHi(v) do { *(int32_t *)rp = (v); rp ++; } while (0)
899 #define T0_ROLL(x) do { \
900 size_t t0len = (size_t)(x); \
901 uint32_t t0tmp = *(dp - 1 - t0len); \
902 memmove(dp - t0len - 1, dp - t0len, t0len * sizeof *dp); \
903 *(dp - 1) = t0tmp; \
904 } while (0)
905 #define T0_SWAP() do { \
906 uint32_t t0tmp = *(dp - 2); \
907 *(dp - 2) = *(dp - 1); \
908 *(dp - 1) = t0tmp; \
909 } while (0)
910 #define T0_ROT() do { \
911 uint32_t t0tmp = *(dp - 3); \
912 *(dp - 3) = *(dp - 2); \
913 *(dp - 2) = *(dp - 1); \
914 *(dp - 1) = t0tmp; \
915 } while (0)
916 #define T0_NROT() do { \
917 uint32_t t0tmp = *(dp - 1); \
918 *(dp - 1) = *(dp - 2); \
919 *(dp - 2) = *(dp - 3); \
920 *(dp - 3) = t0tmp; \
921 } while (0)
922 #define T0_PICK(x) do { \
923 uint32_t t0depth = (x); \
924 T0_PUSH(T0_PEEK(t0depth)); \
925 } while (0)
926 #define T0_CO() do { \
927 goto t0_exit; \
928 } while (0)
929 #define T0_RET() goto t0_next
930
931 dp = ((t0_context *)t0ctx)->dp;
932 rp = ((t0_context *)t0ctx)->rp;
933 ip = ((t0_context *)t0ctx)->ip;
934 goto t0_next;
935 for (;;) {
936 uint32_t t0x;
937
938 t0_next:
939 t0x = T0_NEXT(&ip);
940 if (t0x < T0_INTERPRETED) {
941 switch (t0x) {
942 int32_t t0off;
943
944 case 0: /* ret */
945 t0x = T0_RPOP();
946 rp -= (t0x >> 16);
947 t0x &= 0xFFFF;
948 if (t0x == 0) {
949 ip = NULL;
950 goto t0_exit;
951 }
952 ip = &t0_codeblock[t0x];
953 break;
954 case 1: /* literal constant */
955 T0_PUSHi(t0_parse7E_signed(&ip));
956 break;
957 case 2: /* read local */
958 T0_PUSH(T0_LOCAL(t0_parse7E_unsigned(&ip)));
959 break;
960 case 3: /* write local */
961 T0_LOCAL(t0_parse7E_unsigned(&ip)) = T0_POP();
962 break;
963 case 4: /* jump */
964 t0off = t0_parse7E_signed(&ip);
965 ip += t0off;
966 break;
967 case 5: /* jump if */
968 t0off = t0_parse7E_signed(&ip);
969 if (T0_POP()) {
970 ip += t0off;
971 }
972 break;
973 case 6: /* jump if not */
974 t0off = t0_parse7E_signed(&ip);
975 if (!T0_POP()) {
976 ip += t0off;
977 }
978 break;
979 case 7: {
980 /* %25 */
981
982 int32_t b = T0_POPi();
983 int32_t a = T0_POPi();
984 T0_PUSHi(a % b);
985
986 }
987 break;
988 case 8: {
989 /* * */
990
991 uint32_t b = T0_POP();
992 uint32_t a = T0_POP();
993 T0_PUSH(a * b);
994
995 }
996 break;
997 case 9: {
998 /* + */
999
1000 uint32_t b = T0_POP();
1001 uint32_t a = T0_POP();
1002 T0_PUSH(a + b);
1003
1004 }
1005 break;
1006 case 10: {
1007 /* - */
1008
1009 uint32_t b = T0_POP();
1010 uint32_t a = T0_POP();
1011 T0_PUSH(a - b);
1012
1013 }
1014 break;
1015 case 11: {
1016 /* -rot */
1017 T0_NROT();
1018 }
1019 break;
1020 case 12: {
1021 /* / */
1022
1023 int32_t b = T0_POPi();
1024 int32_t a = T0_POPi();
1025 T0_PUSHi(a / b);
1026
1027 }
1028 break;
1029 case 13: {
1030 /* < */
1031
1032 int32_t b = T0_POPi();
1033 int32_t a = T0_POPi();
1034 T0_PUSH(-(uint32_t)(a < b));
1035
1036 }
1037 break;
1038 case 14: {
1039 /* << */
1040
1041 int c = (int)T0_POPi();
1042 uint32_t x = T0_POP();
1043 T0_PUSH(x << c);
1044
1045 }
1046 break;
1047 case 15: {
1048 /* <= */
1049
1050 int32_t b = T0_POPi();
1051 int32_t a = T0_POPi();
1052 T0_PUSH(-(uint32_t)(a <= b));
1053
1054 }
1055 break;
1056 case 16: {
1057 /* <> */
1058
1059 uint32_t b = T0_POP();
1060 uint32_t a = T0_POP();
1061 T0_PUSH(-(uint32_t)(a != b));
1062
1063 }
1064 break;
1065 case 17: {
1066 /* = */
1067
1068 uint32_t b = T0_POP();
1069 uint32_t a = T0_POP();
1070 T0_PUSH(-(uint32_t)(a == b));
1071
1072 }
1073 break;
1074 case 18: {
1075 /* > */
1076
1077 int32_t b = T0_POPi();
1078 int32_t a = T0_POPi();
1079 T0_PUSH(-(uint32_t)(a > b));
1080
1081 }
1082 break;
1083 case 19: {
1084 /* >= */
1085
1086 int32_t b = T0_POPi();
1087 int32_t a = T0_POPi();
1088 T0_PUSH(-(uint32_t)(a >= b));
1089
1090 }
1091 break;
1092 case 20: {
1093 /* >> */
1094
1095 int c = (int)T0_POPi();
1096 int32_t x = T0_POPi();
1097 T0_PUSHi(x >> c);
1098
1099 }
1100 break;
1101 case 21: {
1102 /* and */
1103
1104 uint32_t b = T0_POP();
1105 uint32_t a = T0_POP();
1106 T0_PUSH(a & b);
1107
1108 }
1109 break;
1110 case 22: {
1111 /* blobcopy */
1112
1113 size_t len = T0_POP();
1114 unsigned char *src = (unsigned char *)CTX + T0_POP();
1115 unsigned char *dst = (unsigned char *)CTX + T0_POP();
1116 memcpy(dst, src, len);
1117
1118 }
1119 break;
1120 case 23: {
1121 /* check-direct-trust */
1122
1123 size_t u;
1124
1125 for (u = 0; u < CTX->trust_anchors_num; u ++) {
1126 const br_x509_trust_anchor *ta;
1127 unsigned char hashed_DN[64];
1128 int kt;
1129
1130 ta = &CTX->trust_anchors[u];
1131 if (ta->flags & BR_X509_TA_CA) {
1132 continue;
1133 }
1134 hash_dn(CTX, ta->dn.data, ta->dn.len, hashed_DN);
1135 if (memcmp(hashed_DN, CTX->current_dn_hash, DNHASH_LEN)) {
1136 continue;
1137 }
1138 kt = CTX->pkey.key_type;
1139 if ((ta->pkey.key_type & 0x0F) != kt) {
1140 continue;
1141 }
1142 switch (kt) {
1143
1144 case BR_KEYTYPE_RSA:
1145 if (!eqbigint(CTX->pkey.key.rsa.n,
1146 CTX->pkey.key.rsa.nlen,
1147 ta->pkey.key.rsa.n,
1148 ta->pkey.key.rsa.nlen)
1149 || !eqbigint(CTX->pkey.key.rsa.e,
1150 CTX->pkey.key.rsa.elen,
1151 ta->pkey.key.rsa.e,
1152 ta->pkey.key.rsa.elen))
1153 {
1154 continue;
1155 }
1156 break;
1157
1158 case BR_KEYTYPE_EC:
1159 if (CTX->pkey.key.ec.curve != ta->pkey.key.ec.curve
1160 || CTX->pkey.key.ec.qlen != ta->pkey.key.ec.qlen
1161 || memcmp(CTX->pkey.key.ec.q,
1162 ta->pkey.key.ec.q,
1163 ta->pkey.key.ec.qlen) != 0)
1164 {
1165 continue;
1166 }
1167 break;
1168
1169 default:
1170 continue;
1171 }
1172
1173 /*
1174 * Direct trust match!
1175 */
1176 CTX->err = BR_ERR_X509_OK;
1177 T0_CO();
1178 }
1179
1180 }
1181 break;
1182 case 24: {
1183 /* check-trust-anchor-CA */
1184
1185 size_t u;
1186
1187 for (u = 0; u < CTX->trust_anchors_num; u ++) {
1188 const br_x509_trust_anchor *ta;
1189 unsigned char hashed_DN[64];
1190
1191 ta = &CTX->trust_anchors[u];
1192 if (!(ta->flags & BR_X509_TA_CA)) {
1193 continue;
1194 }
1195 hash_dn(CTX, ta->dn.data, ta->dn.len, hashed_DN);
1196 if (memcmp(hashed_DN, CTX->saved_dn_hash, DNHASH_LEN)) {
1197 continue;
1198 }
1199 if (verify_signature(CTX, &ta->pkey) == 0) {
1200 CTX->err = BR_ERR_X509_OK;
1201 T0_CO();
1202 }
1203 }
1204
1205 }
1206 break;
1207 case 25: {
1208 /* co */
1209 T0_CO();
1210 }
1211 break;
1212 case 26: {
1213 /* compute-dn-hash */
1214
1215 CTX->dn_hash_impl->out(&CTX->dn_hash.vtable, CTX->current_dn_hash);
1216 CTX->do_dn_hash = 0;
1217
1218 }
1219 break;
1220 case 27: {
1221 /* compute-tbs-hash */
1222
1223 int id = T0_POPi();
1224 size_t len;
1225 len = br_multihash_out(&CTX->mhash, id, CTX->tbs_hash);
1226 T0_PUSH(len);
1227
1228 }
1229 break;
1230 case 28: {
1231 /* copy-ee-ec-pkey */
1232
1233 size_t qlen = T0_POP();
1234 uint32_t curve = T0_POP();
1235 memcpy(CTX->ee_pkey_data, CTX->pkey_data, qlen);
1236 CTX->pkey.key_type = BR_KEYTYPE_EC;
1237 CTX->pkey.key.ec.curve = curve;
1238 CTX->pkey.key.ec.q = CTX->ee_pkey_data;
1239 CTX->pkey.key.ec.qlen = qlen;
1240
1241 }
1242 break;
1243 case 29: {
1244 /* copy-ee-rsa-pkey */
1245
1246 size_t elen = T0_POP();
1247 size_t nlen = T0_POP();
1248 memcpy(CTX->ee_pkey_data, CTX->pkey_data, nlen + elen);
1249 CTX->pkey.key_type = BR_KEYTYPE_RSA;
1250 CTX->pkey.key.rsa.n = CTX->ee_pkey_data;
1251 CTX->pkey.key.rsa.nlen = nlen;
1252 CTX->pkey.key.rsa.e = CTX->ee_pkey_data + nlen;
1253 CTX->pkey.key.rsa.elen = elen;
1254
1255 }
1256 break;
1257 case 30: {
1258 /* copy-name-SAN */
1259
1260 unsigned tag = T0_POP();
1261 unsigned ok = T0_POP();
1262 size_t u, len;
1263
1264 len = CTX->pad[0];
1265 for (u = 0; u < CTX->num_name_elts; u ++) {
1266 br_name_element *ne;
1267
1268 ne = &CTX->name_elts[u];
1269 if (ne->status == 0 && ne->oid[0] == 0 && ne->oid[1] == tag) {
1270 if (ok && ne->len > len) {
1271 memcpy(ne->buf, CTX->pad + 1, len);
1272 ne->buf[len] = 0;
1273 ne->status = 1;
1274 } else {
1275 ne->status = -1;
1276 }
1277 break;
1278 }
1279 }
1280
1281 }
1282 break;
1283 case 31: {
1284 /* copy-name-element */
1285
1286 size_t len;
1287 int32_t off = T0_POPi();
1288 int ok = T0_POPi();
1289
1290 if (off >= 0) {
1291 br_name_element *ne = &CTX->name_elts[off];
1292
1293 if (ok) {
1294 len = CTX->pad[0];
1295 if (len < ne->len) {
1296 memcpy(ne->buf, CTX->pad + 1, len);
1297 ne->buf[len] = 0;
1298 ne->status = 1;
1299 } else {
1300 ne->status = -1;
1301 }
1302 } else {
1303 ne->status = -1;
1304 }
1305 }
1306
1307 }
1308 break;
1309 case 32: {
1310 /* data-get8 */
1311
1312 size_t addr = T0_POP();
1313 T0_PUSH(t0_datablock[addr]);
1314
1315 }
1316 break;
1317 case 33: {
1318 /* dn-hash-length */
1319
1320 T0_PUSH(DNHASH_LEN);
1321
1322 }
1323 break;
1324 case 34: {
1325 /* do-ecdsa-vrfy */
1326
1327 size_t qlen = T0_POP();
1328 int curve = T0_POP();
1329 br_x509_pkey pk;
1330
1331 pk.key_type = BR_KEYTYPE_EC;
1332 pk.key.ec.curve = curve;
1333 pk.key.ec.q = CTX->pkey_data;
1334 pk.key.ec.qlen = qlen;
1335 T0_PUSH(verify_signature(CTX, &pk));
1336
1337 }
1338 break;
1339 case 35: {
1340 /* do-rsa-vrfy */
1341
1342 size_t elen = T0_POP();
1343 size_t nlen = T0_POP();
1344 br_x509_pkey pk;
1345
1346 pk.key_type = BR_KEYTYPE_RSA;
1347 pk.key.rsa.n = CTX->pkey_data;
1348 pk.key.rsa.nlen = nlen;
1349 pk.key.rsa.e = CTX->pkey_data + nlen;
1350 pk.key.rsa.elen = elen;
1351 T0_PUSH(verify_signature(CTX, &pk));
1352
1353 }
1354 break;
1355 case 36: {
1356 /* drop */
1357 (void)T0_POP();
1358 }
1359 break;
1360 case 37: {
1361 /* dup */
1362 T0_PUSH(T0_PEEK(0));
1363 }
1364 break;
1365 case 38: {
1366 /* eqOID */
1367
1368 const unsigned char *a2 = &t0_datablock[T0_POP()];
1369 const unsigned char *a1 = &CTX->pad[0];
1370 size_t len = a1[0];
1371 int x;
1372 if (len == a2[0]) {
1373 x = -(memcmp(a1 + 1, a2 + 1, len) == 0);
1374 } else {
1375 x = 0;
1376 }
1377 T0_PUSH((uint32_t)x);
1378
1379 }
1380 break;
1381 case 39: {
1382 /* eqblob */
1383
1384 size_t len = T0_POP();
1385 const unsigned char *a2 = (const unsigned char *)CTX + T0_POP();
1386 const unsigned char *a1 = (const unsigned char *)CTX + T0_POP();
1387 T0_PUSHi(-(memcmp(a1, a2, len) == 0));
1388
1389 }
1390 break;
1391 case 40: {
1392 /* fail */
1393
1394 CTX->err = T0_POPi();
1395 T0_CO();
1396
1397 }
1398 break;
1399 case 41: {
1400 /* get-system-date */
1401
1402 if (CTX->days == 0 && CTX->seconds == 0) {
1403 #if BR_USE_UNIX_TIME
1404 time_t x = time(NULL);
1405
1406 T0_PUSH((uint32_t)(x / 86400) + 719528);
1407 T0_PUSH((uint32_t)(x % 86400));
1408 #elif BR_USE_WIN32_TIME
1409 FILETIME ft;
1410 uint64_t x;
1411
1412 GetSystemTimeAsFileTime(&ft);
1413 x = ((uint64_t)ft.dwHighDateTime << 32)
1414 + (uint64_t)ft.dwLowDateTime;
1415 x = (x / 10000000);
1416 T0_PUSH((uint32_t)(x / 86400) + 584754);
1417 T0_PUSH((uint32_t)(x % 86400));
1418 #else
1419 CTX->err = BR_ERR_X509_TIME_UNKNOWN;
1420 T0_CO();
1421 #endif
1422 } else {
1423 T0_PUSH(CTX->days);
1424 T0_PUSH(CTX->seconds);
1425 }
1426
1427 }
1428 break;
1429 case 42: {
1430 /* get16 */
1431
1432 uint32_t addr = T0_POP();
1433 T0_PUSH(*(uint16_t *)(void *)((unsigned char *)CTX + addr));
1434
1435 }
1436 break;
1437 case 43: {
1438 /* get32 */
1439
1440 uint32_t addr = T0_POP();
1441 T0_PUSH(*(uint32_t *)(void *)((unsigned char *)CTX + addr));
1442
1443 }
1444 break;
1445 case 44: {
1446 /* match-server-name */
1447
1448 size_t n1, n2;
1449
1450 if (CTX->server_name == NULL) {
1451 T0_PUSH(0);
1452 T0_RET();
1453 }
1454 n1 = strlen(CTX->server_name);
1455 n2 = CTX->pad[0];
1456 if (n1 == n2 && eqnocase(&CTX->pad[1], CTX->server_name, n1)) {
1457 T0_PUSHi(-1);
1458 T0_RET();
1459 }
1460 if (n2 >= 2 && CTX->pad[1] == '*' && CTX->pad[2] == '.') {
1461 size_t u;
1462
1463 u = 0;
1464 while (u < n1 && CTX->server_name[u] != '.') {
1465 u ++;
1466 }
1467 u ++;
1468 n1 -= u;
1469 if ((n2 - 2) == n1
1470 && eqnocase(&CTX->pad[3], CTX->server_name + u, n1))
1471 {
1472 T0_PUSHi(-1);
1473 T0_RET();
1474 }
1475 }
1476 T0_PUSH(0);
1477
1478 }
1479 break;
1480 case 45: {
1481 /* neg */
1482
1483 uint32_t a = T0_POP();
1484 T0_PUSH(-a);
1485
1486 }
1487 break;
1488 case 46: {
1489 /* offset-name-element */
1490
1491 unsigned san = T0_POP();
1492 size_t u;
1493
1494 for (u = 0; u < CTX->num_name_elts; u ++) {
1495 if (CTX->name_elts[u].status == 0) {
1496 const unsigned char *oid;
1497 size_t len, off;
1498
1499 oid = CTX->name_elts[u].oid;
1500 if (san) {
1501 if (oid[0] != 0 || oid[1] != 0) {
1502 continue;
1503 }
1504 off = 2;
1505 } else {
1506 off = 0;
1507 }
1508 len = oid[off];
1509 if (len != 0 && len == CTX->pad[0]
1510 && memcmp(oid + off + 1,
1511 CTX->pad + 1, len) == 0)
1512 {
1513 T0_PUSH(u);
1514 T0_RET();
1515 }
1516 }
1517 }
1518 T0_PUSHi(-1);
1519
1520 }
1521 break;
1522 case 47: {
1523 /* or */
1524
1525 uint32_t b = T0_POP();
1526 uint32_t a = T0_POP();
1527 T0_PUSH(a | b);
1528
1529 }
1530 break;
1531 case 48: {
1532 /* over */
1533 T0_PUSH(T0_PEEK(1));
1534 }
1535 break;
1536 case 49: {
1537 /* read-blob-inner */
1538
1539 uint32_t len = T0_POP();
1540 uint32_t addr = T0_POP();
1541 size_t clen = CTX->hlen;
1542 if (clen > len) {
1543 clen = (size_t)len;
1544 }
1545 if (addr != 0) {
1546 memcpy((unsigned char *)CTX + addr, CTX->hbuf, clen);
1547 }
1548 if (CTX->do_mhash) {
1549 br_multihash_update(&CTX->mhash, CTX->hbuf, clen);
1550 }
1551 if (CTX->do_dn_hash) {
1552 CTX->dn_hash_impl->update(
1553 &CTX->dn_hash.vtable, CTX->hbuf, clen);
1554 }
1555 CTX->hbuf += clen;
1556 CTX->hlen -= clen;
1557 T0_PUSH(addr + clen);
1558 T0_PUSH(len - clen);
1559
1560 }
1561 break;
1562 case 50: {
1563 /* read8-low */
1564
1565 if (CTX->hlen == 0) {
1566 T0_PUSHi(-1);
1567 } else {
1568 unsigned char x = *CTX->hbuf ++;
1569 if (CTX->do_mhash) {
1570 br_multihash_update(&CTX->mhash, &x, 1);
1571 }
1572 if (CTX->do_dn_hash) {
1573 CTX->dn_hash_impl->update(&CTX->dn_hash.vtable, &x, 1);
1574 }
1575 CTX->hlen --;
1576 T0_PUSH(x);
1577 }
1578
1579 }
1580 break;
1581 case 51: {
1582 /* roll */
1583 T0_ROLL(T0_POP());
1584 }
1585 break;
1586 case 52: {
1587 /* rot */
1588 T0_ROT();
1589 }
1590 break;
1591 case 53: {
1592 /* set16 */
1593
1594 uint32_t addr = T0_POP();
1595 *(uint16_t *)(void *)((unsigned char *)CTX + addr) = T0_POP();
1596
1597 }
1598 break;
1599 case 54: {
1600 /* set32 */
1601
1602 uint32_t addr = T0_POP();
1603 *(uint32_t *)(void *)((unsigned char *)CTX + addr) = T0_POP();
1604
1605 }
1606 break;
1607 case 55: {
1608 /* set8 */
1609
1610 uint32_t addr = T0_POP();
1611 *((unsigned char *)CTX + addr) = (unsigned char)T0_POP();
1612
1613 }
1614 break;
1615 case 56: {
1616 /* start-dn-hash */
1617
1618 CTX->dn_hash_impl->init(&CTX->dn_hash.vtable);
1619 CTX->do_dn_hash = 1;
1620
1621 }
1622 break;
1623 case 57: {
1624 /* start-tbs-hash */
1625
1626 br_multihash_init(&CTX->mhash);
1627 CTX->do_mhash = 1;
1628
1629 }
1630 break;
1631 case 58: {
1632 /* stop-tbs-hash */
1633
1634 CTX->do_mhash = 0;
1635
1636 }
1637 break;
1638 case 59: {
1639 /* swap */
1640 T0_SWAP();
1641 }
1642 break;
1643 case 60: {
1644 /* zero-server-name */
1645
1646 T0_PUSHi(-(CTX->server_name == NULL));
1647
1648 }
1649 break;
1650 }
1651
1652 } else {
1653 T0_ENTER(ip, rp, t0x);
1654 }
1655 }
1656 t0_exit:
1657 ((t0_context *)t0ctx)->dp = dp;
1658 ((t0_context *)t0ctx)->rp = rp;
1659 ((t0_context *)t0ctx)->ip = ip;
1660 }
1661
1662
1663
1664 /*
1665 * Verify the signature on the certificate with the provided public key.
1666 * This function checks the public key type with regards to the expected
1667 * type. Returned value is either 0 on success, or a non-zero error code.
1668 */
1669 static int
1670 verify_signature(br_x509_minimal_context *ctx, const br_x509_pkey *pk)
1671 {
1672 int kt;
1673
1674 kt = ctx->cert_signer_key_type;
1675 if ((pk->key_type & 0x0F) != kt) {
1676 return BR_ERR_X509_WRONG_KEY_TYPE;
1677 }
1678 switch (kt) {
1679 unsigned char tmp[64];
1680
1681 case BR_KEYTYPE_RSA:
1682 if (ctx->irsa == 0) {
1683 return BR_ERR_X509_UNSUPPORTED;
1684 }
1685 if (!ctx->irsa(ctx->cert_sig, ctx->cert_sig_len,
1686 &t0_datablock[ctx->cert_sig_hash_oid],
1687 ctx->cert_sig_hash_len, &pk->key.rsa, tmp))
1688 {
1689 return BR_ERR_X509_BAD_SIGNATURE;
1690 }
1691 if (memcmp(ctx->tbs_hash, tmp, ctx->cert_sig_hash_len) != 0) {
1692 return BR_ERR_X509_BAD_SIGNATURE;
1693 }
1694 return 0;
1695
1696 case BR_KEYTYPE_EC:
1697 if (ctx->iecdsa == 0) {
1698 return BR_ERR_X509_UNSUPPORTED;
1699 }
1700 if (!ctx->iecdsa(ctx->iec, ctx->tbs_hash,
1701 ctx->cert_sig_hash_len, &pk->key.ec,
1702 ctx->cert_sig, ctx->cert_sig_len))
1703 {
1704 return BR_ERR_X509_BAD_SIGNATURE;
1705 }
1706 return 0;
1707
1708 default:
1709 return BR_ERR_X509_UNSUPPORTED;
1710 }
1711 }
1712
1713