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_ssl_hs_server_init_main(void *t0ctx); 65 66 void br_ssl_hs_server_run(void *t0ctx); 67 68 69 70 #include <stddef.h> 71 #include <string.h> 72 73 #include "inner.h" 74 75 /* 76 * This macro evaluates to a pointer to the current engine context. 77 */ 78 #define ENG ((br_ssl_engine_context *)(void *)((unsigned char *)t0ctx - offsetof(br_ssl_engine_context, cpu))) 79 80 81 82 83 84 /* 85 * This macro evaluates to a pointer to the server context, under that 86 * specific name. It must be noted that since the engine context is the 87 * first field of the br_ssl_server_context structure ('eng'), then 88 * pointers values of both types are interchangeable, modulo an 89 * appropriate cast. This also means that "addresses" computed as offsets 90 * within the structure work for both kinds of context. 91 */ 92 #define CTX ((br_ssl_server_context *)ENG) 93 94 /* 95 * Decrypt the pre-master secret (RSA key exchange). 96 */ 97 static void 98 do_rsa_decrypt(br_ssl_server_context *ctx, int prf_id, 99 unsigned char *epms, size_t len) 100 { 101 uint32_t x; 102 unsigned char rpms[48]; 103 104 /* 105 * Decrypt the PMS. 106 */ 107 x = (*ctx->policy_vtable)->do_keyx(ctx->policy_vtable, epms, &len); 108 109 /* 110 * Set the first two bytes to the maximum supported client 111 * protocol version. These bytes are used for version rollback 112 * detection; forceing the two bytes will make the master secret 113 * wrong if the bytes are not correct. This process is 114 * recommended by RFC 5246 (section 7.4.7.1). 115 */ 116 br_enc16be(epms, ctx->client_max_version); 117 118 /* 119 * Make a random PMS and copy it above the decrypted value if the 120 * decryption failed. Note that we use a constant-time conditional 121 * copy. 122 */ 123 br_hmac_drbg_generate(&ctx->eng.rng, rpms, sizeof rpms); 124 br_ccopy(x ^ 1, epms, rpms, sizeof rpms); 125 126 /* 127 * Compute master secret. 128 */ 129 br_ssl_engine_compute_master(&ctx->eng, prf_id, epms, 48); 130 131 /* 132 * Clear the pre-master secret from RAM: it is normally a buffer 133 * in the context, hence potentially long-lived. 134 */ 135 memset(epms, 0, len); 136 } 137 138 /* 139 * Common part for ECDH and ECDHE. 140 */ 141 static void 142 ecdh_common(br_ssl_server_context *ctx, int prf_id, 143 unsigned char *xcoor, size_t xcoor_len, uint32_t ctl) 144 { 145 unsigned char rpms[80]; 146 147 if (xcoor_len > sizeof rpms) { 148 xcoor_len = sizeof rpms; 149 ctl = 0; 150 } 151 152 /* 153 * Make a random PMS and copy it above the decrypted value if the 154 * decryption failed. Note that we use a constant-time conditional 155 * copy. 156 */ 157 br_hmac_drbg_generate(&ctx->eng.rng, rpms, xcoor_len); 158 br_ccopy(ctl ^ 1, xcoor, rpms, xcoor_len); 159 160 /* 161 * Compute master secret. 162 */ 163 br_ssl_engine_compute_master(&ctx->eng, prf_id, xcoor, xcoor_len); 164 165 /* 166 * Clear the pre-master secret from RAM: it is normally a buffer 167 * in the context, hence potentially long-lived. 168 */ 169 memset(xcoor, 0, xcoor_len); 170 } 171 172 /* 173 * Do the ECDH key exchange (not ECDHE). 174 */ 175 static void 176 do_ecdh(br_ssl_server_context *ctx, int prf_id, 177 unsigned char *cpoint, size_t cpoint_len) 178 { 179 uint32_t x; 180 181 /* 182 * Finalise the key exchange. 183 */ 184 x = (*ctx->policy_vtable)->do_keyx(ctx->policy_vtable, 185 cpoint, &cpoint_len); 186 ecdh_common(ctx, prf_id, cpoint, cpoint_len, x); 187 } 188 189 /* 190 * Do the full static ECDH key exchange. When this function is called, 191 * it has already been verified that the cipher suite uses ECDH (not ECDHE), 192 * and the client's public key (from its certificate) has type EC and is 193 * apt for key exchange. 194 */ 195 static void 196 do_static_ecdh(br_ssl_server_context *ctx, int prf_id) 197 { 198 unsigned char cpoint[133]; 199 size_t cpoint_len; 200 const br_x509_class **xc; 201 const br_x509_pkey *pk; 202 203 xc = ctx->eng.x509ctx; 204 pk = (*xc)->get_pkey(xc, NULL); 205 cpoint_len = pk->key.ec.qlen; 206 if (cpoint_len > sizeof cpoint) { 207 /* 208 * If the point is larger than our buffer then we need to 209 * restrict it. Length 2 is not a valid point length, so 210 * the ECDH will fail. 211 */ 212 cpoint_len = 2; 213 } 214 memcpy(cpoint, pk->key.ec.q, cpoint_len); 215 do_ecdh(ctx, prf_id, cpoint, cpoint_len); 216 } 217 218 static size_t 219 hash_data(br_ssl_server_context *ctx, 220 void *dst, int hash_id, const void *src, size_t len) 221 { 222 const br_hash_class *hf; 223 br_hash_compat_context hc; 224 225 if (hash_id == 0) { 226 unsigned char tmp[36]; 227 228 hf = br_multihash_getimpl(&ctx->eng.mhash, br_md5_ID); 229 if (hf == NULL) { 230 return 0; 231 } 232 hf->init(&hc.vtable); 233 hf->update(&hc.vtable, src, len); 234 hf->out(&hc.vtable, tmp); 235 hf = br_multihash_getimpl(&ctx->eng.mhash, br_sha1_ID); 236 if (hf == NULL) { 237 return 0; 238 } 239 hf->init(&hc.vtable); 240 hf->update(&hc.vtable, src, len); 241 hf->out(&hc.vtable, tmp + 16); 242 memcpy(dst, tmp, 36); 243 return 36; 244 } else { 245 hf = br_multihash_getimpl(&ctx->eng.mhash, hash_id); 246 if (hf == NULL) { 247 return 0; 248 } 249 hf->init(&hc.vtable); 250 hf->update(&hc.vtable, src, len); 251 hf->out(&hc.vtable, dst); 252 return (hf->desc >> BR_HASHDESC_OUT_OFF) & BR_HASHDESC_OUT_MASK; 253 } 254 } 255 256 /* 257 * Do the ECDHE key exchange (part 1: generation of transient key, and 258 * computing of the point to send to the client). Returned value is the 259 * signature length (in bytes), or -x on error (with x being an error 260 * code). The encoded point is written in the ecdhe_point[] context buffer 261 * (length in ecdhe_point_len). 262 */ 263 static int 264 do_ecdhe_part1(br_ssl_server_context *ctx, int curve) 265 { 266 unsigned algo_id; 267 unsigned mask; 268 const unsigned char *order; 269 size_t olen, glen; 270 size_t hv_len, sig_len; 271 272 if (!((ctx->eng.iec->supported_curves >> curve) & 1)) { 273 return -BR_ERR_INVALID_ALGORITHM; 274 } 275 ctx->eng.ecdhe_curve = curve; 276 277 /* 278 * Generate our private key. We need a non-zero random value 279 * which is lower than the curve order, in a "large enough" 280 * range. We force the top bit to 0 and bottom bit to 1, which 281 * does the trick. Note that contrary to what happens in ECDSA, 282 * this is not a problem if we do not cover the full range of 283 * possible values. 284 */ 285 order = ctx->eng.iec->order(curve, &olen); 286 mask = 0xFF; 287 while (mask >= order[0]) { 288 mask >>= 1; 289 } 290 br_hmac_drbg_generate(&ctx->eng.rng, ctx->ecdhe_key, olen); 291 ctx->ecdhe_key[0] &= mask; 292 ctx->ecdhe_key[olen - 1] |= 0x01; 293 ctx->ecdhe_key_len = olen; 294 295 /* 296 * Compute our ECDH point. 297 */ 298 glen = ctx->eng.iec->mulgen(ctx->eng.ecdhe_point, 299 ctx->ecdhe_key, olen, curve); 300 ctx->eng.ecdhe_point_len = glen; 301 302 /* 303 * Assemble the message to be signed, and possibly hash it. 304 */ 305 memcpy(ctx->eng.pad, ctx->eng.client_random, 32); 306 memcpy(ctx->eng.pad + 32, ctx->eng.server_random, 32); 307 ctx->eng.pad[64 + 0] = 0x03; 308 ctx->eng.pad[64 + 1] = 0x00; 309 ctx->eng.pad[64 + 2] = curve; 310 ctx->eng.pad[64 + 3] = ctx->eng.ecdhe_point_len; 311 memcpy(ctx->eng.pad + 64 + 4, 312 ctx->eng.ecdhe_point, ctx->eng.ecdhe_point_len); 313 hv_len = 64 + 4 + ctx->eng.ecdhe_point_len; 314 algo_id = ctx->sign_hash_id; 315 if (algo_id >= (unsigned)0xFF00) { 316 hv_len = hash_data(ctx, ctx->eng.pad, algo_id & 0xFF, 317 ctx->eng.pad, hv_len); 318 if (hv_len == 0) { 319 return -BR_ERR_INVALID_ALGORITHM; 320 } 321 } 322 323 sig_len = (*ctx->policy_vtable)->do_sign(ctx->policy_vtable, 324 algo_id, ctx->eng.pad, hv_len, sizeof ctx->eng.pad); 325 return sig_len ? (int)sig_len : -BR_ERR_INVALID_ALGORITHM; 326 } 327 328 /* 329 * Do the ECDHE key exchange (part 2: computation of the shared secret 330 * from the point sent by the client). 331 */ 332 static void 333 do_ecdhe_part2(br_ssl_server_context *ctx, int prf_id, 334 unsigned char *cpoint, size_t cpoint_len) 335 { 336 int curve; 337 uint32_t ctl; 338 size_t xoff, xlen; 339 340 curve = ctx->eng.ecdhe_curve; 341 342 /* 343 * Finalise the key exchange. 344 */ 345 ctl = ctx->eng.iec->mul(cpoint, cpoint_len, 346 ctx->ecdhe_key, ctx->ecdhe_key_len, curve); 347 xoff = ctx->eng.iec->xoff(curve, &xlen); 348 ecdh_common(ctx, prf_id, cpoint + xoff, xlen, ctl); 349 350 /* 351 * Clear the ECDHE private key. Forward Secrecy is achieved insofar 352 * as that key does not get stolen, so we'd better destroy it 353 * as soon as it ceases to be useful. 354 */ 355 memset(ctx->ecdhe_key, 0, ctx->ecdhe_key_len); 356 } 357 358 /* 359 * Offset for hash value within the pad (when obtaining all hash values, 360 * in preparation for verification of the CertificateVerify message). 361 * Order is MD5, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512; last value 362 * is used to get the total length. 363 */ 364 static const unsigned char HASH_PAD_OFF[] = { 0, 16, 36, 64, 96, 144, 208 }; 365 366 /* 367 * OID for hash functions in RSA signatures. 368 */ 369 static const unsigned char HASH_OID_SHA1[] = { 370 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A 371 }; 372 373 static const unsigned char HASH_OID_SHA224[] = { 374 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04 375 }; 376 377 static const unsigned char HASH_OID_SHA256[] = { 378 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01 379 }; 380 381 static const unsigned char HASH_OID_SHA384[] = { 382 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02 383 }; 384 385 static const unsigned char HASH_OID_SHA512[] = { 386 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03 387 }; 388 389 static const unsigned char *HASH_OID[] = { 390 HASH_OID_SHA1, 391 HASH_OID_SHA224, 392 HASH_OID_SHA256, 393 HASH_OID_SHA384, 394 HASH_OID_SHA512 395 }; 396 397 /* 398 * Verify the signature in CertificateVerify. Returned value is 0 on 399 * success, or a non-zero error code. Lack of implementation of the 400 * designated signature algorithm is reported as a "bad signature" 401 * error (because it means that the peer did not honour our advertised 402 * set of supported signature algorithms). 403 */ 404 static int 405 verify_CV_sig(br_ssl_server_context *ctx, size_t sig_len) 406 { 407 const br_x509_class **xc; 408 const br_x509_pkey *pk; 409 int id; 410 411 id = ctx->hash_CV_id; 412 xc = ctx->eng.x509ctx; 413 pk = (*xc)->get_pkey(xc, NULL); 414 if (pk->key_type == BR_KEYTYPE_RSA) { 415 unsigned char tmp[64]; 416 const unsigned char *hash_oid; 417 418 if (id == 0) { 419 hash_oid = NULL; 420 } else { 421 hash_oid = HASH_OID[id - 2]; 422 } 423 if (ctx->eng.irsavrfy == 0) { 424 return BR_ERR_BAD_SIGNATURE; 425 } 426 if (!ctx->eng.irsavrfy(ctx->eng.pad, sig_len, 427 hash_oid, ctx->hash_CV_len, &pk->key.rsa, tmp) 428 || memcmp(tmp, ctx->hash_CV, ctx->hash_CV_len) != 0) 429 { 430 return BR_ERR_BAD_SIGNATURE; 431 } 432 } else { 433 if (ctx->eng.iecdsa == 0) { 434 return BR_ERR_BAD_SIGNATURE; 435 } 436 if (!ctx->eng.iecdsa(ctx->eng.iec, 437 ctx->hash_CV, ctx->hash_CV_len, 438 &pk->key.ec, ctx->eng.pad, sig_len)) 439 { 440 return BR_ERR_BAD_SIGNATURE; 441 } 442 } 443 return 0; 444 } 445 446 447 448 static const unsigned char t0_datablock[] = { 449 0x00, 0x00, 0x0A, 0x00, 0x24, 0x00, 0x2F, 0x01, 0x24, 0x00, 0x35, 0x02, 450 0x24, 0x00, 0x3C, 0x01, 0x44, 0x00, 0x3D, 0x02, 0x44, 0x00, 0x9C, 0x03, 451 0x04, 0x00, 0x9D, 0x04, 0x05, 0xC0, 0x03, 0x40, 0x24, 0xC0, 0x04, 0x41, 452 0x24, 0xC0, 0x05, 0x42, 0x24, 0xC0, 0x08, 0x20, 0x24, 0xC0, 0x09, 0x21, 453 0x24, 0xC0, 0x0A, 0x22, 0x24, 0xC0, 0x0D, 0x30, 0x24, 0xC0, 0x0E, 0x31, 454 0x24, 0xC0, 0x0F, 0x32, 0x24, 0xC0, 0x12, 0x10, 0x24, 0xC0, 0x13, 0x11, 455 0x24, 0xC0, 0x14, 0x12, 0x24, 0xC0, 0x23, 0x21, 0x44, 0xC0, 0x24, 0x22, 456 0x55, 0xC0, 0x25, 0x41, 0x44, 0xC0, 0x26, 0x42, 0x55, 0xC0, 0x27, 0x11, 457 0x44, 0xC0, 0x28, 0x12, 0x55, 0xC0, 0x29, 0x31, 0x44, 0xC0, 0x2A, 0x32, 458 0x55, 0xC0, 0x2B, 0x23, 0x04, 0xC0, 0x2C, 0x24, 0x05, 0xC0, 0x2D, 0x43, 459 0x04, 0xC0, 0x2E, 0x44, 0x05, 0xC0, 0x2F, 0x13, 0x04, 0xC0, 0x30, 0x14, 460 0x05, 0xC0, 0x31, 0x33, 0x04, 0xC0, 0x32, 0x34, 0x05, 0xC0, 0x9C, 0x06, 461 0x04, 0xC0, 0x9D, 0x07, 0x04, 0xC0, 0xA0, 0x08, 0x04, 0xC0, 0xA1, 0x09, 462 0x04, 0xC0, 0xAC, 0x26, 0x04, 0xC0, 0xAD, 0x27, 0x04, 0xC0, 0xAE, 0x28, 463 0x04, 0xC0, 0xAF, 0x29, 0x04, 0xCC, 0xA8, 0x15, 0x04, 0xCC, 0xA9, 0x25, 464 0x04, 0x00, 0x00 465 }; 466 467 static const unsigned char t0_codeblock[] = { 468 0x00, 0x01, 0x00, 0x0B, 0x00, 0x00, 0x01, 0x00, 0x0E, 0x00, 0x00, 0x01, 469 0x00, 0x0F, 0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x01, 0x01, 0x08, 470 0x00, 0x00, 0x01, 0x01, 0x09, 0x00, 0x00, 0x01, 0x02, 0x08, 0x00, 0x00, 471 0x01, 0x02, 0x09, 0x00, 0x00, 0x29, 0x29, 0x00, 0x00, 0x01, 472 T0_INT1(BR_ERR_BAD_CCS), 0x00, 0x00, 0x01, 473 T0_INT1(BR_ERR_BAD_FINISHED), 0x00, 0x00, 0x01, 474 T0_INT1(BR_ERR_BAD_FRAGLEN), 0x00, 0x00, 0x01, 475 T0_INT1(BR_ERR_BAD_HANDSHAKE), 0x00, 0x00, 0x01, 476 T0_INT1(BR_ERR_BAD_PARAM), 0x00, 0x00, 0x01, 477 T0_INT1(BR_ERR_BAD_SECRENEG), 0x00, 0x00, 0x01, 478 T0_INT1(BR_ERR_BAD_SIGNATURE), 0x00, 0x00, 0x01, 479 T0_INT1(BR_ERR_BAD_VERSION), 0x00, 0x00, 0x01, 480 T0_INT1(BR_ERR_INVALID_ALGORITHM), 0x00, 0x00, 0x01, 481 T0_INT1(BR_ERR_LIMIT_EXCEEDED), 0x00, 0x00, 0x01, 482 T0_INT1(BR_ERR_NO_CLIENT_AUTH), 0x00, 0x00, 0x01, T0_INT1(BR_ERR_OK), 483 0x00, 0x00, 0x01, T0_INT1(BR_ERR_OVERSIZED_ID), 0x00, 0x00, 0x01, 484 T0_INT1(BR_ERR_UNEXPECTED), 0x00, 0x00, 0x01, 485 T0_INT1(BR_ERR_WRONG_KEY_USAGE), 0x00, 0x00, 0x01, 486 T0_INT2(offsetof(br_ssl_engine_context, action)), 0x00, 0x00, 0x01, 487 T0_INT2(offsetof(br_ssl_engine_context, alert)), 0x00, 0x00, 0x01, 488 T0_INT2(offsetof(br_ssl_engine_context, application_data)), 0x00, 0x00, 489 0x01, 490 T0_INT2(offsetof(br_ssl_engine_context, session) + offsetof(br_ssl_session_parameters, cipher_suite)), 491 0x00, 0x00, 0x01, 492 T0_INT2(offsetof(br_ssl_server_context, client_max_version)), 0x00, 493 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, client_random)), 494 0x00, 0x00, 0x01, 495 T0_INT2(offsetof(br_ssl_server_context, client_suites)), 0x00, 0x00, 496 0x01, T0_INT2(offsetof(br_ssl_server_context, client_suites_num)), 497 0x00, 0x00, 0x01, 498 T0_INT2(offsetof(br_ssl_engine_context, close_received)), 0x00, 0x00, 499 0x01, T0_INT2(offsetof(br_ssl_server_context, curves)), 0x00, 0x00, 500 0x01, T0_INT2(offsetof(br_ssl_engine_context, ecdhe_point)), 0x00, 501 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, ecdhe_point_len)), 502 0x00, 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, flags)), 503 0x00, 0x00, 0x01, T0_INT2(offsetof(br_ssl_server_context, hashes)), 504 0x00, 0x00, 0x7B, 0x01, 505 T0_INT2(BR_MAX_CIPHER_SUITES * sizeof(br_suite_translated)), 0x00, 506 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, log_max_frag_len)), 507 0x00, 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, pad)), 0x00, 508 0x00, 0x01, 509 T0_INT2(offsetof(br_ssl_engine_context, peer_log_max_frag_len)), 0x00, 510 0x00, 0x01, 511 T0_INT2(offsetof(br_ssl_engine_context, protocol_names_num)), 0x00, 512 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, record_type_in)), 513 0x00, 0x00, 0x01, 514 T0_INT2(offsetof(br_ssl_engine_context, record_type_out)), 0x00, 0x00, 515 0x01, T0_INT2(offsetof(br_ssl_engine_context, reneg)), 0x00, 0x00, 516 0x01, T0_INT2(offsetof(br_ssl_engine_context, saved_finished)), 0x00, 517 0x00, 0x01, 518 T0_INT2(offsetof(br_ssl_engine_context, selected_protocol)), 0x00, 519 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, server_name)), 520 0x00, 0x00, 0x01, 521 T0_INT2(offsetof(br_ssl_engine_context, server_random)), 0x00, 0x00, 522 0x01, 523 T0_INT2(offsetof(br_ssl_engine_context, session) + offsetof(br_ssl_session_parameters, session_id)), 524 0x00, 0x00, 0x01, 525 T0_INT2(offsetof(br_ssl_engine_context, session) + offsetof(br_ssl_session_parameters, session_id_len)), 526 0x00, 0x00, 0x01, 527 T0_INT2(offsetof(br_ssl_engine_context, shutdown_recv)), 0x00, 0x00, 528 0x01, T0_INT2(offsetof(br_ssl_server_context, sign_hash_id)), 0x00, 529 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, suites_buf)), 0x00, 530 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, suites_num)), 0x00, 531 0x00, 0x01, 532 T0_INT2(offsetof(br_ssl_engine_context, session) + offsetof(br_ssl_session_parameters, version)), 533 0x00, 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, version_in)), 534 0x00, 0x00, 0x01, 535 T0_INT2(offsetof(br_ssl_engine_context, version_max)), 0x00, 0x00, 536 0x01, T0_INT2(offsetof(br_ssl_engine_context, version_min)), 0x00, 537 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, version_out)), 538 0x00, 0x00, 0x09, 0x2A, 0x5D, 0x06, 0x02, 0x6A, 0x2B, 0x00, 0x00, 0x01, 539 0x01, 0x00, 0x01, 0x03, 0x00, 0x9B, 0x2A, 0x63, 0x47, 0x9F, 0x2A, 0x05, 540 0x04, 0x65, 0x01, 0x00, 0x00, 0x02, 0x00, 0x0F, 0x06, 0x02, 0x9F, 0x00, 541 0x63, 0x04, 0x6B, 0x00, 0x06, 0x02, 0x6A, 0x2B, 0x00, 0x00, 0x2A, 0x8B, 542 0x47, 0x05, 0x03, 0x01, 0x0C, 0x08, 0x47, 0x78, 0x2E, 0xA8, 0x1C, 0x85, 543 0x01, 0x0C, 0x33, 0x00, 0x00, 0x2A, 0x22, 0x01, 0x08, 0x0C, 0x47, 0x61, 544 0x22, 0x08, 0x00, 0x01, 0x03, 0x00, 0x77, 0x30, 0x02, 0x00, 0x38, 0x13, 545 0x01, 0x01, 0x0C, 0x77, 0x42, 0x2C, 0x19, 0x38, 0x06, 0x07, 0x02, 0x00, 546 0xD0, 0x03, 0x00, 0x04, 0x75, 0x01, 0x00, 0xC7, 0x02, 0x00, 0x2A, 0x19, 547 0x13, 0x06, 0x02, 0x71, 0x2B, 0xD0, 0x04, 0x76, 0x00, 0x01, 0x00, 0x77, 548 0x42, 0x01, 0x16, 0x89, 0x42, 0x01, 0x00, 0x8C, 0x40, 0x36, 0xB1, 0x35, 549 0x06, 0x02, 0x73, 0x2B, 0x06, 0x0A, 0xD7, 0x01, 0x00, 0xD3, 0x01, 0x00, 550 0xAD, 0x04, 0x80, 0x46, 0xD7, 0xD4, 0x29, 0xD9, 0x50, 0x06, 0x01, 0xD5, 551 0xD8, 0x2C, 0x50, 0x06, 0x31, 0x01, 0x00, 0xAE, 0x2A, 0x5D, 0x06, 0x0F, 552 0x01, 0x02, 0xA4, 0x05, 0x02, 0x37, 0x2B, 0x29, 0xB2, 0xB0, 0x2A, 0xC9, 553 0x29, 0x04, 0x19, 0x2A, 0x5F, 0x06, 0x0B, 0x29, 0x01, 0x02, 0xA4, 0x05, 554 0x02, 0x70, 0x2B, 0xB2, 0x04, 0x0A, 0xB4, 0x2A, 0x05, 0x04, 0x29, 0xAB, 555 0x04, 0x02, 0xB3, 0xAF, 0x04, 0x01, 0xB2, 0x01, 0x00, 0xAD, 0x01, 0x00, 556 0xD3, 0x3E, 0x01, 0x01, 0x77, 0x42, 0x01, 0x17, 0x89, 0x42, 0x00, 0x00, 557 0x3A, 0x3A, 0x00, 0x01, 0x03, 0x00, 0x2C, 0x19, 0x38, 0x06, 0x04, 0xCF, 558 0x29, 0x04, 0x78, 0x01, 0x02, 0x02, 0x00, 0xC6, 0x19, 0x38, 0x06, 0x04, 559 0xCF, 0x29, 0x04, 0x78, 0x02, 0x00, 0x01, 0x84, 0x00, 0x08, 0x2B, 0x00, 560 0x00, 0x81, 0x2F, 0x47, 0x12, 0x01, 0x01, 0x13, 0x37, 0x00, 0x00, 0x2A, 561 0x05, 0x04, 0x29, 0x01, 0x7F, 0x00, 0x01, 0x00, 0xA2, 0x12, 0x01, 0x01, 562 0x13, 0x5F, 0x06, 0x03, 0x61, 0x04, 0x75, 0x47, 0x29, 0x00, 0x00, 0x01, 563 0x7F, 0xA1, 0xCF, 0x2A, 0x01, 0x07, 0x13, 0x01, 0x00, 0x3A, 0x0F, 0x06, 564 0x0D, 0x29, 0x01, 0x10, 0x13, 0x06, 0x05, 0x01, 0x00, 0x77, 0x42, 0xC5, 565 0x04, 0x33, 0x01, 0x01, 0x3A, 0x0F, 0x06, 0x2A, 0x29, 0x29, 0x8A, 0x30, 566 0x01, 0x01, 0x0F, 0x01, 0x01, 0xA4, 0x39, 0x06, 0x18, 0xC8, 0x2C, 0x19, 567 0x38, 0x06, 0x04, 0xCF, 0x29, 0x04, 0x78, 0x01, 0x80, 0x64, 0xC7, 0x01, 568 0x01, 0x77, 0x42, 0x01, 0x17, 0x89, 0x42, 0x04, 0x03, 0x01, 0x00, 0xA1, 569 0x04, 0x03, 0x73, 0x2B, 0x29, 0x04, 0xFF, 0x32, 0x01, 0x2A, 0x03, 0x00, 570 0x09, 0x2A, 0x5D, 0x06, 0x02, 0x6A, 0x2B, 0x02, 0x00, 0x00, 0x00, 0x9C, 571 0x01, 0x0F, 0x13, 0x00, 0x00, 0x76, 0x30, 0x01, 0x00, 0x3A, 0x0F, 0x06, 572 0x10, 0x29, 0x2A, 0x01, 0x01, 0x0E, 0x06, 0x03, 0x29, 0x01, 0x02, 0x76, 573 0x42, 0x01, 0x00, 0x04, 0x21, 0x01, 0x01, 0x3A, 0x0F, 0x06, 0x14, 0x29, 574 0x01, 0x00, 0x76, 0x42, 0x2A, 0x01, 0x80, 0x64, 0x0F, 0x06, 0x05, 0x01, 575 0x82, 0x00, 0x08, 0x2B, 0x5F, 0x04, 0x07, 0x29, 0x01, 0x82, 0x00, 0x08, 576 0x2B, 0x29, 0x00, 0x00, 0x01, 0x00, 0x31, 0x06, 0x05, 0x3D, 0xA9, 0x39, 577 0x04, 0x78, 0x2A, 0x06, 0x04, 0x01, 0x01, 0x91, 0x42, 0x00, 0x00, 0x01, 578 0x1F, 0x13, 0x01, 0x12, 0x0F, 0x05, 0x02, 0x74, 0x2B, 0x78, 0x2E, 0x2A, 579 0xCB, 0x05, 0x02, 0x73, 0x2B, 0xA8, 0x28, 0x00, 0x02, 0x87, 0x2E, 0x05, 580 0x02, 0xBC, 0x00, 0xC0, 0xA7, 0xC0, 0xA7, 0x01, 0x7E, 0x03, 0x00, 0x2A, 581 0x06, 0x17, 0xC2, 0x2A, 0x03, 0x01, 0x85, 0x47, 0xB6, 0x02, 0x01, 0x51, 582 0x2A, 0x02, 0x00, 0x53, 0x06, 0x04, 0x03, 0x00, 0x04, 0x01, 0x29, 0x04, 583 0x66, 0x9D, 0x9D, 0x02, 0x00, 0x61, 0x8C, 0x40, 0x00, 0x00, 0x31, 0x06, 584 0x0B, 0x88, 0x30, 0x01, 0x14, 0x0E, 0x06, 0x02, 0x73, 0x2B, 0x04, 0x11, 585 0xCF, 0x01, 0x07, 0x13, 0x2A, 0x01, 0x02, 0x0E, 0x06, 0x06, 0x06, 0x02, 586 0x73, 0x2B, 0x04, 0x70, 0x29, 0xC3, 0x01, 0x01, 0x0E, 0x35, 0x39, 0x06, 587 0x02, 0x66, 0x2B, 0x2A, 0x01, 0x01, 0xCA, 0x38, 0xB5, 0x00, 0x01, 0xBA, 588 0x01, 0x0B, 0x0F, 0x05, 0x02, 0x73, 0x2B, 0x2A, 0x01, 0x03, 0x0F, 0x06, 589 0x08, 0xC1, 0x06, 0x02, 0x6A, 0x2B, 0x47, 0x29, 0x00, 0x47, 0x5C, 0xC1, 590 0xA7, 0x2A, 0x06, 0x23, 0xC1, 0xA7, 0x2A, 0x5B, 0x2A, 0x06, 0x18, 0x2A, 591 0x01, 0x82, 0x00, 0x10, 0x06, 0x05, 0x01, 0x82, 0x00, 0x04, 0x01, 0x2A, 592 0x03, 0x00, 0x85, 0x02, 0x00, 0xB6, 0x02, 0x00, 0x58, 0x04, 0x65, 0x9D, 593 0x59, 0x04, 0x5A, 0x9D, 0x9D, 0x5A, 0x2A, 0x06, 0x02, 0x37, 0x00, 0x29, 594 0x2D, 0x00, 0x02, 0x2A, 0x01, 0x20, 0x13, 0x05, 0x02, 0x74, 0x2B, 0x01, 595 0x0F, 0x13, 0x03, 0x00, 0xB0, 0x95, 0x2E, 0x01, 0x86, 0x03, 0x11, 0x06, 596 0x23, 0xC0, 0x2A, 0x01, 0x81, 0x7F, 0x13, 0x61, 0x01, 0x01, 0x12, 0x02, 597 0x00, 0x0F, 0x05, 0x02, 0x6C, 0x2B, 0x01, 0x08, 0x12, 0x2A, 0x01, 0x02, 598 0x0B, 0x3A, 0x01, 0x06, 0x10, 0x39, 0x06, 0x02, 0x6E, 0x2B, 0x04, 0x0D, 599 0x02, 0x00, 0x01, 0x01, 0x0F, 0x06, 0x04, 0x01, 0x00, 0x04, 0x02, 0x01, 600 0x02, 0x20, 0x05, 0x02, 0x6E, 0x2B, 0xC0, 0x2A, 0x03, 0x01, 0x2A, 0x01, 601 0x84, 0x00, 0x10, 0x06, 0x02, 0x6F, 0x2B, 0x85, 0x47, 0xB6, 0x02, 0x01, 602 0x55, 0x2A, 0x06, 0x01, 0x2B, 0x29, 0x9D, 0x00, 0x00, 0x1D, 0xBA, 0x01, 603 0x0F, 0x0F, 0x05, 0x02, 0x73, 0x2B, 0x00, 0x0A, 0xBA, 0x01, 0x01, 0x0F, 604 0x05, 0x02, 0x73, 0x2B, 0xC0, 0x2A, 0x03, 0x00, 0x79, 0x40, 0x7A, 0x01, 605 0x20, 0xB6, 0xC2, 0x2A, 0x01, 0x20, 0x10, 0x06, 0x02, 0x72, 0x2B, 0x2A, 606 0x90, 0x42, 0x8F, 0x47, 0xB6, 0x1A, 0x03, 0x01, 0xC0, 0xA7, 0x01, 0x00, 607 0x03, 0x02, 0x01, 0x00, 0x03, 0x03, 0x83, 0xA2, 0x17, 0x3A, 0x08, 0x03, 608 0x04, 0x03, 0x05, 0x2A, 0x06, 0x80, 0x6D, 0xC0, 0x2A, 0x03, 0x06, 0x02, 609 0x01, 0x06, 0x0A, 0x2A, 0x78, 0x2E, 0x0F, 0x06, 0x04, 0x01, 0x7F, 0x03, 610 0x03, 0x2A, 0x01, 0x81, 0x7F, 0x0F, 0x06, 0x0A, 0x8A, 0x30, 0x06, 0x02, 611 0x6B, 0x2B, 0x01, 0x7F, 0x03, 0x02, 0x2A, 0x01, 0x81, 0xAC, 0x00, 0x0F, 612 0x06, 0x11, 0x02, 0x00, 0x98, 0x2E, 0x11, 0x02, 0x00, 0x97, 0x2E, 0x0B, 613 0x13, 0x06, 0x04, 0x01, 0x7F, 0x03, 0x00, 0xC4, 0x2A, 0x5D, 0x06, 0x03, 614 0x29, 0x04, 0x26, 0x01, 0x00, 0xA4, 0x06, 0x0B, 0x01, 0x02, 0x0C, 0x7B, 615 0x08, 0x02, 0x06, 0x47, 0x40, 0x04, 0x16, 0x29, 0x02, 0x05, 0x02, 0x04, 616 0x11, 0x06, 0x02, 0x69, 0x2B, 0x02, 0x06, 0x02, 0x05, 0x40, 0x02, 0x05, 617 0x01, 0x04, 0x08, 0x03, 0x05, 0x04, 0xFF, 0x0F, 0x29, 0x01, 0x00, 0x03, 618 0x07, 0xC2, 0xA7, 0x2A, 0x06, 0x09, 0xC2, 0x05, 0x04, 0x01, 0x7F, 0x03, 619 0x07, 0x04, 0x74, 0x9D, 0x01, 0x00, 0x8D, 0x42, 0x01, 0x88, 0x04, 0x82, 620 0x41, 0x01, 0x84, 0x80, 0x80, 0x00, 0x7E, 0x41, 0x2A, 0x06, 0x80, 0x4E, 621 0xC0, 0xA7, 0x2A, 0x06, 0x80, 0x47, 0xC0, 0x01, 0x00, 0x3A, 0x0F, 0x06, 622 0x04, 0x29, 0xB9, 0x04, 0x39, 0x01, 0x01, 0x3A, 0x0F, 0x06, 0x04, 0x29, 623 0xB7, 0x04, 0x2F, 0x01, 0x83, 0xFE, 0x01, 0x3A, 0x0F, 0x06, 0x04, 0x29, 624 0xB8, 0x04, 0x23, 0x01, 0x0D, 0x3A, 0x0F, 0x06, 0x04, 0x29, 0xBE, 0x04, 625 0x19, 0x01, 0x0A, 0x3A, 0x0F, 0x06, 0x04, 0x29, 0xBF, 0x04, 0x0F, 0x01, 626 0x10, 0x3A, 0x0F, 0x06, 0x04, 0x29, 0xAC, 0x04, 0x05, 0x29, 0xBC, 0x01, 627 0x00, 0x29, 0x04, 0xFF, 0x35, 0x9D, 0x9D, 0x02, 0x01, 0x02, 0x03, 0x13, 628 0x03, 0x01, 0x02, 0x00, 0x5D, 0x06, 0x08, 0x79, 0x2E, 0x99, 0x40, 0x01, 629 0x80, 0x56, 0xA3, 0x97, 0x2E, 0x2A, 0x02, 0x00, 0x10, 0x06, 0x03, 0x29, 630 0x02, 0x00, 0x2A, 0x01, 0x86, 0x00, 0x0B, 0x06, 0x02, 0x6D, 0x2B, 0x02, 631 0x00, 0x98, 0x2E, 0x0B, 0x06, 0x04, 0x01, 0x80, 0x46, 0xA3, 0x02, 0x01, 632 0x06, 0x10, 0x95, 0x2E, 0x02, 0x00, 0x0D, 0x06, 0x05, 0x29, 0x95, 0x2E, 633 0x04, 0x04, 0x01, 0x00, 0x03, 0x01, 0x2A, 0x95, 0x40, 0x2A, 0x96, 0x40, 634 0x2A, 0x99, 0x40, 0x01, 0x86, 0x03, 0x11, 0x03, 0x08, 0x02, 0x02, 0x06, 635 0x04, 0x01, 0x02, 0x8A, 0x42, 0x8A, 0x30, 0x05, 0x04, 0x01, 0x01, 0x8A, 636 0x42, 0x02, 0x07, 0x05, 0x03, 0x01, 0x28, 0xA3, 0x44, 0x29, 0x01, 0x82, 637 0x01, 0x07, 0x01, 0xFC, 0x80, 0x00, 0x39, 0x82, 0x2F, 0x13, 0x2A, 0x82, 638 0x41, 0x2A, 0x01, 0x81, 0x7F, 0x13, 0x5E, 0x37, 0x47, 0x01, 0x08, 0x12, 639 0x5E, 0x01, 0x02, 0x13, 0x39, 0x01, 0x0C, 0x0C, 0x03, 0x09, 0x7E, 0x2F, 640 0x43, 0x13, 0x2A, 0x7E, 0x41, 0x05, 0x04, 0x01, 0x00, 0x03, 0x09, 0x02, 641 0x01, 0x06, 0x03, 0x01, 0x7F, 0x00, 0x8F, 0x01, 0x20, 0x34, 0x01, 0x20, 642 0x90, 0x42, 0x7B, 0x2A, 0x03, 0x05, 0x2A, 0x02, 0x04, 0x0B, 0x06, 0x80, 643 0x49, 0x2A, 0x2E, 0x2A, 0x9C, 0x2A, 0x01, 0x0C, 0x12, 0x2A, 0x01, 0x01, 644 0x0F, 0x47, 0x01, 0x02, 0x0F, 0x39, 0x06, 0x0A, 0x2A, 0x02, 0x09, 0x13, 645 0x05, 0x04, 0x65, 0x01, 0x00, 0x2A, 0x02, 0x08, 0x05, 0x0E, 0x2A, 0x01, 646 0x81, 0x70, 0x13, 0x01, 0x20, 0x0E, 0x06, 0x04, 0x65, 0x01, 0x00, 0x2A, 647 0x2A, 0x06, 0x10, 0x02, 0x05, 0x63, 0x40, 0x02, 0x05, 0x40, 0x02, 0x05, 648 0x01, 0x04, 0x08, 0x03, 0x05, 0x04, 0x01, 0x65, 0x01, 0x04, 0x08, 0x04, 649 0xFF, 0x30, 0x29, 0x02, 0x05, 0x7B, 0x09, 0x01, 0x02, 0x12, 0x2A, 0x05, 650 0x03, 0x01, 0x28, 0xA3, 0x7C, 0x42, 0x8C, 0x2E, 0x01, 0x83, 0xFF, 0x7F, 651 0x0F, 0x06, 0x0D, 0x01, 0x03, 0xA4, 0x06, 0x04, 0x01, 0x80, 0x78, 0xA3, 652 0x01, 0x00, 0x8C, 0x40, 0x18, 0x05, 0x03, 0x01, 0x28, 0xA3, 0x01, 0x00, 653 0x00, 0x00, 0xB4, 0xB3, 0x00, 0x04, 0x78, 0x2E, 0xCE, 0x06, 0x16, 0xC0, 654 0x2A, 0x01, 0x84, 0x00, 0x10, 0x06, 0x02, 0x6F, 0x2B, 0x2A, 0x03, 0x00, 655 0x85, 0x47, 0xB6, 0x02, 0x00, 0x78, 0x2E, 0xA8, 0x27, 0x78, 0x2E, 0x2A, 656 0xCC, 0x47, 0xCB, 0x03, 0x01, 0x03, 0x02, 0x02, 0x01, 0x02, 0x02, 0x39, 657 0x06, 0x14, 0xC2, 0x2A, 0x03, 0x03, 0x85, 0x47, 0xB6, 0x02, 0x03, 0x78, 658 0x2E, 0xA8, 0x02, 0x02, 0x06, 0x03, 0x26, 0x04, 0x01, 0x24, 0x9D, 0x00, 659 0x00, 0xBA, 0x01, 0x10, 0x0F, 0x05, 0x02, 0x73, 0x2B, 0x00, 0x00, 0x9E, 660 0xBA, 0x01, 0x14, 0x0E, 0x06, 0x02, 0x73, 0x2B, 0x85, 0x01, 0x0C, 0x08, 661 0x01, 0x0C, 0xB6, 0x9D, 0x85, 0x2A, 0x01, 0x0C, 0x08, 0x01, 0x0C, 0x32, 662 0x05, 0x02, 0x67, 0x2B, 0x00, 0x02, 0x03, 0x00, 0x03, 0x01, 0x02, 0x00, 663 0x9A, 0x02, 0x01, 0x02, 0x00, 0x3C, 0x2A, 0x01, 0x00, 0x0F, 0x06, 0x02, 664 0x65, 0x00, 0xD1, 0x04, 0x74, 0x00, 0xC0, 0x01, 0x01, 0x0E, 0x06, 0x02, 665 0x68, 0x2B, 0xC2, 0x2A, 0x2A, 0x5F, 0x47, 0x01, 0x05, 0x11, 0x39, 0x06, 666 0x02, 0x68, 0x2B, 0x01, 0x08, 0x08, 0x2A, 0x84, 0x30, 0x0B, 0x06, 0x0D, 667 0x2A, 0x01, 0x01, 0x47, 0x0C, 0x3F, 0x2A, 0x84, 0x42, 0x86, 0x42, 0x04, 668 0x01, 0x29, 0x00, 0x00, 0xC0, 0x8A, 0x30, 0x01, 0x00, 0x3A, 0x0F, 0x06, 669 0x13, 0x29, 0x01, 0x01, 0x0F, 0x05, 0x02, 0x6B, 0x2B, 0xC2, 0x06, 0x02, 670 0x6B, 0x2B, 0x01, 0x02, 0x8A, 0x42, 0x04, 0x28, 0x01, 0x02, 0x3A, 0x0F, 671 0x06, 0x1F, 0x29, 0x01, 0x0D, 0x0F, 0x05, 0x02, 0x6B, 0x2B, 0xC2, 0x01, 672 0x0C, 0x0F, 0x05, 0x02, 0x6B, 0x2B, 0x85, 0x01, 0x0C, 0xB6, 0x8B, 0x85, 673 0x01, 0x0C, 0x32, 0x05, 0x02, 0x6B, 0x2B, 0x04, 0x03, 0x6B, 0x2B, 0x29, 674 0x00, 0x00, 0xC0, 0xA7, 0xC0, 0xA7, 0x2A, 0x06, 0x1D, 0xC2, 0x06, 0x03, 675 0xBC, 0x04, 0x15, 0xC0, 0x2A, 0x01, 0x81, 0x7F, 0x0D, 0x06, 0x0C, 0x2A, 676 0x8D, 0x08, 0x01, 0x00, 0x47, 0x42, 0x8D, 0x47, 0xB6, 0x04, 0x01, 0xC9, 677 0x04, 0x60, 0x9D, 0x9D, 0x00, 0x00, 0xBB, 0x2A, 0x5F, 0x06, 0x07, 0x29, 678 0x06, 0x02, 0x69, 0x2B, 0x04, 0x74, 0x00, 0x00, 0xC3, 0x01, 0x03, 0xC1, 679 0x47, 0x29, 0x47, 0x00, 0x00, 0xC0, 0xC9, 0x00, 0x03, 0x01, 0x00, 0x03, 680 0x00, 0xC0, 0xA7, 0x2A, 0x06, 0x80, 0x50, 0xC2, 0x03, 0x01, 0xC2, 0x03, 681 0x02, 0x02, 0x01, 0x01, 0x08, 0x0F, 0x06, 0x16, 0x02, 0x02, 0x01, 0x0F, 682 0x0D, 0x06, 0x0D, 0x01, 0x01, 0x02, 0x02, 0x01, 0x10, 0x08, 0x0C, 0x02, 683 0x00, 0x39, 0x03, 0x00, 0x04, 0x2A, 0x02, 0x01, 0x01, 0x02, 0x11, 0x02, 684 0x01, 0x01, 0x06, 0x0D, 0x13, 0x02, 0x02, 0x01, 0x01, 0x0F, 0x02, 0x02, 685 0x01, 0x03, 0x0F, 0x39, 0x13, 0x06, 0x11, 0x02, 0x00, 0x01, 0x01, 0x02, 686 0x02, 0x62, 0x01, 0x02, 0x0C, 0x02, 0x01, 0x08, 0x0C, 0x39, 0x03, 0x00, 687 0x04, 0xFF, 0x2C, 0x9D, 0x02, 0x00, 0x00, 0x00, 0xC0, 0xA7, 0xBD, 0x82, 688 0x41, 0x9D, 0x00, 0x00, 0xC0, 0xA7, 0xC0, 0xA7, 0x01, 0x00, 0x7E, 0x41, 689 0x2A, 0x06, 0x15, 0xC0, 0x2A, 0x01, 0x20, 0x0B, 0x06, 0x0B, 0x01, 0x01, 690 0x47, 0x0C, 0x7E, 0x2F, 0x39, 0x7E, 0x41, 0x04, 0x01, 0x29, 0x04, 0x68, 691 0x9D, 0x9D, 0x00, 0x00, 0x01, 0x02, 0x9A, 0xC3, 0x01, 0x08, 0x0C, 0xC3, 692 0x08, 0x00, 0x00, 0x01, 0x03, 0x9A, 0xC3, 0x01, 0x08, 0x0C, 0xC3, 0x08, 693 0x01, 0x08, 0x0C, 0xC3, 0x08, 0x00, 0x00, 0x01, 0x01, 0x9A, 0xC3, 0x00, 694 0x00, 0x3D, 0x2A, 0x5D, 0x05, 0x01, 0x00, 0x29, 0xD1, 0x04, 0x76, 0x02, 695 0x03, 0x00, 0x94, 0x30, 0x03, 0x01, 0x01, 0x00, 0x2A, 0x02, 0x01, 0x0B, 696 0x06, 0x10, 0x2A, 0x01, 0x01, 0x0C, 0x93, 0x08, 0x2E, 0x02, 0x00, 0x0F, 697 0x06, 0x01, 0x00, 0x61, 0x04, 0x6A, 0x29, 0x01, 0x7F, 0x00, 0x00, 0x2C, 698 0x19, 0x38, 0x06, 0x04, 0xCF, 0x29, 0x04, 0x78, 0x01, 0x16, 0x89, 0x42, 699 0x01, 0x00, 0xE2, 0x01, 0x00, 0xE1, 0x2C, 0x01, 0x17, 0x89, 0x42, 0x00, 700 0x00, 0x01, 0x15, 0x89, 0x42, 0x47, 0x57, 0x29, 0x57, 0x29, 0x2C, 0x00, 701 0x00, 0x01, 0x01, 0x47, 0xC6, 0x00, 0x00, 0xBB, 0x01, 0x01, 0x0F, 0x05, 702 0x02, 0x73, 0x2B, 0x2A, 0xC9, 0x29, 0x00, 0x00, 0x47, 0x3A, 0x9A, 0x47, 703 0x2A, 0x06, 0x05, 0xC3, 0x29, 0x62, 0x04, 0x78, 0x29, 0x00, 0x02, 0x03, 704 0x00, 0x78, 0x2E, 0x9C, 0x03, 0x01, 0x02, 0x01, 0x01, 0x0F, 0x13, 0x02, 705 0x01, 0x01, 0x04, 0x12, 0x01, 0x0F, 0x13, 0x02, 0x01, 0x01, 0x08, 0x12, 706 0x01, 0x0F, 0x13, 0x01, 0x00, 0x3A, 0x0F, 0x06, 0x10, 0x29, 0x01, 0x00, 707 0x01, 0x18, 0x02, 0x00, 0x06, 0x03, 0x4C, 0x04, 0x01, 0x4D, 0x04, 0x81, 708 0x0D, 0x01, 0x01, 0x3A, 0x0F, 0x06, 0x10, 0x29, 0x01, 0x01, 0x01, 0x10, 709 0x02, 0x00, 0x06, 0x03, 0x4C, 0x04, 0x01, 0x4D, 0x04, 0x80, 0x77, 0x01, 710 0x02, 0x3A, 0x0F, 0x06, 0x10, 0x29, 0x01, 0x01, 0x01, 0x20, 0x02, 0x00, 711 0x06, 0x03, 0x4C, 0x04, 0x01, 0x4D, 0x04, 0x80, 0x61, 0x01, 0x03, 0x3A, 712 0x0F, 0x06, 0x0F, 0x29, 0x29, 0x01, 0x10, 0x02, 0x00, 0x06, 0x03, 0x4A, 713 0x04, 0x01, 0x4B, 0x04, 0x80, 0x4C, 0x01, 0x04, 0x3A, 0x0F, 0x06, 0x0E, 714 0x29, 0x29, 0x01, 0x20, 0x02, 0x00, 0x06, 0x03, 0x4A, 0x04, 0x01, 0x4B, 715 0x04, 0x38, 0x01, 0x05, 0x3A, 0x0F, 0x06, 0x0C, 0x29, 0x29, 0x02, 0x00, 716 0x06, 0x03, 0x4E, 0x04, 0x01, 0x4F, 0x04, 0x26, 0x2A, 0x01, 0x09, 0x10, 717 0x06, 0x02, 0x6A, 0x2B, 0x47, 0x29, 0x2A, 0x01, 0x01, 0x13, 0x01, 0x04, 718 0x0C, 0x01, 0x10, 0x08, 0x47, 0x01, 0x08, 0x13, 0x01, 0x10, 0x47, 0x09, 719 0x02, 0x00, 0x06, 0x03, 0x48, 0x04, 0x01, 0x49, 0x00, 0x29, 0x00, 0x00, 720 0x9C, 0x01, 0x0C, 0x12, 0x01, 0x02, 0x10, 0x00, 0x00, 0x9C, 0x01, 0x0C, 721 0x12, 0x2A, 0x60, 0x47, 0x01, 0x03, 0x0B, 0x13, 0x00, 0x00, 0x9C, 0x01, 722 0x0C, 0x12, 0x01, 0x01, 0x0F, 0x00, 0x00, 0x9C, 0x01, 0x0C, 0x12, 0x5F, 723 0x00, 0x00, 0x1B, 0x01, 0x00, 0x75, 0x30, 0x2A, 0x06, 0x22, 0x01, 0x01, 724 0x3A, 0x0F, 0x06, 0x06, 0x29, 0x01, 0x00, 0xA0, 0x04, 0x14, 0x01, 0x02, 725 0x3A, 0x0F, 0x06, 0x0D, 0x29, 0x77, 0x30, 0x01, 0x01, 0x0F, 0x06, 0x03, 726 0x01, 0x10, 0x39, 0x04, 0x01, 0x29, 0x04, 0x01, 0x29, 0x7D, 0x30, 0x05, 727 0x33, 0x31, 0x06, 0x30, 0x88, 0x30, 0x01, 0x14, 0x3A, 0x0F, 0x06, 0x06, 728 0x29, 0x01, 0x02, 0x39, 0x04, 0x22, 0x01, 0x15, 0x3A, 0x0F, 0x06, 0x09, 729 0x29, 0xAA, 0x06, 0x03, 0x01, 0x7F, 0xA0, 0x04, 0x13, 0x01, 0x16, 0x3A, 730 0x0F, 0x06, 0x06, 0x29, 0x01, 0x01, 0x39, 0x04, 0x07, 0x29, 0x01, 0x04, 731 0x39, 0x01, 0x00, 0x29, 0x19, 0x06, 0x03, 0x01, 0x08, 0x39, 0x00, 0x00, 732 0x1B, 0x2A, 0x05, 0x13, 0x31, 0x06, 0x10, 0x88, 0x30, 0x01, 0x15, 0x0F, 733 0x06, 0x08, 0x29, 0xAA, 0x01, 0x00, 0x77, 0x42, 0x04, 0x01, 0x23, 0x00, 734 0x00, 0xCF, 0x01, 0x07, 0x13, 0x01, 0x01, 0x10, 0x06, 0x02, 0x73, 0x2B, 735 0x00, 0x01, 0x03, 0x00, 0x2C, 0x19, 0x06, 0x05, 0x02, 0x00, 0x89, 0x42, 736 0x00, 0xCF, 0x29, 0x04, 0x74, 0x00, 0x01, 0x14, 0xD2, 0x01, 0x01, 0xE2, 737 0x2C, 0x2A, 0x01, 0x00, 0xCA, 0x01, 0x16, 0xD2, 0xD6, 0x2C, 0x00, 0x00, 738 0x01, 0x0B, 0xE2, 0x52, 0x2A, 0x2A, 0x01, 0x03, 0x08, 0xE1, 0xE1, 0x14, 739 0x2A, 0x5D, 0x06, 0x02, 0x29, 0x00, 0xE1, 0x1E, 0x2A, 0x06, 0x05, 0x85, 740 0x47, 0xDA, 0x04, 0x77, 0x29, 0x04, 0x6C, 0x00, 0x01, 0x00, 0xDC, 0x95, 741 0x2E, 0x01, 0x86, 0x03, 0x11, 0x06, 0x05, 0x63, 0x01, 0x00, 0xDD, 0x08, 742 0x50, 0x08, 0x01, 0x03, 0x08, 0x01, 0x0D, 0xE2, 0xE1, 0x01, 0x00, 0xDC, 743 0xE2, 0x01, 0x01, 0xDC, 0x29, 0x95, 0x2E, 0x01, 0x86, 0x03, 0x11, 0x06, 744 0x08, 0x01, 0x00, 0xDD, 0xE0, 0x01, 0x01, 0xDD, 0x29, 0x50, 0xE0, 0x16, 745 0x15, 0x2A, 0x5D, 0x06, 0x02, 0x29, 0x00, 0xE0, 0x1F, 0x2A, 0x06, 0x05, 746 0x85, 0x47, 0xDA, 0x04, 0x77, 0x29, 0x04, 0x6C, 0x00, 0x9E, 0x01, 0x14, 747 0xE2, 0x01, 0x0C, 0xE1, 0x85, 0x01, 0x0C, 0xDA, 0x00, 0x04, 0x03, 0x00, 748 0x01, 0x02, 0xE2, 0x01, 0x80, 0x46, 0x8A, 0x30, 0x01, 0x02, 0x0F, 0x06, 749 0x0C, 0x02, 0x00, 0x06, 0x04, 0x01, 0x05, 0x04, 0x02, 0x01, 0x1D, 0x04, 750 0x02, 0x01, 0x00, 0x03, 0x01, 0x86, 0x30, 0x06, 0x04, 0x01, 0x05, 0x04, 751 0x02, 0x01, 0x00, 0x03, 0x02, 0x8C, 0x2E, 0x2A, 0x06, 0x05, 0x62, 0x21, 752 0x01, 0x07, 0x08, 0x03, 0x03, 0x02, 0x01, 0x02, 0x02, 0x08, 0x02, 0x03, 753 0x08, 0x2A, 0x06, 0x03, 0x01, 0x02, 0x08, 0x08, 0xE1, 0x95, 0x2E, 0xE0, 754 0x8E, 0x01, 0x04, 0x17, 0x8E, 0x01, 0x04, 0x08, 0x01, 0x1C, 0x34, 0x8E, 755 0x01, 0x20, 0xDA, 0x01, 0x20, 0xE2, 0x8F, 0x01, 0x20, 0xDA, 0x78, 0x2E, 756 0xE0, 0x01, 0x00, 0xE2, 0x02, 0x01, 0x02, 0x02, 0x08, 0x02, 0x03, 0x08, 757 0x2A, 0x06, 0x80, 0x40, 0xE0, 0x02, 0x01, 0x2A, 0x06, 0x10, 0x01, 0x83, 758 0xFE, 0x01, 0xE0, 0x01, 0x04, 0x09, 0x2A, 0xE0, 0x62, 0x8B, 0x47, 0xDB, 759 0x04, 0x01, 0x29, 0x02, 0x02, 0x06, 0x0C, 0x01, 0x01, 0xE0, 0x01, 0x01, 760 0xE0, 0x86, 0x30, 0x01, 0x08, 0x09, 0xE2, 0x02, 0x03, 0x2A, 0x06, 0x11, 761 0x01, 0x10, 0xE0, 0x01, 0x04, 0x09, 0x2A, 0xE0, 0x64, 0x2A, 0xE0, 0x62, 762 0x85, 0x47, 0xDB, 0x04, 0x01, 0x29, 0x04, 0x01, 0x29, 0x00, 0x00, 0x01, 763 0x0E, 0xE2, 0x01, 0x00, 0xE1, 0x00, 0x03, 0x78, 0x2E, 0xCC, 0x05, 0x01, 764 0x00, 0x7E, 0x2F, 0x2A, 0x01, 0x82, 0x80, 0x80, 0x80, 0x00, 0x13, 0x06, 765 0x05, 0x29, 0x01, 0x1D, 0x04, 0x0E, 0x2A, 0x01, 0x83, 0xC0, 0x80, 0x80, 766 0x00, 0x13, 0x2A, 0x06, 0x01, 0x47, 0x29, 0xA5, 0x03, 0x00, 0x02, 0x00, 767 0x25, 0x2A, 0x5D, 0x06, 0x02, 0x37, 0x2B, 0x03, 0x01, 0x95, 0x2E, 0x01, 768 0x86, 0x03, 0x11, 0x03, 0x02, 0x01, 0x0C, 0xE2, 0x02, 0x01, 0x80, 0x30, 769 0x08, 0x02, 0x02, 0x01, 0x02, 0x13, 0x08, 0x01, 0x06, 0x08, 0xE1, 0x01, 770 0x03, 0xE2, 0x02, 0x00, 0xE0, 0x7F, 0x80, 0x30, 0xDB, 0x02, 0x02, 0x06, 771 0x1C, 0x92, 0x2E, 0x2A, 0x01, 0x83, 0xFE, 0x00, 0x0B, 0x06, 0x03, 0xE0, 772 0x04, 0x0F, 0x01, 0x81, 0x7F, 0x13, 0xE2, 0x78, 0x2E, 0xCD, 0x01, 0x01, 773 0x0C, 0x01, 0x03, 0x08, 0xE2, 0x02, 0x01, 0xE0, 0x85, 0x02, 0x01, 0xDA, 774 0x00, 0x00, 0x56, 0x2A, 0x01, 0x00, 0x0F, 0x06, 0x02, 0x65, 0x00, 0xCF, 775 0x29, 0x04, 0x73, 0x00, 0x2A, 0xE2, 0xDA, 0x00, 0x00, 0x01, 0x00, 0x78, 776 0x2E, 0xCB, 0x06, 0x0C, 0x63, 0x3A, 0x06, 0x08, 0x01, 0x80, 0x41, 0xE2, 777 0x01, 0x80, 0x42, 0xE2, 0x46, 0x06, 0x07, 0x61, 0x3A, 0x06, 0x03, 0x01, 778 0x01, 0xE2, 0x45, 0x06, 0x08, 0x61, 0x3A, 0x06, 0x04, 0x01, 0x80, 0x40, 779 0xE2, 0x47, 0x29, 0x00, 0x01, 0x01, 0x00, 0x03, 0x00, 0x46, 0x45, 0x39, 780 0x05, 0x14, 0x01, 0x01, 0x01, 0x80, 0x7C, 0xDE, 0x03, 0x00, 0x01, 0x03, 781 0x01, 0x80, 0x7C, 0xDE, 0x02, 0x00, 0x08, 0x47, 0x29, 0x00, 0x46, 0x06, 782 0x07, 0x01, 0x01, 0x44, 0x29, 0xDE, 0x03, 0x00, 0x45, 0x06, 0x0A, 0x01, 783 0x03, 0x44, 0x29, 0xDE, 0x02, 0x00, 0x08, 0x03, 0x00, 0x29, 0x02, 0x00, 784 0x00, 0x00, 0x01, 0x00, 0x01, 0x04, 0xDF, 0x01, 0x05, 0xDF, 0x01, 0x06, 785 0xDF, 0x01, 0x03, 0xDF, 0x01, 0x02, 0xDF, 0x0A, 0x65, 0x00, 0x01, 0x03, 786 0x00, 0x3A, 0x01, 0x01, 0x02, 0x00, 0x0C, 0x13, 0x05, 0x01, 0x00, 0x63, 787 0x01, 0x03, 0x3B, 0x06, 0x07, 0x02, 0x00, 0xE2, 0x01, 0x02, 0x3B, 0xE2, 788 0x00, 0x00, 0x2A, 0x01, 0x08, 0x54, 0xE2, 0xE2, 0x00, 0x00, 0x2A, 0x01, 789 0x10, 0x54, 0xE2, 0xE0, 0x00, 0x00, 0x2A, 0x57, 0x06, 0x02, 0x29, 0x00, 790 0xCF, 0x29, 0x04, 0x76 791 }; 792 793 static const uint16_t t0_caddr[] = { 794 0, 795 5, 796 10, 797 15, 798 20, 799 25, 800 30, 801 35, 802 40, 803 44, 804 48, 805 52, 806 56, 807 60, 808 64, 809 68, 810 72, 811 76, 812 80, 813 84, 814 88, 815 92, 816 96, 817 100, 818 104, 819 109, 820 114, 821 119, 822 124, 823 129, 824 134, 825 139, 826 144, 827 149, 828 154, 829 159, 830 164, 831 169, 832 174, 833 180, 834 185, 835 190, 836 195, 837 200, 838 205, 839 210, 840 215, 841 220, 842 225, 843 230, 844 235, 845 240, 846 245, 847 250, 848 255, 849 260, 850 265, 851 270, 852 275, 853 280, 854 285, 855 290, 856 299, 857 303, 858 328, 859 334, 860 353, 861 364, 862 405, 863 516, 864 520, 865 553, 866 563, 867 587, 868 669, 869 683, 870 689, 871 748, 872 767, 873 789, 874 838, 875 887, 876 963, 877 1065, 878 1076, 879 1670, 880 1674, 881 1741, 882 1751, 883 1782, 884 1806, 885 1852, 886 1922, 887 1962, 888 1976, 889 1985, 890 1989, 891 2084, 892 2092, 893 2128, 894 2139, 895 2155, 896 2161, 897 2172, 898 2207, 899 2233, 900 2245, 901 2251, 902 2264, 903 2279, 904 2472, 905 2481, 906 2494, 907 2503, 908 2510, 909 2616, 910 2641, 911 2654, 912 2670, 913 2688, 914 2720, 915 2793, 916 2806, 917 2987, 918 2995, 919 3122, 920 3136, 921 3141, 922 3185, 923 3242, 924 3263, 925 3290, 926 3298, 927 3306 928 }; 929 930 #define T0_INTERPRETED 93 931 932 #define T0_ENTER(ip, rp, slot) do { \ 933 const unsigned char *t0_newip; \ 934 uint32_t t0_lnum; \ 935 t0_newip = &t0_codeblock[t0_caddr[(slot) - T0_INTERPRETED]]; \ 936 t0_lnum = t0_parse7E_unsigned(&t0_newip); \ 937 (rp) += t0_lnum; \ 938 *((rp) ++) = (uint32_t)((ip) - &t0_codeblock[0]) + (t0_lnum << 16); \ 939 (ip) = t0_newip; \ 940 } while (0) 941 942 #define T0_DEFENTRY(name, slot) \ 943 void \ 944 name(void *ctx) \ 945 { \ 946 t0_context *t0ctx = ctx; \ 947 t0ctx->ip = &t0_codeblock[0]; \ 948 T0_ENTER(t0ctx->ip, t0ctx->rp, slot); \ 949 } 950 951 T0_DEFENTRY(br_ssl_hs_server_init_main, 166) 952 953 #define T0_NEXT(t0ipp) (*(*(t0ipp)) ++) 954 955 void 956 br_ssl_hs_server_run(void *t0ctx) 957 { 958 uint32_t *dp, *rp; 959 const unsigned char *ip; 960 961 #define T0_LOCAL(x) (*(rp - 2 - (x))) 962 #define T0_POP() (*-- dp) 963 #define T0_POPi() (*(int32_t *)(-- dp)) 964 #define T0_PEEK(x) (*(dp - 1 - (x))) 965 #define T0_PEEKi(x) (*(int32_t *)(dp - 1 - (x))) 966 #define T0_PUSH(v) do { *dp = (v); dp ++; } while (0) 967 #define T0_PUSHi(v) do { *(int32_t *)dp = (v); dp ++; } while (0) 968 #define T0_RPOP() (*-- rp) 969 #define T0_RPOPi() (*(int32_t *)(-- rp)) 970 #define T0_RPUSH(v) do { *rp = (v); rp ++; } while (0) 971 #define T0_RPUSHi(v) do { *(int32_t *)rp = (v); rp ++; } while (0) 972 #define T0_ROLL(x) do { \ 973 size_t t0len = (size_t)(x); \ 974 uint32_t t0tmp = *(dp - 1 - t0len); \ 975 memmove(dp - t0len - 1, dp - t0len, t0len * sizeof *dp); \ 976 *(dp - 1) = t0tmp; \ 977 } while (0) 978 #define T0_SWAP() do { \ 979 uint32_t t0tmp = *(dp - 2); \ 980 *(dp - 2) = *(dp - 1); \ 981 *(dp - 1) = t0tmp; \ 982 } while (0) 983 #define T0_ROT() do { \ 984 uint32_t t0tmp = *(dp - 3); \ 985 *(dp - 3) = *(dp - 2); \ 986 *(dp - 2) = *(dp - 1); \ 987 *(dp - 1) = t0tmp; \ 988 } while (0) 989 #define T0_NROT() do { \ 990 uint32_t t0tmp = *(dp - 1); \ 991 *(dp - 1) = *(dp - 2); \ 992 *(dp - 2) = *(dp - 3); \ 993 *(dp - 3) = t0tmp; \ 994 } while (0) 995 #define T0_PICK(x) do { \ 996 uint32_t t0depth = (x); \ 997 T0_PUSH(T0_PEEK(t0depth)); \ 998 } while (0) 999 #define T0_CO() do { \ 1000 goto t0_exit; \ 1001 } while (0) 1002 #define T0_RET() goto t0_next 1003 1004 dp = ((t0_context *)t0ctx)->dp; 1005 rp = ((t0_context *)t0ctx)->rp; 1006 ip = ((t0_context *)t0ctx)->ip; 1007 goto t0_next; 1008 for (;;) { 1009 uint32_t t0x; 1010 1011 t0_next: 1012 t0x = T0_NEXT(&ip); 1013 if (t0x < T0_INTERPRETED) { 1014 switch (t0x) { 1015 int32_t t0off; 1016 1017 case 0: /* ret */ 1018 t0x = T0_RPOP(); 1019 rp -= (t0x >> 16); 1020 t0x &= 0xFFFF; 1021 if (t0x == 0) { 1022 ip = NULL; 1023 goto t0_exit; 1024 } 1025 ip = &t0_codeblock[t0x]; 1026 break; 1027 case 1: /* literal constant */ 1028 T0_PUSHi(t0_parse7E_signed(&ip)); 1029 break; 1030 case 2: /* read local */ 1031 T0_PUSH(T0_LOCAL(t0_parse7E_unsigned(&ip))); 1032 break; 1033 case 3: /* write local */ 1034 T0_LOCAL(t0_parse7E_unsigned(&ip)) = T0_POP(); 1035 break; 1036 case 4: /* jump */ 1037 t0off = t0_parse7E_signed(&ip); 1038 ip += t0off; 1039 break; 1040 case 5: /* jump if */ 1041 t0off = t0_parse7E_signed(&ip); 1042 if (T0_POP()) { 1043 ip += t0off; 1044 } 1045 break; 1046 case 6: /* jump if not */ 1047 t0off = t0_parse7E_signed(&ip); 1048 if (!T0_POP()) { 1049 ip += t0off; 1050 } 1051 break; 1052 case 7: { 1053 /* * */ 1054 1055 uint32_t b = T0_POP(); 1056 uint32_t a = T0_POP(); 1057 T0_PUSH(a * b); 1058 1059 } 1060 break; 1061 case 8: { 1062 /* + */ 1063 1064 uint32_t b = T0_POP(); 1065 uint32_t a = T0_POP(); 1066 T0_PUSH(a + b); 1067 1068 } 1069 break; 1070 case 9: { 1071 /* - */ 1072 1073 uint32_t b = T0_POP(); 1074 uint32_t a = T0_POP(); 1075 T0_PUSH(a - b); 1076 1077 } 1078 break; 1079 case 10: { 1080 /* -rot */ 1081 T0_NROT(); 1082 } 1083 break; 1084 case 11: { 1085 /* < */ 1086 1087 int32_t b = T0_POPi(); 1088 int32_t a = T0_POPi(); 1089 T0_PUSH(-(uint32_t)(a < b)); 1090 1091 } 1092 break; 1093 case 12: { 1094 /* << */ 1095 1096 int c = (int)T0_POPi(); 1097 uint32_t x = T0_POP(); 1098 T0_PUSH(x << c); 1099 1100 } 1101 break; 1102 case 13: { 1103 /* <= */ 1104 1105 int32_t b = T0_POPi(); 1106 int32_t a = T0_POPi(); 1107 T0_PUSH(-(uint32_t)(a <= b)); 1108 1109 } 1110 break; 1111 case 14: { 1112 /* <> */ 1113 1114 uint32_t b = T0_POP(); 1115 uint32_t a = T0_POP(); 1116 T0_PUSH(-(uint32_t)(a != b)); 1117 1118 } 1119 break; 1120 case 15: { 1121 /* = */ 1122 1123 uint32_t b = T0_POP(); 1124 uint32_t a = T0_POP(); 1125 T0_PUSH(-(uint32_t)(a == b)); 1126 1127 } 1128 break; 1129 case 16: { 1130 /* > */ 1131 1132 int32_t b = T0_POPi(); 1133 int32_t a = T0_POPi(); 1134 T0_PUSH(-(uint32_t)(a > b)); 1135 1136 } 1137 break; 1138 case 17: { 1139 /* >= */ 1140 1141 int32_t b = T0_POPi(); 1142 int32_t a = T0_POPi(); 1143 T0_PUSH(-(uint32_t)(a >= b)); 1144 1145 } 1146 break; 1147 case 18: { 1148 /* >> */ 1149 1150 int c = (int)T0_POPi(); 1151 int32_t x = T0_POPi(); 1152 T0_PUSHi(x >> c); 1153 1154 } 1155 break; 1156 case 19: { 1157 /* and */ 1158 1159 uint32_t b = T0_POP(); 1160 uint32_t a = T0_POP(); 1161 T0_PUSH(a & b); 1162 1163 } 1164 break; 1165 case 20: { 1166 /* begin-cert */ 1167 1168 if (ENG->chain_len == 0) { 1169 T0_PUSHi(-1); 1170 } else { 1171 ENG->cert_cur = ENG->chain->data; 1172 ENG->cert_len = ENG->chain->data_len; 1173 ENG->chain ++; 1174 ENG->chain_len --; 1175 T0_PUSH(ENG->cert_len); 1176 } 1177 1178 } 1179 break; 1180 case 21: { 1181 /* begin-ta-name */ 1182 1183 const br_x500_name *dn; 1184 if (CTX->cur_dn_index >= CTX->num_tas) { 1185 T0_PUSHi(-1); 1186 } else { 1187 if (CTX->ta_names == NULL) { 1188 dn = &CTX->tas[CTX->cur_dn_index].dn; 1189 } else { 1190 dn = &CTX->ta_names[CTX->cur_dn_index]; 1191 } 1192 CTX->cur_dn_index ++; 1193 CTX->cur_dn = dn->data; 1194 CTX->cur_dn_len = dn->len; 1195 T0_PUSH(CTX->cur_dn_len); 1196 } 1197 1198 } 1199 break; 1200 case 22: { 1201 /* begin-ta-name-list */ 1202 1203 CTX->cur_dn_index = 0; 1204 1205 } 1206 break; 1207 case 23: { 1208 /* bzero */ 1209 1210 size_t len = (size_t)T0_POP(); 1211 void *addr = (unsigned char *)ENG + (size_t)T0_POP(); 1212 memset(addr, 0, len); 1213 1214 } 1215 break; 1216 case 24: { 1217 /* call-policy-handler */ 1218 1219 int x; 1220 br_ssl_server_choices choices; 1221 1222 x = (*CTX->policy_vtable)->choose( 1223 CTX->policy_vtable, CTX, &choices); 1224 ENG->session.cipher_suite = choices.cipher_suite; 1225 CTX->sign_hash_id = choices.algo_id; 1226 ENG->chain = choices.chain; 1227 ENG->chain_len = choices.chain_len; 1228 T0_PUSHi(-(x != 0)); 1229 1230 } 1231 break; 1232 case 25: { 1233 /* can-output? */ 1234 1235 T0_PUSHi(-(ENG->hlen_out > 0)); 1236 1237 } 1238 break; 1239 case 26: { 1240 /* check-resume */ 1241 1242 if (ENG->session.session_id_len == 32 1243 && CTX->cache_vtable != NULL && (*CTX->cache_vtable)->load( 1244 CTX->cache_vtable, CTX, &ENG->session)) 1245 { 1246 T0_PUSHi(-1); 1247 } else { 1248 T0_PUSH(0); 1249 } 1250 1251 } 1252 break; 1253 case 27: { 1254 /* co */ 1255 T0_CO(); 1256 } 1257 break; 1258 case 28: { 1259 /* compute-Finished-inner */ 1260 1261 int prf_id = T0_POP(); 1262 int from_client = T0_POPi(); 1263 unsigned char tmp[48]; 1264 br_tls_prf_seed_chunk seed; 1265 1266 br_tls_prf_impl prf = br_ssl_engine_get_PRF(ENG, prf_id); 1267 seed.data = tmp; 1268 if (ENG->session.version >= BR_TLS12) { 1269 seed.len = br_multihash_out(&ENG->mhash, prf_id, tmp); 1270 } else { 1271 br_multihash_out(&ENG->mhash, br_md5_ID, tmp); 1272 br_multihash_out(&ENG->mhash, br_sha1_ID, tmp + 16); 1273 seed.len = 36; 1274 } 1275 prf(ENG->pad, 12, ENG->session.master_secret, 1276 sizeof ENG->session.master_secret, 1277 from_client ? "client finished" : "server finished", 1278 1, &seed); 1279 1280 } 1281 break; 1282 case 29: { 1283 /* compute-hash-CV */ 1284 1285 int i; 1286 1287 for (i = 1; i <= 6; i ++) { 1288 br_multihash_out(&ENG->mhash, i, 1289 ENG->pad + HASH_PAD_OFF[i - 1]); 1290 } 1291 1292 } 1293 break; 1294 case 30: { 1295 /* copy-cert-chunk */ 1296 1297 size_t clen; 1298 1299 clen = ENG->cert_len; 1300 if (clen > sizeof ENG->pad) { 1301 clen = sizeof ENG->pad; 1302 } 1303 memcpy(ENG->pad, ENG->cert_cur, clen); 1304 ENG->cert_cur += clen; 1305 ENG->cert_len -= clen; 1306 T0_PUSH(clen); 1307 1308 } 1309 break; 1310 case 31: { 1311 /* copy-dn-chunk */ 1312 1313 size_t clen; 1314 1315 clen = CTX->cur_dn_len; 1316 if (clen > sizeof ENG->pad) { 1317 clen = sizeof ENG->pad; 1318 } 1319 memcpy(ENG->pad, CTX->cur_dn, clen); 1320 CTX->cur_dn += clen; 1321 CTX->cur_dn_len -= clen; 1322 T0_PUSH(clen); 1323 1324 } 1325 break; 1326 case 32: { 1327 /* copy-hash-CV */ 1328 1329 int id = T0_POP(); 1330 size_t off, len; 1331 1332 if (id == 0) { 1333 off = 0; 1334 len = 36; 1335 } else { 1336 if (br_multihash_getimpl(&ENG->mhash, id) == 0) { 1337 T0_PUSH(0); 1338 T0_RET(); 1339 } 1340 off = HASH_PAD_OFF[id - 1]; 1341 len = HASH_PAD_OFF[id] - off; 1342 } 1343 memcpy(CTX->hash_CV, ENG->pad + off, len); 1344 CTX->hash_CV_len = len; 1345 CTX->hash_CV_id = id; 1346 T0_PUSHi(-1); 1347 1348 } 1349 break; 1350 case 33: { 1351 /* copy-protocol-name */ 1352 1353 size_t idx = T0_POP(); 1354 size_t len = strlen(ENG->protocol_names[idx]); 1355 memcpy(ENG->pad, ENG->protocol_names[idx], len); 1356 T0_PUSH(len); 1357 1358 } 1359 break; 1360 case 34: { 1361 /* data-get8 */ 1362 1363 size_t addr = T0_POP(); 1364 T0_PUSH(t0_datablock[addr]); 1365 1366 } 1367 break; 1368 case 35: { 1369 /* discard-input */ 1370 1371 ENG->hlen_in = 0; 1372 1373 } 1374 break; 1375 case 36: { 1376 /* do-ecdh */ 1377 1378 int prf_id = T0_POPi(); 1379 size_t len = T0_POP(); 1380 do_ecdh(CTX, prf_id, ENG->pad, len); 1381 1382 } 1383 break; 1384 case 37: { 1385 /* do-ecdhe-part1 */ 1386 1387 int curve = T0_POPi(); 1388 T0_PUSHi(do_ecdhe_part1(CTX, curve)); 1389 1390 } 1391 break; 1392 case 38: { 1393 /* do-ecdhe-part2 */ 1394 1395 int prf_id = T0_POPi(); 1396 size_t len = T0_POP(); 1397 do_ecdhe_part2(CTX, prf_id, ENG->pad, len); 1398 1399 } 1400 break; 1401 case 39: { 1402 /* do-rsa-decrypt */ 1403 1404 int prf_id = T0_POPi(); 1405 size_t len = T0_POP(); 1406 do_rsa_decrypt(CTX, prf_id, ENG->pad, len); 1407 1408 } 1409 break; 1410 case 40: { 1411 /* do-static-ecdh */ 1412 1413 do_static_ecdh(CTX, T0_POP()); 1414 1415 } 1416 break; 1417 case 41: { 1418 /* drop */ 1419 (void)T0_POP(); 1420 } 1421 break; 1422 case 42: { 1423 /* dup */ 1424 T0_PUSH(T0_PEEK(0)); 1425 } 1426 break; 1427 case 43: { 1428 /* fail */ 1429 1430 br_ssl_engine_fail(ENG, (int)T0_POPi()); 1431 T0_CO(); 1432 1433 } 1434 break; 1435 case 44: { 1436 /* flush-record */ 1437 1438 br_ssl_engine_flush_record(ENG); 1439 1440 } 1441 break; 1442 case 45: { 1443 /* get-key-type-usages */ 1444 1445 const br_x509_class *xc; 1446 const br_x509_pkey *pk; 1447 unsigned usages; 1448 1449 xc = *(ENG->x509ctx); 1450 pk = xc->get_pkey(ENG->x509ctx, &usages); 1451 if (pk == NULL) { 1452 T0_PUSH(0); 1453 } else { 1454 T0_PUSH(pk->key_type | usages); 1455 } 1456 1457 } 1458 break; 1459 case 46: { 1460 /* get16 */ 1461 1462 size_t addr = (size_t)T0_POP(); 1463 T0_PUSH(*(uint16_t *)(void *)((unsigned char *)ENG + addr)); 1464 1465 } 1466 break; 1467 case 47: { 1468 /* get32 */ 1469 1470 size_t addr = (size_t)T0_POP(); 1471 T0_PUSH(*(uint32_t *)(void *)((unsigned char *)ENG + addr)); 1472 1473 } 1474 break; 1475 case 48: { 1476 /* get8 */ 1477 1478 size_t addr = (size_t)T0_POP(); 1479 T0_PUSH(*((unsigned char *)ENG + addr)); 1480 1481 } 1482 break; 1483 case 49: { 1484 /* has-input? */ 1485 1486 T0_PUSHi(-(ENG->hlen_in != 0)); 1487 1488 } 1489 break; 1490 case 50: { 1491 /* memcmp */ 1492 1493 size_t len = (size_t)T0_POP(); 1494 void *addr2 = (unsigned char *)ENG + (size_t)T0_POP(); 1495 void *addr1 = (unsigned char *)ENG + (size_t)T0_POP(); 1496 int x = memcmp(addr1, addr2, len); 1497 T0_PUSH((uint32_t)-(x == 0)); 1498 1499 } 1500 break; 1501 case 51: { 1502 /* memcpy */ 1503 1504 size_t len = (size_t)T0_POP(); 1505 void *src = (unsigned char *)ENG + (size_t)T0_POP(); 1506 void *dst = (unsigned char *)ENG + (size_t)T0_POP(); 1507 memcpy(dst, src, len); 1508 1509 } 1510 break; 1511 case 52: { 1512 /* mkrand */ 1513 1514 size_t len = (size_t)T0_POP(); 1515 void *addr = (unsigned char *)ENG + (size_t)T0_POP(); 1516 br_hmac_drbg_generate(&ENG->rng, addr, len); 1517 1518 } 1519 break; 1520 case 53: { 1521 /* more-incoming-bytes? */ 1522 1523 T0_PUSHi(ENG->hlen_in != 0 || !br_ssl_engine_recvrec_finished(ENG)); 1524 1525 } 1526 break; 1527 case 54: { 1528 /* multihash-init */ 1529 1530 br_multihash_init(&ENG->mhash); 1531 1532 } 1533 break; 1534 case 55: { 1535 /* neg */ 1536 1537 uint32_t a = T0_POP(); 1538 T0_PUSH(-a); 1539 1540 } 1541 break; 1542 case 56: { 1543 /* not */ 1544 1545 uint32_t a = T0_POP(); 1546 T0_PUSH(~a); 1547 1548 } 1549 break; 1550 case 57: { 1551 /* or */ 1552 1553 uint32_t b = T0_POP(); 1554 uint32_t a = T0_POP(); 1555 T0_PUSH(a | b); 1556 1557 } 1558 break; 1559 case 58: { 1560 /* over */ 1561 T0_PUSH(T0_PEEK(1)); 1562 } 1563 break; 1564 case 59: { 1565 /* pick */ 1566 T0_PICK(T0_POP()); 1567 } 1568 break; 1569 case 60: { 1570 /* read-chunk-native */ 1571 1572 size_t clen = ENG->hlen_in; 1573 if (clen > 0) { 1574 uint32_t addr, len; 1575 1576 len = T0_POP(); 1577 addr = T0_POP(); 1578 if ((size_t)len < clen) { 1579 clen = (size_t)len; 1580 } 1581 memcpy((unsigned char *)ENG + addr, ENG->hbuf_in, clen); 1582 if (ENG->record_type_in == BR_SSL_HANDSHAKE) { 1583 br_multihash_update(&ENG->mhash, ENG->hbuf_in, clen); 1584 } 1585 T0_PUSH(addr + (uint32_t)clen); 1586 T0_PUSH(len - (uint32_t)clen); 1587 ENG->hbuf_in += clen; 1588 ENG->hlen_in -= clen; 1589 } 1590 1591 } 1592 break; 1593 case 61: { 1594 /* read8-native */ 1595 1596 if (ENG->hlen_in > 0) { 1597 unsigned char x; 1598 1599 x = *ENG->hbuf_in ++; 1600 if (ENG->record_type_in == BR_SSL_HANDSHAKE) { 1601 br_multihash_update(&ENG->mhash, &x, 1); 1602 } 1603 T0_PUSH(x); 1604 ENG->hlen_in --; 1605 } else { 1606 T0_PUSHi(-1); 1607 } 1608 1609 } 1610 break; 1611 case 62: { 1612 /* save-session */ 1613 1614 if (CTX->cache_vtable != NULL) { 1615 (*CTX->cache_vtable)->save( 1616 CTX->cache_vtable, CTX, &ENG->session); 1617 } 1618 1619 } 1620 break; 1621 case 63: { 1622 /* set-max-frag-len */ 1623 1624 size_t max_frag_len = T0_POP(); 1625 1626 br_ssl_engine_new_max_frag_len(ENG, max_frag_len); 1627 1628 /* 1629 * We must adjust our own output limit. Since we call this only 1630 * after receiving a ClientHello and before beginning to send 1631 * the ServerHello, the next output record should be empty at 1632 * that point, so we can use max_frag_len as a limit. 1633 */ 1634 if (ENG->hlen_out > max_frag_len) { 1635 ENG->hlen_out = max_frag_len; 1636 } 1637 1638 } 1639 break; 1640 case 64: { 1641 /* set16 */ 1642 1643 size_t addr = (size_t)T0_POP(); 1644 *(uint16_t *)(void *)((unsigned char *)ENG + addr) = (uint16_t)T0_POP(); 1645 1646 } 1647 break; 1648 case 65: { 1649 /* set32 */ 1650 1651 size_t addr = (size_t)T0_POP(); 1652 *(uint32_t *)(void *)((unsigned char *)ENG + addr) = (uint32_t)T0_POP(); 1653 1654 } 1655 break; 1656 case 66: { 1657 /* set8 */ 1658 1659 size_t addr = (size_t)T0_POP(); 1660 *((unsigned char *)ENG + addr) = (unsigned char)T0_POP(); 1661 1662 } 1663 break; 1664 case 67: { 1665 /* supported-curves */ 1666 1667 uint32_t x = ENG->iec == NULL ? 0 : ENG->iec->supported_curves; 1668 T0_PUSH(x); 1669 1670 } 1671 break; 1672 case 68: { 1673 /* supported-hash-functions */ 1674 1675 int i; 1676 unsigned x, num; 1677 1678 x = 0; 1679 num = 0; 1680 for (i = br_sha1_ID; i <= br_sha512_ID; i ++) { 1681 if (br_multihash_getimpl(&ENG->mhash, i)) { 1682 x |= 1U << i; 1683 num ++; 1684 } 1685 } 1686 T0_PUSH(x); 1687 T0_PUSH(num); 1688 1689 } 1690 break; 1691 case 69: { 1692 /* supports-ecdsa? */ 1693 1694 T0_PUSHi(-(ENG->iecdsa != 0)); 1695 1696 } 1697 break; 1698 case 70: { 1699 /* supports-rsa-sign? */ 1700 1701 T0_PUSHi(-(ENG->irsavrfy != 0)); 1702 1703 } 1704 break; 1705 case 71: { 1706 /* swap */ 1707 T0_SWAP(); 1708 } 1709 break; 1710 case 72: { 1711 /* switch-aesccm-in */ 1712 1713 int is_client, prf_id; 1714 unsigned cipher_key_len, tag_len; 1715 1716 tag_len = T0_POP(); 1717 cipher_key_len = T0_POP(); 1718 prf_id = T0_POP(); 1719 is_client = T0_POP(); 1720 br_ssl_engine_switch_ccm_in(ENG, is_client, prf_id, 1721 ENG->iaes_ctrcbc, cipher_key_len, tag_len); 1722 1723 } 1724 break; 1725 case 73: { 1726 /* switch-aesccm-out */ 1727 1728 int is_client, prf_id; 1729 unsigned cipher_key_len, tag_len; 1730 1731 tag_len = T0_POP(); 1732 cipher_key_len = T0_POP(); 1733 prf_id = T0_POP(); 1734 is_client = T0_POP(); 1735 br_ssl_engine_switch_ccm_out(ENG, is_client, prf_id, 1736 ENG->iaes_ctrcbc, cipher_key_len, tag_len); 1737 1738 } 1739 break; 1740 case 74: { 1741 /* switch-aesgcm-in */ 1742 1743 int is_client, prf_id; 1744 unsigned cipher_key_len; 1745 1746 cipher_key_len = T0_POP(); 1747 prf_id = T0_POP(); 1748 is_client = T0_POP(); 1749 br_ssl_engine_switch_gcm_in(ENG, is_client, prf_id, 1750 ENG->iaes_ctr, cipher_key_len); 1751 1752 } 1753 break; 1754 case 75: { 1755 /* switch-aesgcm-out */ 1756 1757 int is_client, prf_id; 1758 unsigned cipher_key_len; 1759 1760 cipher_key_len = T0_POP(); 1761 prf_id = T0_POP(); 1762 is_client = T0_POP(); 1763 br_ssl_engine_switch_gcm_out(ENG, is_client, prf_id, 1764 ENG->iaes_ctr, cipher_key_len); 1765 1766 } 1767 break; 1768 case 76: { 1769 /* switch-cbc-in */ 1770 1771 int is_client, prf_id, mac_id, aes; 1772 unsigned cipher_key_len; 1773 1774 cipher_key_len = T0_POP(); 1775 aes = T0_POP(); 1776 mac_id = T0_POP(); 1777 prf_id = T0_POP(); 1778 is_client = T0_POP(); 1779 br_ssl_engine_switch_cbc_in(ENG, is_client, prf_id, mac_id, 1780 aes ? ENG->iaes_cbcdec : ENG->ides_cbcdec, cipher_key_len); 1781 1782 } 1783 break; 1784 case 77: { 1785 /* switch-cbc-out */ 1786 1787 int is_client, prf_id, mac_id, aes; 1788 unsigned cipher_key_len; 1789 1790 cipher_key_len = T0_POP(); 1791 aes = T0_POP(); 1792 mac_id = T0_POP(); 1793 prf_id = T0_POP(); 1794 is_client = T0_POP(); 1795 br_ssl_engine_switch_cbc_out(ENG, is_client, prf_id, mac_id, 1796 aes ? ENG->iaes_cbcenc : ENG->ides_cbcenc, cipher_key_len); 1797 1798 } 1799 break; 1800 case 78: { 1801 /* switch-chapol-in */ 1802 1803 int is_client, prf_id; 1804 1805 prf_id = T0_POP(); 1806 is_client = T0_POP(); 1807 br_ssl_engine_switch_chapol_in(ENG, is_client, prf_id); 1808 1809 } 1810 break; 1811 case 79: { 1812 /* switch-chapol-out */ 1813 1814 int is_client, prf_id; 1815 1816 prf_id = T0_POP(); 1817 is_client = T0_POP(); 1818 br_ssl_engine_switch_chapol_out(ENG, is_client, prf_id); 1819 1820 } 1821 break; 1822 case 80: { 1823 /* ta-names-total-length */ 1824 1825 size_t u, len; 1826 1827 len = 0; 1828 if (CTX->ta_names != NULL) { 1829 for (u = 0; u < CTX->num_tas; u ++) { 1830 len += CTX->ta_names[u].len + 2; 1831 } 1832 } else if (CTX->tas != NULL) { 1833 for (u = 0; u < CTX->num_tas; u ++) { 1834 len += CTX->tas[u].dn.len + 2; 1835 } 1836 } 1837 T0_PUSH(len); 1838 1839 } 1840 break; 1841 case 81: { 1842 /* test-protocol-name */ 1843 1844 size_t len = T0_POP(); 1845 size_t u; 1846 1847 for (u = 0; u < ENG->protocol_names_num; u ++) { 1848 const char *name; 1849 1850 name = ENG->protocol_names[u]; 1851 if (len == strlen(name) && memcmp(ENG->pad, name, len) == 0) { 1852 T0_PUSH(u); 1853 T0_RET(); 1854 } 1855 } 1856 T0_PUSHi(-1); 1857 1858 } 1859 break; 1860 case 82: { 1861 /* total-chain-length */ 1862 1863 size_t u; 1864 uint32_t total; 1865 1866 total = 0; 1867 for (u = 0; u < ENG->chain_len; u ++) { 1868 total += 3 + (uint32_t)ENG->chain[u].data_len; 1869 } 1870 T0_PUSH(total); 1871 1872 } 1873 break; 1874 case 83: { 1875 /* u< */ 1876 1877 uint32_t b = T0_POP(); 1878 uint32_t a = T0_POP(); 1879 T0_PUSH(-(uint32_t)(a < b)); 1880 1881 } 1882 break; 1883 case 84: { 1884 /* u>> */ 1885 1886 int c = (int)T0_POPi(); 1887 uint32_t x = T0_POP(); 1888 T0_PUSH(x >> c); 1889 1890 } 1891 break; 1892 case 85: { 1893 /* verify-CV-sig */ 1894 1895 int err; 1896 1897 err = verify_CV_sig(CTX, T0_POP()); 1898 T0_PUSHi(err); 1899 1900 } 1901 break; 1902 case 86: { 1903 /* write-blob-chunk */ 1904 1905 size_t clen = ENG->hlen_out; 1906 if (clen > 0) { 1907 uint32_t addr, len; 1908 1909 len = T0_POP(); 1910 addr = T0_POP(); 1911 if ((size_t)len < clen) { 1912 clen = (size_t)len; 1913 } 1914 memcpy(ENG->hbuf_out, (unsigned char *)ENG + addr, clen); 1915 if (ENG->record_type_out == BR_SSL_HANDSHAKE) { 1916 br_multihash_update(&ENG->mhash, ENG->hbuf_out, clen); 1917 } 1918 T0_PUSH(addr + (uint32_t)clen); 1919 T0_PUSH(len - (uint32_t)clen); 1920 ENG->hbuf_out += clen; 1921 ENG->hlen_out -= clen; 1922 } 1923 1924 } 1925 break; 1926 case 87: { 1927 /* write8-native */ 1928 1929 unsigned char x; 1930 1931 x = (unsigned char)T0_POP(); 1932 if (ENG->hlen_out > 0) { 1933 if (ENG->record_type_out == BR_SSL_HANDSHAKE) { 1934 br_multihash_update(&ENG->mhash, &x, 1); 1935 } 1936 *ENG->hbuf_out ++ = x; 1937 ENG->hlen_out --; 1938 T0_PUSHi(-1); 1939 } else { 1940 T0_PUSHi(0); 1941 } 1942 1943 } 1944 break; 1945 case 88: { 1946 /* x509-append */ 1947 1948 const br_x509_class *xc; 1949 size_t len; 1950 1951 xc = *(ENG->x509ctx); 1952 len = T0_POP(); 1953 xc->append(ENG->x509ctx, ENG->pad, len); 1954 1955 } 1956 break; 1957 case 89: { 1958 /* x509-end-cert */ 1959 1960 const br_x509_class *xc; 1961 1962 xc = *(ENG->x509ctx); 1963 xc->end_cert(ENG->x509ctx); 1964 1965 } 1966 break; 1967 case 90: { 1968 /* x509-end-chain */ 1969 1970 const br_x509_class *xc; 1971 1972 xc = *(ENG->x509ctx); 1973 T0_PUSH(xc->end_chain(ENG->x509ctx)); 1974 1975 } 1976 break; 1977 case 91: { 1978 /* x509-start-cert */ 1979 1980 const br_x509_class *xc; 1981 1982 xc = *(ENG->x509ctx); 1983 xc->start_cert(ENG->x509ctx, T0_POP()); 1984 1985 } 1986 break; 1987 case 92: { 1988 /* x509-start-chain */ 1989 1990 const br_x509_class *xc; 1991 uint32_t bc; 1992 1993 bc = T0_POP(); 1994 xc = *(ENG->x509ctx); 1995 xc->start_chain(ENG->x509ctx, bc ? ENG->server_name : NULL); 1996 1997 } 1998 break; 1999 } 2000 2001 } else { 2002 T0_ENTER(ip, rp, t0x); 2003 } 2004 } 2005 t0_exit: 2006 ((t0_context *)t0ctx)->dp = dp; 2007 ((t0_context *)t0ctx)->rp = rp; 2008 ((t0_context *)t0ctx)->ip = ip; 2009 } 2010