_ Git - BearSSL/blob - ssl/ssl_hs_server.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 uint8_t 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 *)((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 "adresses" 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 *cpoint, size_t cpoint_len, uint32_t ctl)
 144 {
 145         unsigned char rpms[80];
 146         size_t pms_len;
 147
 148         /*
 149          * The point length is supposed to be 1+2*Xlen, where Xlen is
 150          * the length (in bytes) of the X coordinate, i.e. the pre-master
 151          * secret. If the provided point is too large, then it is
 152          * obviously incorrect (i.e. everybody can see that it is
 153          * incorrect), so leaking that fact is not a problem.
 154          */
 155         pms_len = cpoint_len >> 1;
 156         if (pms_len > sizeof rpms) {
 157                 pms_len = sizeof rpms;
 158                 ctl = 0;
 159         }
 160
 161         /*
 162          * Make a random PMS and copy it above the decrypted value if the
 163          * decryption failed. Note that we use a constant-time conditional
 164          * copy.
 165          */
 166         br_hmac_drbg_generate(&ctx->eng.rng, rpms, pms_len);
 167         br_ccopy(ctl ^ 1, cpoint + 1, rpms, pms_len);
 168
 169         /*
 170          * Compute master secret.
 171          */
 172         br_ssl_engine_compute_master(&ctx->eng, prf_id, cpoint + 1, pms_len);
 173
 174         /*
 175          * Clear the pre-master secret from RAM: it is normally a buffer
 176          * in the context, hence potentially long-lived.
 177          */
 178         memset(cpoint, 0, cpoint_len);
 179 }
 180
 181 /*
 182  * Do the ECDH key exchange (not ECDHE).
 183  */
 184 static void
 185 do_ecdh(br_ssl_server_context *ctx, int prf_id,
 186         unsigned char *cpoint, size_t cpoint_len)
 187 {
 188         uint32_t x;
 189
 190         /*
 191          * Finalise the key exchange.
 192          */
 193         x = (*ctx->policy_vtable)->do_keyx(ctx->policy_vtable,
 194                 cpoint, cpoint_len);
 195         ecdh_common(ctx, prf_id, cpoint, cpoint_len, x);
 196 }
 197
 198 /*
 199  * Do the ECDHE key exchange (part 1: generation of transient key, and
 200  * computing of the point to send to the client). Returned value is the
 201  * signature length (in bytes), or -x on error (with x being an error
 202  * code). The encoded point is written in the ecdhe_point[] context buffer
 203  * (length in ecdhe_point_len).
 204  */
 205 static int
 206 do_ecdhe_part1(br_ssl_server_context *ctx, int curve)
 207 {
 208         int hash;
 209         unsigned mask;
 210         const unsigned char *order, *generator;
 211         size_t olen, glen;
 212         br_multihash_context mhc;
 213         unsigned char head[4];
 214         size_t hv_len, sig_len;
 215
 216         if (!((ctx->eng.iec->supported_curves >> curve) & 1)) {
 217                 return -BR_ERR_INVALID_ALGORITHM;
 218         }
 219         ctx->eng.ecdhe_curve = curve;
 220
 221         /*
 222          * Generate our private key. We need a non-zero random value
 223          * which is lower than the curve order, in a "large enough"
 224          * range. We force the top bit to 0 and bottom bit to 1, which
 225          * does the trick. Note that contrary to what happens in ECDSA,
 226          * this is not a problem if we do not cover the full range of
 227          * possible values.
 228          */
 229         order = ctx->eng.iec->order(curve, &olen);
 230         mask = 0xFF;
 231         while (mask >= order[0]) {
 232                 mask >>= 1;
 233         }
 234         br_hmac_drbg_generate(&ctx->eng.rng, ctx->ecdhe_key, olen);
 235         ctx->ecdhe_key[0] &= mask;
 236         ctx->ecdhe_key[olen - 1] |= 0x01;
 237         ctx->ecdhe_key_len = olen;
 238
 239         /*
 240          * Compute our ECDH point.
 241          */
 242         generator = ctx->eng.iec->generator(curve, &glen);
 243         memcpy(ctx->eng.ecdhe_point, generator, glen);
 244         ctx->eng.ecdhe_point_len = glen;
 245         if (!ctx->eng.iec->mul(ctx->eng.ecdhe_point, glen,
 246                 ctx->ecdhe_key, olen, curve))
 247         {
 248                 return -BR_ERR_INVALID_ALGORITHM;
 249         }
 250
 251         /*
 252          * Compute the signature.
 253          */
 254         br_multihash_zero(&mhc);
 255         br_multihash_copyimpl(&mhc, &ctx->eng.mhash);
 256         br_multihash_init(&mhc);
 257         br_multihash_update(&mhc,
 258                 ctx->eng.client_random, sizeof ctx->eng.client_random);
 259         br_multihash_update(&mhc,
 260                 ctx->eng.server_random, sizeof ctx->eng.server_random);
 261         head[0] = 3;
 262         head[1] = 0;
 263         head[2] = curve;
 264         head[3] = ctx->eng.ecdhe_point_len;
 265         br_multihash_update(&mhc, head, sizeof head);
 266         br_multihash_update(&mhc,
 267                 ctx->eng.ecdhe_point, ctx->eng.ecdhe_point_len);
 268         hash = ctx->sign_hash_id;
 269         if (hash) {
 270                 hv_len = br_multihash_out(&mhc, hash, ctx->eng.pad);
 271                 if (hv_len == 0) {
 272                         return -BR_ERR_INVALID_ALGORITHM;
 273                 }
 274         } else {
 275                 if (!br_multihash_out(&mhc, br_md5_ID, ctx->eng.pad)
 276                         || !br_multihash_out(&mhc,
 277                         br_sha1_ID, ctx->eng.pad + 16))
 278                 {
 279                         return -BR_ERR_INVALID_ALGORITHM;
 280                 }
 281                 hv_len = 36;
 282         }
 283         sig_len = (*ctx->policy_vtable)->do_sign(ctx->policy_vtable,
 284                 hash, hv_len, ctx->eng.pad, sizeof ctx->eng.pad);
 285         return sig_len ? (int)sig_len : -BR_ERR_INVALID_ALGORITHM;
 286 }
 287
 288 /*
 289  * Do the ECDHE key exchange (part 2: computation of the shared secret
 290  * from the point sent by the client).
 291  */
 292 static void
 293 do_ecdhe_part2(br_ssl_server_context *ctx, int prf_id,
 294         unsigned char *cpoint, size_t cpoint_len)
 295 {
 296         int curve;
 297         uint32_t x;
 298
 299         curve = ctx->eng.ecdhe_curve;
 300
 301         /*
 302          * Finalise the key exchange.
 303          */
 304         x = ctx->eng.iec->mul(cpoint, cpoint_len,
 305                 ctx->ecdhe_key, ctx->ecdhe_key_len, curve);
 306         ecdh_common(ctx, prf_id, cpoint, cpoint_len, x);
 307
 308         /*
 309          * Clear the ECDHE private key. Forward Secrecy is achieved insofar
 310          * as that key does not get stolen, so we'd better destroy it
 311          * as soon as it ceases to be useful.
 312          */
 313         memset(ctx->ecdhe_key, 0, ctx->ecdhe_key_len);
 314 }
 315
 316
 317
 318 static const uint8_t t0_datablock[] = {
 319         0x00, 0x00, 0x0A, 0x00, 0x24, 0x00, 0x2F, 0x01, 0x24, 0x00, 0x35, 0x02,
 320         0x24, 0x00, 0x3C, 0x01, 0x44, 0x00, 0x3D, 0x02, 0x44, 0x00, 0x9C, 0x03,
 321         0x04, 0x00, 0x9D, 0x04, 0x05, 0xC0, 0x03, 0x40, 0x24, 0xC0, 0x04, 0x41,
 322         0x24, 0xC0, 0x05, 0x42, 0x24, 0xC0, 0x08, 0x20, 0x24, 0xC0, 0x09, 0x21,
 323         0x24, 0xC0, 0x0A, 0x22, 0x24, 0xC0, 0x0D, 0x30, 0x24, 0xC0, 0x0E, 0x31,
 324         0x24, 0xC0, 0x0F, 0x32, 0x24, 0xC0, 0x12, 0x10, 0x24, 0xC0, 0x13, 0x11,
 325         0x24, 0xC0, 0x14, 0x12, 0x24, 0xC0, 0x23, 0x21, 0x44, 0xC0, 0x24, 0x22,
 326         0x55, 0xC0, 0x25, 0x41, 0x44, 0xC0, 0x26, 0x42, 0x55, 0xC0, 0x27, 0x11,
 327         0x44, 0xC0, 0x28, 0x12, 0x55, 0xC0, 0x29, 0x31, 0x44, 0xC0, 0x2A, 0x32,
 328         0x55, 0xC0, 0x2B, 0x23, 0x04, 0xC0, 0x2C, 0x24, 0x05, 0xC0, 0x2D, 0x43,
 329         0x04, 0xC0, 0x2E, 0x44, 0x05, 0xC0, 0x2F, 0x13, 0x04, 0xC0, 0x30, 0x14,
 330         0x05, 0xC0, 0x31, 0x33, 0x04, 0xC0, 0x32, 0x34, 0x05, 0xCC, 0xA8, 0x15,
 331         0x04, 0xCC, 0xA9, 0x25, 0x04, 0x00, 0x00
 332 };
 333
 334 static const uint8_t t0_codeblock[] = {
 335         0x00, 0x01, 0x00, 0x0A, 0x00, 0x00, 0x01, 0x00, 0x0D, 0x00, 0x00, 0x01,
 336         0x00, 0x0E, 0x00, 0x00, 0x01, 0x00, 0x0F, 0x00, 0x00, 0x01, 0x01, 0x08,
 337         0x00, 0x00, 0x01, 0x01, 0x09, 0x00, 0x00, 0x01, 0x02, 0x08, 0x00, 0x00,
 338         0x21, 0x21, 0x00, 0x00, 0x01, T0_INT1(BR_ERR_BAD_CCS), 0x00, 0x00,
 339         0x01, T0_INT1(BR_ERR_BAD_FINISHED), 0x00, 0x00, 0x01,
 340         T0_INT1(BR_ERR_BAD_FRAGLEN), 0x00, 0x00, 0x01,
 341         T0_INT1(BR_ERR_BAD_HANDSHAKE), 0x00, 0x00, 0x01,
 342         T0_INT1(BR_ERR_BAD_PARAM), 0x00, 0x00, 0x01,
 343         T0_INT1(BR_ERR_BAD_SECRENEG), 0x00, 0x00, 0x01,
 344         T0_INT1(BR_ERR_BAD_VERSION), 0x00, 0x00, 0x01,
 345         T0_INT1(BR_ERR_LIMIT_EXCEEDED), 0x00, 0x00, 0x01, T0_INT1(BR_ERR_OK),
 346         0x00, 0x00, 0x01, T0_INT1(BR_ERR_OVERSIZED_ID), 0x00, 0x00, 0x01,
 347         T0_INT1(BR_ERR_UNEXPECTED), 0x00, 0x00, 0x01,
 348         T0_INT2(offsetof(br_ssl_engine_context, action)), 0x00, 0x00, 0x01,
 349         T0_INT2(offsetof(br_ssl_engine_context, alert)), 0x00, 0x00, 0x01,
 350         T0_INT2(offsetof(br_ssl_engine_context, application_data)), 0x00, 0x00,
 351         0x01,
 352         T0_INT2(offsetof(br_ssl_engine_context, session) + offsetof(br_ssl_session_parameters, cipher_suite)),
 353         0x00, 0x00, 0x01,
 354         T0_INT2(offsetof(br_ssl_server_context, client_max_version)), 0x00,
 355         0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, client_random)),
 356         0x00, 0x00, 0x01,
 357         T0_INT2(offsetof(br_ssl_server_context, client_suites)), 0x00, 0x00,
 358         0x01, T0_INT2(offsetof(br_ssl_server_context, client_suites_num)),
 359         0x00, 0x00, 0x01,
 360         T0_INT2(offsetof(br_ssl_engine_context, close_received)), 0x00, 0x00,
 361         0x01, T0_INT2(offsetof(br_ssl_server_context, curves)), 0x00, 0x00,
 362         0x01, T0_INT2(offsetof(br_ssl_engine_context, ecdhe_point)), 0x00,
 363         0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, ecdhe_point_len)),
 364         0x00, 0x00, 0x01, T0_INT2(offsetof(br_ssl_server_context, flags)),
 365         0x00, 0x00, 0x01, T0_INT2(offsetof(br_ssl_server_context, hashes)),
 366         0x00, 0x00, 0x5D, 0x01,
 367         T0_INT2(BR_MAX_CIPHER_SUITES * sizeof(br_suite_translated)), 0x00,
 368         0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, log_max_frag_len)),
 369         0x00, 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, pad)), 0x00,
 370         0x00, 0x01,
 371         T0_INT2(offsetof(br_ssl_engine_context, peer_log_max_frag_len)), 0x00,
 372         0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, record_type_in)),
 373         0x00, 0x00, 0x01,
 374         T0_INT2(offsetof(br_ssl_engine_context, record_type_out)), 0x00, 0x00,
 375         0x01, T0_INT2(offsetof(br_ssl_engine_context, reneg)), 0x00, 0x00,
 376         0x01, T0_INT2(offsetof(br_ssl_engine_context, saved_finished)), 0x00,
 377         0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, server_name)),
 378         0x00, 0x00, 0x01,
 379         T0_INT2(offsetof(br_ssl_engine_context, server_random)), 0x00, 0x00,
 380         0x01,
 381         T0_INT2(offsetof(br_ssl_engine_context, session) + offsetof(br_ssl_session_parameters, session_id)),
 382         0x00, 0x00, 0x01,
 383         T0_INT2(offsetof(br_ssl_engine_context, session) + offsetof(br_ssl_session_parameters, session_id_len)),
 384         0x00, 0x00, 0x01,
 385         T0_INT2(offsetof(br_ssl_engine_context, shutdown_recv)), 0x00, 0x00,
 386         0x01, T0_INT2(offsetof(br_ssl_server_context, sign_hash_id)), 0x00,
 387         0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, suites_buf)), 0x00,
 388         0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, suites_num)), 0x00,
 389         0x00, 0x01,
 390         T0_INT2(offsetof(br_ssl_engine_context, session) + offsetof(br_ssl_session_parameters, version)),
 391         0x00, 0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, version_in)),
 392         0x00, 0x00, 0x01,
 393         T0_INT2(offsetof(br_ssl_engine_context, version_max)), 0x00, 0x00,
 394         0x01, T0_INT2(offsetof(br_ssl_engine_context, version_min)), 0x00,
 395         0x00, 0x01, T0_INT2(offsetof(br_ssl_engine_context, version_out)),
 396         0x00, 0x00, 0x09, 0x22, 0x44, 0x06, 0x02, 0x50, 0x23, 0x00, 0x00, 0x01,
 397         0x01, 0x00, 0x01, 0x03, 0x00, 0x7B, 0x22, 0x4A, 0x3B, 0x7F, 0x22, 0x05,
 398         0x04, 0x4B, 0x01, 0x00, 0x00, 0x02, 0x00, 0x0E, 0x06, 0x02, 0x7F, 0x00,
 399         0x4A, 0x04, 0x6B, 0x00, 0x06, 0x02, 0x50, 0x23, 0x00, 0x00, 0x22, 0x6C,
 400         0x3B, 0x05, 0x03, 0x01, 0x0C, 0x08, 0x3B, 0x5A, 0x25, 0x81, 0x07, 0x19,
 401         0x67, 0x01, 0x0C, 0x2A, 0x00, 0x00, 0x22, 0x1B, 0x01, 0x08, 0x0B, 0x3B,
 402         0x48, 0x1B, 0x08, 0x00, 0x01, 0x03, 0x00, 0x01, 0x00, 0x59, 0x38, 0x24,
 403         0x16, 0x2F, 0x06, 0x08, 0x02, 0x00, 0x81, 0x26, 0x03, 0x00, 0x04, 0x74,
 404         0x01, 0x00, 0x81, 0x1E, 0x02, 0x00, 0x22, 0x16, 0x12, 0x06, 0x02, 0x54,
 405         0x23, 0x81, 0x26, 0x04, 0x75, 0x00, 0x01, 0x00, 0x59, 0x38, 0x01, 0x16,
 406         0x6A, 0x38, 0x2D, 0x81, 0x0B, 0x2C, 0x06, 0x02, 0x56, 0x23, 0x06, 0x0C,
 407         0x81, 0x2C, 0x01, 0x00, 0x81, 0x29, 0x01, 0x00, 0x81, 0x0A, 0x04, 0x14,
 408         0x81, 0x2C, 0x81, 0x2A, 0x81, 0x2E, 0x81, 0x2D, 0x24, 0x81, 0x0C, 0x01,
 409         0x00, 0x81, 0x0A, 0x01, 0x00, 0x81, 0x29, 0x34, 0x01, 0x01, 0x59, 0x38,
 410         0x01, 0x17, 0x6A, 0x38, 0x00, 0x00, 0x31, 0x31, 0x00, 0x01, 0x03, 0x00,
 411         0x24, 0x16, 0x2F, 0x06, 0x05, 0x81, 0x25, 0x21, 0x04, 0x77, 0x01, 0x02,
 412         0x02, 0x00, 0x81, 0x1D, 0x16, 0x2F, 0x06, 0x05, 0x81, 0x25, 0x21, 0x04,
 413         0x77, 0x02, 0x00, 0x01, 0x84, 0x00, 0x08, 0x23, 0x00, 0x00, 0x63, 0x26,
 414         0x3B, 0x11, 0x01, 0x01, 0x12, 0x2E, 0x00, 0x00, 0x01, 0x7F, 0x81, 0x01,
 415         0x81, 0x25, 0x22, 0x01, 0x07, 0x12, 0x01, 0x00, 0x31, 0x0E, 0x06, 0x0A,
 416         0x21, 0x01, 0x10, 0x12, 0x06, 0x02, 0x81, 0x1C, 0x04, 0x24, 0x01, 0x01,
 417         0x31, 0x0E, 0x06, 0x1B, 0x21, 0x21, 0x6B, 0x27, 0x01, 0x01, 0x0D, 0x06,
 418         0x06, 0x01, 0x00, 0x81, 0x01, 0x04, 0x0A, 0x24, 0x16, 0x2F, 0x06, 0x05,
 419         0x81, 0x25, 0x21, 0x04, 0x77, 0x04, 0x03, 0x56, 0x23, 0x21, 0x04, 0x44,
 420         0x01, 0x22, 0x03, 0x00, 0x09, 0x22, 0x44, 0x06, 0x02, 0x50, 0x23, 0x02,
 421         0x00, 0x00, 0x00, 0x7C, 0x01, 0x0F, 0x12, 0x00, 0x00, 0x58, 0x27, 0x01,
 422         0x00, 0x31, 0x0E, 0x06, 0x10, 0x21, 0x22, 0x01, 0x01, 0x0D, 0x06, 0x03,
 423         0x21, 0x01, 0x02, 0x58, 0x38, 0x01, 0x00, 0x04, 0x16, 0x01, 0x01, 0x31,
 424         0x0E, 0x06, 0x09, 0x21, 0x01, 0x00, 0x58, 0x38, 0x46, 0x00, 0x04, 0x07,
 425         0x21, 0x01, 0x82, 0x00, 0x08, 0x23, 0x21, 0x00, 0x00, 0x01, 0x00, 0x28,
 426         0x06, 0x06, 0x33, 0x81, 0x08, 0x30, 0x04, 0x77, 0x22, 0x06, 0x04, 0x01,
 427         0x01, 0x71, 0x38, 0x00, 0x00, 0x28, 0x06, 0x0B, 0x69, 0x27, 0x01, 0x14,
 428         0x0D, 0x06, 0x02, 0x56, 0x23, 0x04, 0x12, 0x81, 0x25, 0x01, 0x07, 0x12,
 429         0x22, 0x01, 0x02, 0x0D, 0x06, 0x06, 0x06, 0x02, 0x56, 0x23, 0x04, 0x6F,
 430         0x21, 0x81, 0x1A, 0x01, 0x01, 0x0D, 0x2C, 0x30, 0x06, 0x02, 0x4C, 0x23,
 431         0x22, 0x01, 0x01, 0x81, 0x20, 0x2F, 0x81, 0x0D, 0x00, 0x0A, 0x81, 0x12,
 432         0x01, 0x01, 0x0E, 0x05, 0x02, 0x56, 0x23, 0x81, 0x17, 0x22, 0x03, 0x00,
 433         0x5B, 0x36, 0x5C, 0x01, 0x20, 0x81, 0x0E, 0x81, 0x19, 0x22, 0x01, 0x20,
 434         0x0F, 0x06, 0x02, 0x55, 0x23, 0x22, 0x70, 0x38, 0x6F, 0x3B, 0x81, 0x0E,
 435         0x17, 0x03, 0x01, 0x81, 0x17, 0x81, 0x06, 0x01, 0x00, 0x03, 0x02, 0x01,
 436         0x00, 0x03, 0x03, 0x65, 0x81, 0x02, 0x14, 0x31, 0x08, 0x03, 0x04, 0x03,
 437         0x05, 0x22, 0x06, 0x80, 0x70, 0x81, 0x17, 0x22, 0x03, 0x06, 0x02, 0x01,
 438         0x06, 0x0A, 0x22, 0x5A, 0x25, 0x0E, 0x06, 0x04, 0x01, 0x7F, 0x03, 0x03,
 439         0x22, 0x01, 0x81, 0x7F, 0x0E, 0x06, 0x0A, 0x6B, 0x27, 0x06, 0x02, 0x51,
 440         0x23, 0x01, 0x7F, 0x03, 0x02, 0x22, 0x01, 0x81, 0xAC, 0x00, 0x0E, 0x06,
 441         0x11, 0x02, 0x00, 0x78, 0x25, 0x10, 0x02, 0x00, 0x77, 0x25, 0x0A, 0x12,
 442         0x06, 0x04, 0x01, 0x7F, 0x03, 0x00, 0x81, 0x1B, 0x22, 0x44, 0x06, 0x03,
 443         0x21, 0x04, 0x27, 0x01, 0x00, 0x81, 0x04, 0x06, 0x0B, 0x01, 0x02, 0x0B,
 444         0x5D, 0x08, 0x02, 0x06, 0x3B, 0x36, 0x04, 0x16, 0x21, 0x02, 0x05, 0x02,
 445         0x04, 0x10, 0x06, 0x02, 0x4F, 0x23, 0x02, 0x06, 0x02, 0x05, 0x36, 0x02,
 446         0x05, 0x01, 0x04, 0x08, 0x03, 0x05, 0x04, 0xFF, 0x0C, 0x21, 0x01, 0x00,
 447         0x03, 0x07, 0x81, 0x19, 0x81, 0x06, 0x22, 0x06, 0x0A, 0x81, 0x19, 0x05,
 448         0x04, 0x01, 0x7F, 0x03, 0x07, 0x04, 0x73, 0x7D, 0x01, 0x00, 0x6D, 0x38,
 449         0x01, 0x88, 0x04, 0x64, 0x36, 0x01, 0x84, 0x80, 0x80, 0x00, 0x60, 0x37,
 450         0x22, 0x06, 0x80, 0x4D, 0x81, 0x17, 0x81, 0x06, 0x22, 0x06, 0x80, 0x44,
 451         0x81, 0x17, 0x01, 0x00, 0x31, 0x0E, 0x06, 0x05, 0x21, 0x81, 0x11, 0x04,
 452         0x34, 0x01, 0x01, 0x31, 0x0E, 0x06, 0x05, 0x21, 0x81, 0x0F, 0x04, 0x29,
 453         0x01, 0x83, 0xFE, 0x01, 0x31, 0x0E, 0x06, 0x05, 0x21, 0x81, 0x10, 0x04,
 454         0x1C, 0x01, 0x0D, 0x31, 0x0E, 0x06, 0x05, 0x21, 0x81, 0x15, 0x04, 0x11,
 455         0x01, 0x0A, 0x31, 0x0E, 0x06, 0x05, 0x21, 0x81, 0x16, 0x04, 0x06, 0x21,
 456         0x81, 0x14, 0x01, 0x00, 0x21, 0x04, 0xFF, 0x38, 0x7D, 0x7D, 0x02, 0x01,
 457         0x02, 0x03, 0x12, 0x03, 0x01, 0x02, 0x00, 0x44, 0x06, 0x09, 0x5B, 0x25,
 458         0x79, 0x36, 0x01, 0x80, 0x56, 0x81, 0x03, 0x77, 0x25, 0x22, 0x02, 0x00,
 459         0x0F, 0x06, 0x03, 0x21, 0x02, 0x00, 0x22, 0x01, 0x86, 0x00, 0x0A, 0x06,
 460         0x02, 0x52, 0x23, 0x02, 0x00, 0x78, 0x25, 0x0A, 0x06, 0x05, 0x01, 0x80,
 461         0x46, 0x81, 0x03, 0x02, 0x01, 0x06, 0x10, 0x75, 0x25, 0x02, 0x00, 0x0C,
 462         0x06, 0x05, 0x21, 0x75, 0x25, 0x04, 0x04, 0x01, 0x00, 0x03, 0x01, 0x22,
 463         0x75, 0x36, 0x22, 0x76, 0x36, 0x22, 0x79, 0x36, 0x01, 0x86, 0x03, 0x10,
 464         0x03, 0x08, 0x02, 0x02, 0x06, 0x04, 0x01, 0x02, 0x6B, 0x38, 0x02, 0x07,
 465         0x05, 0x04, 0x01, 0x28, 0x81, 0x03, 0x3A, 0x21, 0x01, 0x82, 0x01, 0x07,
 466         0x64, 0x25, 0x12, 0x22, 0x64, 0x36, 0x45, 0x03, 0x09, 0x60, 0x26, 0x39,
 467         0x12, 0x22, 0x60, 0x37, 0x05, 0x04, 0x01, 0x00, 0x03, 0x09, 0x02, 0x01,
 468         0x06, 0x03, 0x01, 0x7F, 0x00, 0x6F, 0x01, 0x20, 0x2B, 0x5D, 0x22, 0x03,
 469         0x05, 0x22, 0x02, 0x04, 0x0A, 0x06, 0x80, 0x47, 0x22, 0x25, 0x22, 0x7C,
 470         0x02, 0x09, 0x05, 0x13, 0x22, 0x01, 0x0C, 0x11, 0x22, 0x01, 0x01, 0x0E,
 471         0x3B, 0x01, 0x02, 0x0E, 0x30, 0x06, 0x04, 0x4B, 0x01, 0x00, 0x22, 0x02,
 472         0x08, 0x05, 0x0E, 0x22, 0x01, 0x81, 0x70, 0x12, 0x01, 0x20, 0x0D, 0x06,
 473         0x04, 0x4B, 0x01, 0x00, 0x22, 0x22, 0x06, 0x10, 0x02, 0x05, 0x4A, 0x36,
 474         0x02, 0x05, 0x36, 0x02, 0x05, 0x01, 0x04, 0x08, 0x03, 0x05, 0x04, 0x01,
 475         0x4B, 0x01, 0x04, 0x08, 0x04, 0xFF, 0x32, 0x21, 0x02, 0x05, 0x5D, 0x09,
 476         0x01, 0x02, 0x11, 0x22, 0x05, 0x04, 0x01, 0x28, 0x81, 0x03, 0x5E, 0x38,
 477         0x15, 0x05, 0x04, 0x01, 0x28, 0x81, 0x03, 0x01, 0x00, 0x00, 0x04, 0x81,
 478         0x12, 0x01, 0x10, 0x0E, 0x05, 0x02, 0x56, 0x23, 0x5A, 0x25, 0x81, 0x24,
 479         0x06, 0x19, 0x81, 0x17, 0x22, 0x01, 0x84, 0x00, 0x0F, 0x06, 0x02, 0x53,
 480         0x23, 0x22, 0x03, 0x00, 0x67, 0x3B, 0x81, 0x0E, 0x02, 0x00, 0x5A, 0x25,
 481         0x81, 0x07, 0x20, 0x5A, 0x25, 0x22, 0x81, 0x22, 0x3B, 0x81, 0x21, 0x03,
 482         0x01, 0x03, 0x02, 0x02, 0x01, 0x02, 0x02, 0x30, 0x06, 0x17, 0x81, 0x19,
 483         0x22, 0x03, 0x03, 0x67, 0x3B, 0x81, 0x0E, 0x02, 0x03, 0x5A, 0x25, 0x81,
 484         0x07, 0x02, 0x02, 0x06, 0x03, 0x1F, 0x04, 0x01, 0x1D, 0x7D, 0x00, 0x00,
 485         0x7E, 0x81, 0x12, 0x01, 0x14, 0x0D, 0x06, 0x02, 0x56, 0x23, 0x67, 0x01,
 486         0x0C, 0x08, 0x01, 0x0C, 0x81, 0x0E, 0x7D, 0x67, 0x22, 0x01, 0x0C, 0x08,
 487         0x01, 0x0C, 0x29, 0x05, 0x02, 0x4D, 0x23, 0x00, 0x02, 0x03, 0x00, 0x03,
 488         0x01, 0x02, 0x00, 0x7A, 0x02, 0x01, 0x02, 0x00, 0x32, 0x22, 0x01, 0x00,
 489         0x0E, 0x06, 0x02, 0x4B, 0x00, 0x81, 0x27, 0x04, 0x73, 0x00, 0x81, 0x17,
 490         0x01, 0x01, 0x0D, 0x06, 0x02, 0x4E, 0x23, 0x81, 0x19, 0x22, 0x22, 0x46,
 491         0x3B, 0x01, 0x05, 0x10, 0x30, 0x06, 0x02, 0x4E, 0x23, 0x01, 0x08, 0x08,
 492         0x22, 0x66, 0x27, 0x0A, 0x06, 0x0D, 0x22, 0x01, 0x01, 0x3B, 0x0B, 0x35,
 493         0x22, 0x66, 0x38, 0x68, 0x38, 0x04, 0x01, 0x21, 0x00, 0x00, 0x81, 0x17,
 494         0x6B, 0x27, 0x01, 0x00, 0x31, 0x0E, 0x06, 0x14, 0x21, 0x01, 0x01, 0x0E,
 495         0x05, 0x02, 0x51, 0x23, 0x81, 0x19, 0x06, 0x02, 0x51, 0x23, 0x01, 0x02,
 496         0x6B, 0x38, 0x04, 0x2A, 0x01, 0x02, 0x31, 0x0E, 0x06, 0x21, 0x21, 0x01,
 497         0x0D, 0x0E, 0x05, 0x02, 0x51, 0x23, 0x81, 0x19, 0x01, 0x0C, 0x0E, 0x05,
 498         0x02, 0x51, 0x23, 0x67, 0x01, 0x0C, 0x81, 0x0E, 0x6C, 0x67, 0x01, 0x0C,
 499         0x29, 0x05, 0x02, 0x51, 0x23, 0x04, 0x03, 0x51, 0x23, 0x21, 0x00, 0x00,
 500         0x81, 0x17, 0x81, 0x06, 0x81, 0x17, 0x81, 0x06, 0x22, 0x06, 0x22, 0x81,
 501         0x19, 0x06, 0x04, 0x81, 0x14, 0x04, 0x18, 0x81, 0x17, 0x22, 0x01, 0x81,
 502         0x7F, 0x0C, 0x06, 0x0D, 0x22, 0x6D, 0x08, 0x01, 0x00, 0x3B, 0x38, 0x6D,
 503         0x3B, 0x81, 0x0E, 0x04, 0x02, 0x81, 0x1F, 0x04, 0x5B, 0x7D, 0x7D, 0x00,
 504         0x00, 0x81, 0x13, 0x22, 0x46, 0x06, 0x07, 0x21, 0x06, 0x02, 0x4F, 0x23,
 505         0x04, 0x73, 0x00, 0x00, 0x81, 0x1A, 0x01, 0x03, 0x81, 0x18, 0x3B, 0x21,
 506         0x3B, 0x00, 0x00, 0x81, 0x17, 0x81, 0x1F, 0x00, 0x02, 0x81, 0x17, 0x81,
 507         0x06, 0x01, 0x00, 0x64, 0x36, 0x81, 0x17, 0x81, 0x06, 0x22, 0x06, 0x34,
 508         0x81, 0x19, 0x03, 0x00, 0x81, 0x19, 0x03, 0x01, 0x02, 0x00, 0x01, 0x02,
 509         0x10, 0x02, 0x00, 0x01, 0x06, 0x0C, 0x12, 0x02, 0x01, 0x01, 0x01, 0x0E,
 510         0x02, 0x01, 0x01, 0x03, 0x0E, 0x30, 0x12, 0x06, 0x11, 0x64, 0x25, 0x01,
 511         0x01, 0x02, 0x01, 0x49, 0x01, 0x02, 0x0B, 0x02, 0x00, 0x08, 0x0B, 0x30,
 512         0x64, 0x36, 0x04, 0x49, 0x7D, 0x7D, 0x00, 0x00, 0x81, 0x17, 0x81, 0x06,
 513         0x81, 0x17, 0x81, 0x06, 0x01, 0x00, 0x60, 0x37, 0x22, 0x06, 0x16, 0x81,
 514         0x17, 0x22, 0x01, 0x20, 0x0A, 0x06, 0x0B, 0x01, 0x01, 0x3B, 0x0B, 0x60,
 515         0x26, 0x30, 0x60, 0x37, 0x04, 0x01, 0x21, 0x04, 0x67, 0x7D, 0x7D, 0x00,
 516         0x00, 0x01, 0x02, 0x7A, 0x81, 0x1A, 0x01, 0x08, 0x0B, 0x81, 0x1A, 0x08,
 517         0x00, 0x00, 0x01, 0x03, 0x7A, 0x81, 0x1A, 0x01, 0x08, 0x0B, 0x81, 0x1A,
 518         0x08, 0x01, 0x08, 0x0B, 0x81, 0x1A, 0x08, 0x00, 0x00, 0x01, 0x01, 0x7A,
 519         0x81, 0x1A, 0x00, 0x00, 0x33, 0x22, 0x44, 0x05, 0x01, 0x00, 0x21, 0x81,
 520         0x27, 0x04, 0x75, 0x02, 0x03, 0x00, 0x74, 0x27, 0x03, 0x01, 0x01, 0x00,
 521         0x22, 0x02, 0x01, 0x0A, 0x06, 0x10, 0x22, 0x01, 0x01, 0x0B, 0x73, 0x08,
 522         0x25, 0x02, 0x00, 0x0E, 0x06, 0x01, 0x00, 0x48, 0x04, 0x6A, 0x21, 0x01,
 523         0x7F, 0x00, 0x00, 0x24, 0x16, 0x2F, 0x06, 0x05, 0x81, 0x25, 0x21, 0x04,
 524         0x77, 0x01, 0x16, 0x6A, 0x38, 0x01, 0x00, 0x81, 0x33, 0x01, 0x00, 0x81,
 525         0x32, 0x24, 0x01, 0x17, 0x6A, 0x38, 0x00, 0x00, 0x01, 0x15, 0x6A, 0x38,
 526         0x3B, 0x43, 0x21, 0x43, 0x21, 0x24, 0x00, 0x00, 0x01, 0x01, 0x3B, 0x81,
 527         0x1D, 0x00, 0x00, 0x3B, 0x31, 0x7A, 0x3B, 0x22, 0x06, 0x06, 0x81, 0x1A,
 528         0x21, 0x49, 0x04, 0x77, 0x21, 0x00, 0x02, 0x03, 0x00, 0x5A, 0x25, 0x7C,
 529         0x03, 0x01, 0x02, 0x01, 0x01, 0x0F, 0x12, 0x02, 0x01, 0x01, 0x04, 0x11,
 530         0x01, 0x0F, 0x12, 0x02, 0x01, 0x01, 0x08, 0x11, 0x01, 0x0F, 0x12, 0x01,
 531         0x00, 0x31, 0x0E, 0x06, 0x10, 0x21, 0x01, 0x00, 0x01, 0x18, 0x02, 0x00,
 532         0x06, 0x03, 0x3E, 0x04, 0x01, 0x3F, 0x04, 0x80, 0x56, 0x01, 0x01, 0x31,
 533         0x0E, 0x06, 0x10, 0x21, 0x01, 0x01, 0x01, 0x10, 0x02, 0x00, 0x06, 0x03,
 534         0x3E, 0x04, 0x01, 0x3F, 0x04, 0x80, 0x40, 0x01, 0x02, 0x31, 0x0E, 0x06,
 535         0x0F, 0x21, 0x01, 0x01, 0x01, 0x20, 0x02, 0x00, 0x06, 0x03, 0x3E, 0x04,
 536         0x01, 0x3F, 0x04, 0x2B, 0x01, 0x03, 0x31, 0x0E, 0x06, 0x0E, 0x21, 0x21,
 537         0x01, 0x10, 0x02, 0x00, 0x06, 0x03, 0x3C, 0x04, 0x01, 0x3D, 0x04, 0x17,
 538         0x01, 0x04, 0x31, 0x0E, 0x06, 0x0E, 0x21, 0x21, 0x01, 0x20, 0x02, 0x00,
 539         0x06, 0x03, 0x3C, 0x04, 0x01, 0x3D, 0x04, 0x03, 0x50, 0x23, 0x21, 0x00,
 540         0x00, 0x7C, 0x01, 0x0C, 0x11, 0x01, 0x02, 0x0F, 0x00, 0x00, 0x7C, 0x01,
 541         0x0C, 0x11, 0x22, 0x47, 0x3B, 0x01, 0x03, 0x0A, 0x12, 0x00, 0x00, 0x7C,
 542         0x01, 0x0C, 0x11, 0x01, 0x01, 0x0E, 0x00, 0x00, 0x7C, 0x01, 0x0C, 0x11,
 543         0x46, 0x00, 0x00, 0x18, 0x01, 0x00, 0x57, 0x27, 0x22, 0x06, 0x20, 0x01,
 544         0x01, 0x31, 0x0E, 0x06, 0x07, 0x21, 0x01, 0x00, 0x81, 0x00, 0x04, 0x11,
 545         0x01, 0x02, 0x31, 0x0E, 0x06, 0x0A, 0x21, 0x59, 0x27, 0x06, 0x03, 0x01,
 546         0x10, 0x30, 0x04, 0x01, 0x21, 0x04, 0x01, 0x21, 0x5F, 0x27, 0x05, 0x35,
 547         0x28, 0x06, 0x32, 0x69, 0x27, 0x01, 0x14, 0x31, 0x0E, 0x06, 0x06, 0x21,
 548         0x01, 0x02, 0x30, 0x04, 0x24, 0x01, 0x15, 0x31, 0x0E, 0x06, 0x0B, 0x21,
 549         0x81, 0x09, 0x06, 0x04, 0x01, 0x7F, 0x81, 0x00, 0x04, 0x13, 0x01, 0x16,
 550         0x31, 0x0E, 0x06, 0x06, 0x21, 0x01, 0x01, 0x30, 0x04, 0x07, 0x21, 0x01,
 551         0x04, 0x30, 0x01, 0x00, 0x21, 0x16, 0x06, 0x03, 0x01, 0x08, 0x30, 0x00,
 552         0x00, 0x18, 0x22, 0x05, 0x10, 0x28, 0x06, 0x0D, 0x69, 0x27, 0x01, 0x15,
 553         0x0E, 0x06, 0x05, 0x21, 0x81, 0x09, 0x04, 0x01, 0x1C, 0x00, 0x00, 0x81,
 554         0x25, 0x01, 0x07, 0x12, 0x01, 0x01, 0x0F, 0x06, 0x02, 0x56, 0x23, 0x00,
 555         0x01, 0x03, 0x00, 0x24, 0x16, 0x06, 0x05, 0x02, 0x00, 0x6A, 0x38, 0x00,
 556         0x81, 0x25, 0x21, 0x04, 0x73, 0x00, 0x01, 0x14, 0x81, 0x28, 0x01, 0x01,
 557         0x81, 0x33, 0x24, 0x22, 0x01, 0x00, 0x81, 0x20, 0x01, 0x16, 0x81, 0x28,
 558         0x81, 0x2B, 0x24, 0x00, 0x00, 0x01, 0x0B, 0x81, 0x33, 0x40, 0x22, 0x01,
 559         0x03, 0x08, 0x81, 0x32, 0x81, 0x32, 0x13, 0x22, 0x44, 0x06, 0x02, 0x21,
 560         0x00, 0x81, 0x32, 0x1A, 0x22, 0x06, 0x06, 0x67, 0x3B, 0x81, 0x2F, 0x04,
 561         0x76, 0x21, 0x04, 0x6A, 0x00, 0x7E, 0x01, 0x14, 0x81, 0x33, 0x01, 0x0C,
 562         0x81, 0x32, 0x67, 0x01, 0x0C, 0x81, 0x2F, 0x00, 0x03, 0x03, 0x00, 0x01,
 563         0x02, 0x81, 0x33, 0x01, 0x80, 0x46, 0x6B, 0x27, 0x01, 0x02, 0x0E, 0x06,
 564         0x0C, 0x02, 0x00, 0x06, 0x04, 0x01, 0x05, 0x04, 0x02, 0x01, 0x1D, 0x04,
 565         0x02, 0x01, 0x00, 0x03, 0x01, 0x68, 0x27, 0x06, 0x04, 0x01, 0x05, 0x04,
 566         0x02, 0x01, 0x00, 0x03, 0x02, 0x02, 0x01, 0x02, 0x02, 0x08, 0x22, 0x06,
 567         0x03, 0x01, 0x02, 0x08, 0x08, 0x81, 0x32, 0x75, 0x25, 0x81, 0x31, 0x6E,
 568         0x01, 0x04, 0x14, 0x6E, 0x01, 0x04, 0x08, 0x01, 0x1C, 0x2B, 0x6E, 0x01,
 569         0x20, 0x81, 0x2F, 0x01, 0x20, 0x81, 0x33, 0x6F, 0x01, 0x20, 0x81, 0x2F,
 570         0x5A, 0x25, 0x81, 0x31, 0x01, 0x00, 0x81, 0x33, 0x02, 0x01, 0x02, 0x02,
 571         0x08, 0x22, 0x06, 0x30, 0x81, 0x31, 0x02, 0x01, 0x22, 0x06, 0x13, 0x01,
 572         0x83, 0xFE, 0x01, 0x81, 0x31, 0x01, 0x04, 0x09, 0x22, 0x81, 0x31, 0x49,
 573         0x6C, 0x3B, 0x81, 0x30, 0x04, 0x01, 0x21, 0x02, 0x02, 0x06, 0x0F, 0x01,
 574         0x01, 0x81, 0x31, 0x01, 0x01, 0x81, 0x31, 0x68, 0x27, 0x01, 0x08, 0x09,
 575         0x81, 0x33, 0x04, 0x01, 0x21, 0x00, 0x00, 0x01, 0x0E, 0x81, 0x33, 0x01,
 576         0x00, 0x81, 0x32, 0x00, 0x03, 0x5A, 0x25, 0x81, 0x22, 0x05, 0x01, 0x00,
 577         0x60, 0x26, 0x01, 0x00, 0x81, 0x02, 0x11, 0x01, 0x01, 0x12, 0x46, 0x06,
 578         0x03, 0x48, 0x04, 0x74, 0x03, 0x00, 0x21, 0x02, 0x00, 0x1E, 0x22, 0x44,
 579         0x06, 0x02, 0x2E, 0x23, 0x03, 0x01, 0x75, 0x25, 0x01, 0x86, 0x03, 0x10,
 580         0x03, 0x02, 0x01, 0x0C, 0x81, 0x33, 0x02, 0x01, 0x62, 0x27, 0x08, 0x02,
 581         0x02, 0x01, 0x02, 0x12, 0x08, 0x01, 0x06, 0x08, 0x81, 0x32, 0x01, 0x03,
 582         0x81, 0x33, 0x02, 0x00, 0x81, 0x31, 0x61, 0x62, 0x27, 0x81, 0x30, 0x02,
 583         0x02, 0x06, 0x10, 0x72, 0x27, 0x81, 0x33, 0x5A, 0x25, 0x81, 0x23, 0x01,
 584         0x01, 0x0B, 0x01, 0x03, 0x08, 0x81, 0x33, 0x02, 0x01, 0x81, 0x31, 0x67,
 585         0x02, 0x01, 0x81, 0x2F, 0x00, 0x00, 0x42, 0x22, 0x01, 0x00, 0x0E, 0x06,
 586         0x02, 0x4B, 0x00, 0x81, 0x25, 0x21, 0x04, 0x72, 0x00, 0x22, 0x81, 0x33,
 587         0x81, 0x2F, 0x00, 0x00, 0x22, 0x01, 0x08, 0x41, 0x81, 0x33, 0x81, 0x33,
 588         0x00, 0x00, 0x22, 0x01, 0x10, 0x41, 0x81, 0x33, 0x81, 0x31, 0x00, 0x00,
 589         0x22, 0x43, 0x06, 0x02, 0x21, 0x00, 0x81, 0x25, 0x21, 0x04, 0x75
 590 };
 591
 592 static const uint16_t t0_caddr[] = {
 593         0,
 594         5,
 595         10,
 596         15,
 597         20,
 598         25,
 599         30,
 600         35,
 601         39,
 602         43,
 603         47,
 604         51,
 605         55,
 606         59,
 607         63,
 608         67,
 609         71,
 610         75,
 611         79,
 612         83,
 613         88,
 614         93,
 615         98,
 616         103,
 617         108,
 618         113,
 619         118,
 620         123,
 621         128,
 622         133,
 623         138,
 624         143,
 625         148,
 626         153,
 627         159,
 628         164,
 629         169,
 630         174,
 631         179,
 632         184,
 633         189,
 634         194,
 635         199,
 636         204,
 637         209,
 638         214,
 639         219,
 640         224,
 641         229,
 642         234,
 643         239,
 644         244,
 645         249,
 646         254,
 647         259,
 648         268,
 649         272,
 650         297,
 651         303,
 652         323,
 653         334,
 654         371,
 655         431,
 656         435,
 657         471,
 658         481,
 659         546,
 660         560,
 661         566,
 662         614,
 663         634,
 664         687,
 665         1240,
 666         1325,
 667         1358,
 668         1383,
 669         1431,
 670         1505,
 671         1554,
 672         1569,
 673         1580,
 674         1586,
 675         1657,
 676         1698,
 677         1711,
 678         1730,
 679         1737,
 680         1749,
 681         1784,
 682         1813,
 683         1825,
 684         1832,
 685         1848,
 686         1986,
 687         1995,
 688         2008,
 689         2017,
 690         2024,
 691         2130,
 692         2152,
 693         2166,
 694         2183,
 695         2206,
 696         2242,
 697         2258,
 698         2412,
 699         2422,
 700         2531,
 701         2546,
 702         2553,
 703         2563,
 704         2573
 705 };
 706
 707 #define T0_INTERPRETED   68
 708
 709 #define T0_ENTER(ip, rp, slot)   do { \
 710                 const unsigned char *t0_newip; \
 711                 uint32_t t0_lnum; \
 712                 t0_newip = &t0_codeblock[t0_caddr[(slot) - T0_INTERPRETED]]; \
 713                 t0_lnum = t0_parse7E_unsigned(&t0_newip); \
 714                 (rp) += t0_lnum; \
 715                 *((rp) ++) = (uint32_t)((ip) - &t0_codeblock[0]) + (t0_lnum << 16); \
 716                 (ip) = t0_newip; \
 717         } while (0)
 718
 719 #define T0_DEFENTRY(name, slot) \
 720 void \
 721 name(void *ctx) \
 722 { \
 723         t0_context *t0ctx = ctx; \
 724         t0ctx->ip = &t0_codeblock[0]; \
 725         T0_ENTER(t0ctx->ip, t0ctx->rp, slot); \
 726 }
 727
 728 T0_DEFENTRY(br_ssl_hs_server_init_main, 133)
 729
 730 void
 731 br_ssl_hs_server_run(void *t0ctx)
 732 {
 733         uint32_t *dp, *rp;
 734         const unsigned char *ip;
 735
 736 #define T0_LOCAL(x)    (*(rp - 2 - (x)))
 737 #define T0_POP()       (*-- dp)
 738 #define T0_POPi()      (*(int32_t *)(-- dp))
 739 #define T0_PEEK(x)     (*(dp - 1 - (x)))
 740 #define T0_PEEKi(x)    (*(int32_t *)(dp - 1 - (x)))
 741 #define T0_PUSH(v)     do { *dp = (v); dp ++; } while (0)
 742 #define T0_PUSHi(v)    do { *(int32_t *)dp = (v); dp ++; } while (0)
 743 #define T0_RPOP()      (*-- rp)
 744 #define T0_RPOPi()     (*(int32_t *)(-- rp))
 745 #define T0_RPUSH(v)    do { *rp = (v); rp ++; } while (0)
 746 #define T0_RPUSHi(v)   do { *(int32_t *)rp = (v); rp ++; } while (0)
 747 #define T0_ROLL(x)     do { \
 748         size_t t0len = (size_t)(x); \
 749         uint32_t t0tmp = *(dp - 1 - t0len); \
 750         memmove(dp - t0len - 1, dp - t0len, t0len * sizeof *dp); \
 751         *(dp - 1) = t0tmp; \
 752 } while (0)
 753 #define T0_SWAP()      do { \
 754         uint32_t t0tmp = *(dp - 2); \
 755         *(dp - 2) = *(dp - 1); \
 756         *(dp - 1) = t0tmp; \
 757 } while (0)
 758 #define T0_ROT()       do { \
 759         uint32_t t0tmp = *(dp - 3); \
 760         *(dp - 3) = *(dp - 2); \
 761         *(dp - 2) = *(dp - 1); \
 762         *(dp - 1) = t0tmp; \
 763 } while (0)
 764 #define T0_NROT()       do { \
 765         uint32_t t0tmp = *(dp - 1); \
 766         *(dp - 1) = *(dp - 2); \
 767         *(dp - 2) = *(dp - 3); \
 768         *(dp - 3) = t0tmp; \
 769 } while (0)
 770 #define T0_PICK(x)      do { \
 771         uint32_t t0depth = (x); \
 772         T0_PUSH(T0_PEEK(t0depth)); \
 773 } while (0)
 774 #define T0_CO()         do { \
 775         goto t0_exit; \
 776 } while (0)
 777 #define T0_RET()        break
 778
 779         dp = ((t0_context *)t0ctx)->dp;
 780         rp = ((t0_context *)t0ctx)->rp;
 781         ip = ((t0_context *)t0ctx)->ip;
 782         for (;;) {
 783                 uint32_t t0x;
 784
 785                 t0x = t0_parse7E_unsigned(&ip);
 786                 if (t0x < T0_INTERPRETED) {
 787                         switch (t0x) {
 788                                 int32_t t0off;
 789
 790                         case 0: /* ret */
 791                                 t0x = T0_RPOP();
 792                                 rp -= (t0x >> 16);
 793                                 t0x &= 0xFFFF;
 794                                 if (t0x == 0) {
 795                                         ip = NULL;
 796                                         goto t0_exit;
 797                                 }
 798                                 ip = &t0_codeblock[t0x];
 799                                 break;
 800                         case 1: /* literal constant */
 801                                 T0_PUSHi(t0_parse7E_signed(&ip));
 802                                 break;
 803                         case 2: /* read local */
 804                                 T0_PUSH(T0_LOCAL(t0_parse7E_unsigned(&ip)));
 805                                 break;
 806                         case 3: /* write local */
 807                                 T0_LOCAL(t0_parse7E_unsigned(&ip)) = T0_POP();
 808                                 break;
 809                         case 4: /* jump */
 810                                 t0off = t0_parse7E_signed(&ip);
 811                                 ip += t0off;
 812                                 break;
 813                         case 5: /* jump if */
 814                                 t0off = t0_parse7E_signed(&ip);
 815                                 if (T0_POP()) {
 816                                         ip += t0off;
 817                                 }
 818                                 break;
 819                         case 6: /* jump if not */
 820                                 t0off = t0_parse7E_signed(&ip);
 821                                 if (!T0_POP()) {
 822                                         ip += t0off;
 823                                 }
 824                                 break;
 825                         case 7: {
 826                                 /* * */
 827
 828         uint32_t b = T0_POP();
 829         uint32_t a = T0_POP();
 830         T0_PUSH(a * b);
 831
 832                                 }
 833                                 break;
 834                         case 8: {
 835                                 /* + */
 836
 837         uint32_t b = T0_POP();
 838         uint32_t a = T0_POP();
 839         T0_PUSH(a + b);
 840
 841                                 }
 842                                 break;
 843                         case 9: {
 844                                 /* - */
 845
 846         uint32_t b = T0_POP();
 847         uint32_t a = T0_POP();
 848         T0_PUSH(a - b);
 849
 850                                 }
 851                                 break;
 852                         case 10: {
 853                                 /* < */
 854
 855         int32_t b = T0_POPi();
 856         int32_t a = T0_POPi();
 857         T0_PUSH(-(uint32_t)(a < b));
 858
 859                                 }
 860                                 break;
 861                         case 11: {
 862                                 /* << */
 863
 864         int c = (int)T0_POPi();
 865         uint32_t x = T0_POP();
 866         T0_PUSH(x << c);
 867
 868                                 }
 869                                 break;
 870                         case 12: {
 871                                 /* <= */
 872
 873         int32_t b = T0_POPi();
 874         int32_t a = T0_POPi();
 875         T0_PUSH(-(uint32_t)(a <= b));
 876
 877                                 }
 878                                 break;
 879                         case 13: {
 880                                 /* <> */
 881
 882         uint32_t b = T0_POP();
 883         uint32_t a = T0_POP();
 884         T0_PUSH(-(uint32_t)(a != b));
 885
 886                                 }
 887                                 break;
 888                         case 14: {
 889                                 /* = */
 890
 891         uint32_t b = T0_POP();
 892         uint32_t a = T0_POP();
 893         T0_PUSH(-(uint32_t)(a == b));
 894
 895                                 }
 896                                 break;
 897                         case 15: {
 898                                 /* > */
 899
 900         int32_t b = T0_POPi();
 901         int32_t a = T0_POPi();
 902         T0_PUSH(-(uint32_t)(a > b));
 903
 904                                 }
 905                                 break;
 906                         case 16: {
 907                                 /* >= */
 908
 909         int32_t b = T0_POPi();
 910         int32_t a = T0_POPi();
 911         T0_PUSH(-(uint32_t)(a >= b));
 912
 913                                 }
 914                                 break;
 915                         case 17: {
 916                                 /* >> */
 917
 918         int c = (int)T0_POPi();
 919         int32_t x = T0_POPi();
 920         T0_PUSHi(x >> c);
 921
 922                                 }
 923                                 break;
 924                         case 18: {
 925                                 /* and */
 926
 927         uint32_t b = T0_POP();
 928         uint32_t a = T0_POP();
 929         T0_PUSH(a & b);
 930
 931                                 }
 932                                 break;
 933                         case 19: {
 934                                 /* begin-cert */
 935
 936         if (CTX->chain_len == 0) {
 937                 T0_PUSHi(-1);
 938         } else {
 939                 CTX->cert_cur = CTX->chain->data;
 940                 CTX->cert_len = CTX->chain->data_len;
 941                 CTX->chain ++;
 942                 CTX->chain_len --;
 943                 T0_PUSH(CTX->cert_len);
 944         }
 945
 946                                 }
 947                                 break;
 948                         case 20: {
 949                                 /* bzero */
 950
 951         size_t len = (size_t)T0_POP();
 952         void *addr = (unsigned char *)ENG + (size_t)T0_POP();
 953         memset(addr, 0, len);
 954
 955                                 }
 956                                 break;
 957                         case 21: {
 958                                 /* call-policy-handler */
 959
 960         int x;
 961         br_ssl_server_choices choices;
 962
 963         x = (*CTX->policy_vtable)->choose(
 964                 CTX->policy_vtable, CTX, &choices);
 965         ENG->session.cipher_suite = choices.cipher_suite;
 966         CTX->sign_hash_id = choices.hash_id;
 967         CTX->chain = choices.chain;
 968         CTX->chain_len = choices.chain_len;
 969         T0_PUSHi(-(x != 0));
 970
 971                                 }
 972                                 break;
 973                         case 22: {
 974                                 /* can-output? */
 975
 976         T0_PUSHi(-(ENG->hlen_out > 0));
 977
 978                                 }
 979                                 break;
 980                         case 23: {
 981                                 /* check-resume */
 982
 983         if (ENG->session.session_id_len == 32
 984                 && CTX->cache_vtable != NULL && (*CTX->cache_vtable)->load(
 985                         CTX->cache_vtable, CTX, &ENG->session))
 986         {
 987                 T0_PUSHi(-1);
 988         } else {
 989                 T0_PUSH(0);
 990         }
 991
 992                                 }
 993                                 break;
 994                         case 24: {
 995                                 /* co */
 996  T0_CO();
 997                                 }
 998                                 break;
 999                         case 25: {
1000                                 /* compute-Finished-inner */
1001
1002         int prf_id = T0_POP();
1003         int from_client = T0_POPi();
1004         unsigned char seed[48];
1005         size_t seed_len;
1006
1007         br_tls_prf_impl prf = br_ssl_engine_get_PRF(ENG, prf_id);
1008         if (ENG->session.version >= BR_TLS12) {
1009                 seed_len = br_multihash_out(&ENG->mhash, prf_id, seed);
1010         } else {
1011                 br_multihash_out(&ENG->mhash, br_md5_ID, seed);
1012                 br_multihash_out(&ENG->mhash, br_sha1_ID, seed + 16);
1013                 seed_len = 36;
1014         }
1015         prf(ENG->pad, 12, ENG->session.master_secret,
1016                 sizeof ENG->session.master_secret,
1017                 from_client ? "client finished" : "server finished",
1018                 seed, seed_len);
1019
1020                                 }
1021                                 break;
1022                         case 26: {
1023                                 /* copy-cert-chunk */
1024
1025         size_t clen;
1026
1027         clen = CTX->cert_len;
1028         if (clen > sizeof ENG->pad) {
1029                 clen = sizeof ENG->pad;
1030         }
1031         memcpy(ENG->pad, CTX->cert_cur, clen);
1032         CTX->cert_cur += clen;
1033         CTX->cert_len -= clen;
1034         T0_PUSH(clen);
1035
1036                                 }
1037                                 break;
1038                         case 27: {
1039                                 /* data-get8 */
1040
1041         size_t addr = T0_POP();
1042         T0_PUSH(t0_datablock[addr]);
1043
1044                                 }
1045                                 break;
1046                         case 28: {
1047                                 /* discard-input */
1048
1049         ENG->hlen_in = 0;
1050
1051                                 }
1052                                 break;
1053                         case 29: {
1054                                 /* do-ecdh */
1055
1056         int prf_id = T0_POPi();
1057         size_t len = T0_POP();
1058         do_ecdh(CTX, prf_id, ENG->pad, len);
1059
1060                                 }
1061                                 break;
1062                         case 30: {
1063                                 /* do-ecdhe-part1 */
1064
1065         int curve = T0_POPi();
1066         T0_PUSHi(do_ecdhe_part1(CTX, curve));
1067
1068                                 }
1069                                 break;
1070                         case 31: {
1071                                 /* do-ecdhe-part2 */
1072
1073         int prf_id = T0_POPi();
1074         size_t len = T0_POP();
1075         do_ecdhe_part2(CTX, prf_id, ENG->pad, len);
1076
1077                                 }
1078                                 break;
1079                         case 32: {
1080                                 /* do-rsa-decrypt */
1081
1082         int prf_id = T0_POPi();
1083         size_t len = T0_POP();
1084         do_rsa_decrypt(CTX, prf_id, ENG->pad, len);
1085
1086                                 }
1087                                 break;
1088                         case 33: {
1089                                 /* drop */
1090  (void)T0_POP();
1091                                 }
1092                                 break;
1093                         case 34: {
1094                                 /* dup */
1095  T0_PUSH(T0_PEEK(0));
1096                                 }
1097                                 break;
1098                         case 35: {
1099                                 /* fail */
1100
1101         br_ssl_engine_fail(ENG, (int)T0_POPi());
1102         T0_CO();
1103
1104                                 }
1105                                 break;
1106                         case 36: {
1107                                 /* flush-record */
1108
1109         br_ssl_engine_flush_record(ENG);
1110
1111                                 }
1112                                 break;
1113                         case 37: {
1114                                 /* get16 */
1115
1116         size_t addr = (size_t)T0_POP();
1117         T0_PUSH(*(uint16_t *)((unsigned char *)ENG + addr));
1118
1119                                 }
1120                                 break;
1121                         case 38: {
1122                                 /* get32 */
1123
1124         size_t addr = (size_t)T0_POP();
1125         T0_PUSH(*(uint32_t *)((unsigned char *)ENG + addr));
1126
1127                                 }
1128                                 break;
1129                         case 39: {
1130                                 /* get8 */
1131
1132         size_t addr = (size_t)T0_POP();
1133         T0_PUSH(*((unsigned char *)ENG + addr));
1134
1135                                 }
1136                                 break;
1137                         case 40: {
1138                                 /* has-input? */
1139
1140         T0_PUSHi(-(ENG->hlen_in != 0));
1141
1142                                 }
1143                                 break;
1144                         case 41: {
1145                                 /* memcmp */
1146
1147         size_t len = (size_t)T0_POP();
1148         void *addr2 = (unsigned char *)ENG + (size_t)T0_POP();
1149         void *addr1 = (unsigned char *)ENG + (size_t)T0_POP();
1150         int x = memcmp(addr1, addr2, len);
1151         T0_PUSH((uint32_t)-(x == 0));
1152
1153                                 }
1154                                 break;
1155                         case 42: {
1156                                 /* memcpy */
1157
1158         size_t len = (size_t)T0_POP();
1159         void *src = (unsigned char *)ENG + (size_t)T0_POP();
1160         void *dst = (unsigned char *)ENG + (size_t)T0_POP();
1161         memcpy(dst, src, len);
1162
1163                                 }
1164                                 break;
1165                         case 43: {
1166                                 /* mkrand */
1167
1168         size_t len = (size_t)T0_POP();
1169         void *addr = (unsigned char *)ENG + (size_t)T0_POP();
1170         br_hmac_drbg_generate(&ENG->rng, addr, len);
1171
1172                                 }
1173                                 break;
1174                         case 44: {
1175                                 /* more-incoming-bytes? */
1176
1177         T0_PUSHi(ENG->hlen_in != 0 || !br_ssl_engine_recvrec_finished(ENG));
1178
1179                                 }
1180                                 break;
1181                         case 45: {
1182                                 /* multihash-init */
1183
1184         br_multihash_init(&ENG->mhash);
1185
1186                                 }
1187                                 break;
1188                         case 46: {
1189                                 /* neg */
1190
1191         uint32_t a = T0_POP();
1192         T0_PUSH(-a);
1193
1194                                 }
1195                                 break;
1196                         case 47: {
1197                                 /* not */
1198
1199         uint32_t a = T0_POP();
1200         T0_PUSH(~a);
1201
1202                                 }
1203                                 break;
1204                         case 48: {
1205                                 /* or */
1206
1207         uint32_t b = T0_POP();
1208         uint32_t a = T0_POP();
1209         T0_PUSH(a | b);
1210
1211                                 }
1212                                 break;
1213                         case 49: {
1214                                 /* over */
1215  T0_PUSH(T0_PEEK(1));
1216                                 }
1217                                 break;
1218                         case 50: {
1219                                 /* read-chunk-native */
1220
1221         size_t clen = ENG->hlen_in;
1222         if (clen > 0) {
1223                 uint32_t addr, len;
1224
1225                 len = T0_POP();
1226                 addr = T0_POP();
1227                 if ((size_t)len < clen) {
1228                         clen = (size_t)len;
1229                 }
1230                 memcpy((unsigned char *)ENG + addr, ENG->hbuf_in, clen);
1231                 if (ENG->record_type_in == BR_SSL_HANDSHAKE) {
1232                         br_multihash_update(&ENG->mhash, ENG->hbuf_in, clen);
1233                 }
1234                 T0_PUSH(addr + (uint32_t)clen);
1235                 T0_PUSH(len - (uint32_t)clen);
1236                 ENG->hbuf_in += clen;
1237                 ENG->hlen_in -= clen;
1238         }
1239
1240                                 }
1241                                 break;
1242                         case 51: {
1243                                 /* read8-native */
1244
1245         if (ENG->hlen_in > 0) {
1246                 unsigned char x;
1247
1248                 x = *ENG->hbuf_in ++;
1249                 if (ENG->record_type_in == BR_SSL_HANDSHAKE) {
1250                         br_multihash_update(&ENG->mhash, &x, 1);
1251                 }
1252                 T0_PUSH(x);
1253                 ENG->hlen_in --;
1254         } else {
1255                 T0_PUSHi(-1);
1256         }
1257
1258                                 }
1259                                 break;
1260                         case 52: {
1261                                 /* save-session */
1262
1263         if (CTX->cache_vtable != NULL) {
1264                 (*CTX->cache_vtable)->save(
1265                         CTX->cache_vtable, CTX, &ENG->session);
1266         }
1267
1268                                 }
1269                                 break;
1270                         case 53: {
1271                                 /* set-max-frag-len */
1272
1273         size_t max_frag_len = T0_POP();
1274
1275         br_ssl_engine_new_max_frag_len(ENG, max_frag_len);
1276
1277         /*
1278          * We must adjust our own output limit. Since we call this only
1279          * after receiving a ClientHello and before beginning to send
1280          * the ServerHello, the next output record should be empty at
1281          * that point, so we can use max_frag_len as a limit.
1282          */
1283         if (ENG->hlen_out > max_frag_len) {
1284                 ENG->hlen_out = max_frag_len;
1285         }
1286
1287                                 }
1288                                 break;
1289                         case 54: {
1290                                 /* set16 */
1291
1292         size_t addr = (size_t)T0_POP();
1293         *(uint16_t *)((unsigned char *)ENG + addr) = (uint16_t)T0_POP();
1294
1295                                 }
1296                                 break;
1297                         case 55: {
1298                                 /* set32 */
1299
1300         size_t addr = (size_t)T0_POP();
1301         *(uint32_t *)((unsigned char *)ENG + addr) = (uint32_t)T0_POP();
1302
1303                                 }
1304                                 break;
1305                         case 56: {
1306                                 /* set8 */
1307
1308         size_t addr = (size_t)T0_POP();
1309         *((unsigned char *)ENG + addr) = (unsigned char)T0_POP();
1310
1311                                 }
1312                                 break;
1313                         case 57: {
1314                                 /* supported-curves */
1315
1316         uint32_t x = ENG->iec == NULL ? 0 : ENG->iec->supported_curves;
1317         T0_PUSH(x);
1318
1319                                 }
1320                                 break;
1321                         case 58: {
1322                                 /* supported-hash-functions */
1323
1324         int i;
1325         unsigned x, num;
1326
1327         x = 0;
1328         num = 0;
1329         for (i = br_sha1_ID; i <= br_sha512_ID; i ++) {
1330                 if (br_multihash_getimpl(&ENG->mhash, i)) {
1331                         x |= 1U << i;
1332                         num ++;
1333                 }
1334         }
1335         T0_PUSH(x);
1336         T0_PUSH(num);
1337
1338                                 }
1339                                 break;
1340                         case 59: {
1341                                 /* swap */
1342  T0_SWAP();
1343                                 }
1344                                 break;
1345                         case 60: {
1346                                 /* switch-aesgcm-in */
1347
1348         int is_client, prf_id;
1349         unsigned cipher_key_len;
1350
1351         cipher_key_len = T0_POP();
1352         prf_id = T0_POP();
1353         is_client = T0_POP();
1354         br_ssl_engine_switch_gcm_in(ENG, is_client, prf_id,
1355                 ENG->iaes_ctr, cipher_key_len);
1356
1357                                 }
1358                                 break;
1359                         case 61: {
1360                                 /* switch-aesgcm-out */
1361
1362         int is_client, prf_id;
1363         unsigned cipher_key_len;
1364
1365         cipher_key_len = T0_POP();
1366         prf_id = T0_POP();
1367         is_client = T0_POP();
1368         br_ssl_engine_switch_gcm_out(ENG, is_client, prf_id,
1369                 ENG->iaes_ctr, cipher_key_len);
1370
1371                                 }
1372                                 break;
1373                         case 62: {
1374                                 /* switch-cbc-in */
1375
1376         int is_client, prf_id, mac_id, aes;
1377         unsigned cipher_key_len;
1378
1379         cipher_key_len = T0_POP();
1380         aes = T0_POP();
1381         mac_id = T0_POP();
1382         prf_id = T0_POP();
1383         is_client = T0_POP();
1384         br_ssl_engine_switch_cbc_in(ENG, is_client, prf_id, mac_id,
1385                 aes ? ENG->iaes_cbcdec : ENG->ides_cbcdec, cipher_key_len);
1386
1387                                 }
1388                                 break;
1389                         case 63: {
1390                                 /* switch-cbc-out */
1391
1392         int is_client, prf_id, mac_id, aes;
1393         unsigned cipher_key_len;
1394
1395         cipher_key_len = T0_POP();
1396         aes = T0_POP();
1397         mac_id = T0_POP();
1398         prf_id = T0_POP();
1399         is_client = T0_POP();
1400         br_ssl_engine_switch_cbc_out(ENG, is_client, prf_id, mac_id,
1401                 aes ? ENG->iaes_cbcenc : ENG->ides_cbcenc, cipher_key_len);
1402
1403                                 }
1404                                 break;
1405                         case 64: {
1406                                 /* total-chain-length */
1407
1408         size_t u;
1409         uint32_t total;
1410
1411         total = 0;
1412         for (u = 0; u < CTX->chain_len; u ++) {
1413                 total += 3 + (uint32_t)CTX->chain[u].data_len;
1414         }
1415         T0_PUSH(total);
1416
1417                                 }
1418                                 break;
1419                         case 65: {
1420                                 /* u>> */
1421
1422         int c = (int)T0_POPi();
1423         uint32_t x = T0_POP();
1424         T0_PUSH(x >> c);
1425
1426                                 }
1427                                 break;
1428                         case 66: {
1429                                 /* write-blob-chunk */
1430
1431         size_t clen = ENG->hlen_out;
1432         if (clen > 0) {
1433                 uint32_t addr, len;
1434
1435                 len = T0_POP();
1436                 addr = T0_POP();
1437                 if ((size_t)len < clen) {
1438                         clen = (size_t)len;
1439                 }
1440                 memcpy(ENG->hbuf_out, (unsigned char *)ENG + addr, clen);
1441                 if (ENG->record_type_out == BR_SSL_HANDSHAKE) {
1442                         br_multihash_update(&ENG->mhash, ENG->hbuf_out, clen);
1443                 }
1444                 T0_PUSH(addr + (uint32_t)clen);
1445                 T0_PUSH(len - (uint32_t)clen);
1446                 ENG->hbuf_out += clen;
1447                 ENG->hlen_out -= clen;
1448         }
1449
1450                                 }
1451                                 break;
1452                         case 67: {
1453                                 /* write8-native */
1454
1455         unsigned char x;
1456
1457         x = (unsigned char)T0_POP();
1458         if (ENG->hlen_out > 0) {
1459                 if (ENG->record_type_out == BR_SSL_HANDSHAKE) {
1460                         br_multihash_update(&ENG->mhash, &x, 1);
1461                 }
1462                 *ENG->hbuf_out ++ = x;
1463                 ENG->hlen_out --;
1464                 T0_PUSHi(-1);
1465         } else {
1466                 T0_PUSHi(0);
1467         }
1468
1469                                 }
1470                                 break;
1471                         }
1472
1473                 } else {
1474                         T0_ENTER(ip, rp, t0x);
1475                 }
1476         }
1477 t0_exit:
1478         ((t0_context *)t0ctx)->dp = dp;
1479         ((t0_context *)t0ctx)->rp = rp;
1480         ((t0_context *)t0ctx)->ip = ip;
1481 }