test/modes_internal_test.c

   1 /*
   2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /* Internal tests for the modes module */
  11
  12 #include <stdio.h>
  13 #include <string.h>
  14
  15 #include <openssl/aes.h>
  16 #include <openssl/modes.h>
  17 #include "../crypto/modes/modes_lcl.h"
  18 #include "testutil.h"
  19 #include "e_os.h"
  20
  21 typedef struct {
  22     size_t size;
  23     const unsigned char *data;
  24 }  SIZED_DATA;
  25
  26 /**********************************************************************
  27  *
  28  * Test of cts128
  29  *
  30  ***/
  31
  32 /* cts128 test vectors from RFC 3962 */
  33 static const unsigned char cts128_test_key[16] = "chicken teriyaki";
  34 static const unsigned char cts128_test_input[64] =
  35     "I would like the" " General Gau's C"
  36     "hicken, please, " "and wonton soup.";
  37 static const unsigned char cts128_test_iv[] =
  38     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  39
  40 static const unsigned char vector_17[17] = {
  41     0xc6, 0x35, 0x35, 0x68, 0xf2, 0xbf, 0x8c, 0xb4,
  42     0xd8, 0xa5, 0x80, 0x36, 0x2d, 0xa7, 0xff, 0x7f,
  43     0x97
  44 };
  45
  46 static const unsigned char vector_31[31] = {
  47     0xfc, 0x00, 0x78, 0x3e, 0x0e, 0xfd, 0xb2, 0xc1,
  48     0xd4, 0x45, 0xd4, 0xc8, 0xef, 0xf7, 0xed, 0x22,
  49     0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
  50     0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5
  51 };
  52
  53 static const unsigned char vector_32[32] = {
  54     0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
  55     0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5, 0xa8,
  56     0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
  57     0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5, 0x84
  58 };
  59
  60 static const unsigned char vector_47[47] = {
  61     0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
  62     0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5, 0x84,
  63     0xb3, 0xff, 0xfd, 0x94, 0x0c, 0x16, 0xa1, 0x8c,
  64     0x1b, 0x55, 0x49, 0xd2, 0xf8, 0x38, 0x02, 0x9e,
  65     0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
  66     0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5
  67 };
  68
  69 static const unsigned char vector_48[48] = {
  70     0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
  71     0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5, 0x84,
  72     0x9d, 0xad, 0x8b, 0xbb, 0x96, 0xc4, 0xcd, 0xc0,
  73     0x3b, 0xc1, 0x03, 0xe1, 0xa1, 0x94, 0xbb, 0xd8,
  74     0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
  75     0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5, 0xa8
  76 };
  77
  78 static const unsigned char vector_64[64] = {
  79     0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
  80     0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5, 0x84,
  81     0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
  82     0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5, 0xa8,
  83     0x48, 0x07, 0xef, 0xe8, 0x36, 0xee, 0x89, 0xa5,
  84     0x26, 0x73, 0x0d, 0xbc, 0x2f, 0x7b, 0xc8, 0x40,
  85     0x9d, 0xad, 0x8b, 0xbb, 0x96, 0xc4, 0xcd, 0xc0,
  86     0x3b, 0xc1, 0x03, 0xe1, 0xa1, 0x94, 0xbb, 0xd8
  87 };
  88
  89 #define CTS128_TEST_VECTOR(len)                 \
  90     {                                           \
  91         sizeof(vector_##len), vector_##len      \
  92     }
  93 static const SIZED_DATA cts128_vectors[] = {
  94     CTS128_TEST_VECTOR(17),
  95     CTS128_TEST_VECTOR(31),
  96     CTS128_TEST_VECTOR(32),
  97     CTS128_TEST_VECTOR(47),
  98     CTS128_TEST_VECTOR(48),
  99     CTS128_TEST_VECTOR(64),
 100 };
 101
 102 static AES_KEY *cts128_encrypt_key_schedule()
 103 {
 104     static int init_key = 1;
 105     static AES_KEY ks;
 106
 107     if (init_key) {
 108         AES_set_encrypt_key(cts128_test_key, 128, &ks);
 109         init_key = 0;
 110     }
 111     return &ks;
 112 }
 113
 114 static AES_KEY *cts128_decrypt_key_schedule()
 115 {
 116     static int init_key = 1;
 117     static AES_KEY ks;
 118
 119     if (init_key) {
 120         AES_set_decrypt_key(cts128_test_key, 128, &ks);
 121         init_key = 0;
 122     }
 123     return &ks;
 124 }
 125
 126 typedef struct {
 127     const char *case_name;
 128     int num;
 129     size_t (*transform_output)(const unsigned char *in, unsigned char *out,
 130                                size_t len);
 131     size_t (*encrypt_block)(const unsigned char *in,
 132                             unsigned char *out, size_t len,
 133                             const void *key, unsigned char ivec[16],
 134                             block128_f block);
 135     size_t (*encrypt)(const unsigned char *in, unsigned char *out,
 136                       size_t len, const void *key,
 137                       unsigned char ivec[16], cbc128_f cbc);
 138     size_t (*decrypt_block)(const unsigned char *in,
 139                             unsigned char *out, size_t len,
 140                             const void *key, unsigned char ivec[16],
 141                             block128_f block);
 142     size_t (*decrypt)(const unsigned char *in, unsigned char *out,
 143                       size_t len, const void *key,
 144                       unsigned char ivec[16], cbc128_f cbc);
 145 } CTS128_FIXTURE;
 146
 147
 148 static CTS128_FIXTURE setup_cts128(const char *const test_case_name)
 149 {
 150     CTS128_FIXTURE fixture;
 151     fixture.case_name = test_case_name;
 152     return fixture;
 153 }
 154
 155 static size_t transform_output(const unsigned char *in, unsigned char *out,
 156                                size_t len)
 157 {
 158     size_t tail;
 159
 160     memcpy(out, in, len);
 161     if ((tail = len % 16) == 0)
 162         tail = 16;
 163     tail += 16;
 164
 165     return tail;
 166 }
 167
 168 static size_t transform_output_nist(const unsigned char *in, unsigned char *out,
 169                                     size_t len)
 170 {
 171     size_t tail;
 172
 173     if ((tail = len % 16) == 0)
 174         tail = 16;
 175     len -= 16 + tail;
 176     memcpy(out, in, len);
 177     /* flip two last blocks */
 178     memcpy(out + len, in + len + 16, tail);
 179     memcpy(out + len + tail, in + len, 16);
 180     len += 16 + tail;
 181     tail = 16;
 182
 183     return tail;
 184 }
 185
 186 static int execute_cts128(CTS128_FIXTURE fixture)
 187 {
 188     const unsigned char *test_iv = cts128_test_iv;
 189     size_t test_iv_len = sizeof(cts128_test_iv);
 190     const unsigned char *orig_vector = cts128_vectors[fixture.num].data;
 191     size_t len = cts128_vectors[fixture.num].size;
 192     const unsigned char *test_input = cts128_test_input;
 193     const AES_KEY *encrypt_key_schedule = cts128_encrypt_key_schedule();
 194     const AES_KEY *decrypt_key_schedule = cts128_decrypt_key_schedule();
 195     unsigned char iv[16];
 196     /* The largest test inputs are = 64 bytes. */
 197     unsigned char cleartext[64], ciphertext[64], vector[64];
 198     size_t tail;
 199
 200     fprintf(stderr, "%s_vector_%" OSSLzu "\n", fixture.case_name, len);
 201     fflush(stdout);
 202
 203     tail = fixture.transform_output(orig_vector, vector, len);
 204
 205     /* test block-based encryption */
 206     memcpy(iv, test_iv, test_iv_len);
 207     fixture.encrypt_block(test_input, ciphertext, len,
 208                           encrypt_key_schedule, iv,
 209                           (block128_f)AES_encrypt);
 210     if (memcmp(ciphertext, vector, len)) {
 211         fprintf(stderr, "block encrypt: output_%" OSSLzu " mismatch\n", len);
 212         return 0;
 213     }
 214     if (memcmp(iv, vector + len - tail, sizeof(iv))) {
 215         fprintf(stderr, "block encrypt: iv_%" OSSLzu " mismatch\n", len);
 216         return 0;
 217     }
 218
 219     /* test block-based decryption */
 220     memcpy(iv, test_iv, test_iv_len);
 221     fixture.decrypt_block(ciphertext, cleartext, len,
 222                           decrypt_key_schedule, iv,
 223                           (block128_f)AES_decrypt);
 224     if (memcmp(cleartext, test_input, len)) {
 225         fprintf(stderr, "block decrypt: input_%" OSSLzu " mismatch\n", len);
 226         return 0;
 227     }
 228     if (memcmp(iv, vector + len - tail, sizeof(iv))) {
 229         fprintf(stderr, "block decrypt: iv_%" OSSLzu " mismatch\n", len);
 230         return 0;
 231     }
 232
 233     /* test streamed encryption */
 234     memcpy(iv, test_iv, test_iv_len);
 235     fixture.encrypt(test_input, ciphertext, len, encrypt_key_schedule,
 236                     iv, (cbc128_f) AES_cbc_encrypt);
 237     if (memcmp(ciphertext, vector, len)) {
 238         fprintf(stderr, "stream encrypt: output_%" OSSLzu " mismatch\n", len);
 239         return 0;
 240     }
 241     if (memcmp(iv, vector + len - tail, sizeof(iv))) {
 242         fprintf(stderr, "stream encrypt: iv_%" OSSLzu " mismatch\n", len);
 243         return 0;
 244     }
 245
 246     /* test streamed decryption */
 247     memcpy(iv, test_iv, test_iv_len);
 248     fixture.decrypt(ciphertext, cleartext, len, decrypt_key_schedule, iv,
 249                     (cbc128_f)AES_cbc_encrypt);
 250     if (memcmp(cleartext, test_input, len)) {
 251         fprintf(stderr, "stream decrypt: input_%" OSSLzu " mismatch\n", len);
 252         return 0;
 253     }
 254     if (memcmp(iv, vector + len - tail, sizeof(iv))) {
 255         fprintf(stderr, "stream decrypt: iv_%" OSSLzu " mismatch\n", len);
 256         return 0;
 257     }
 258
 259     return 1;
 260 }
 261
 262 static int test_cts128(int idx)
 263 {
 264     SETUP_TEST_FIXTURE(CTS128_FIXTURE, setup_cts128);
 265     fixture.transform_output = transform_output;
 266     fixture.encrypt_block = CRYPTO_cts128_encrypt_block;
 267     fixture.encrypt = CRYPTO_cts128_encrypt;
 268     fixture.decrypt_block = CRYPTO_cts128_decrypt_block;
 269     fixture.decrypt = CRYPTO_cts128_decrypt;
 270     fixture.case_name = "cts128";
 271     fixture.num = idx;
 272     EXECUTE_TEST_NO_TEARDOWN(execute_cts128);
 273 }
 274
 275 static int test_cts128_nist(int idx)
 276 {
 277     SETUP_TEST_FIXTURE(CTS128_FIXTURE, setup_cts128);
 278     fixture.transform_output = transform_output_nist;
 279     fixture.encrypt_block = CRYPTO_nistcts128_encrypt_block;
 280     fixture.encrypt = CRYPTO_nistcts128_encrypt;
 281     fixture.decrypt_block = CRYPTO_nistcts128_decrypt_block;
 282     fixture.decrypt = CRYPTO_nistcts128_decrypt;
 283     fixture.case_name = "cts128_nist";
 284     fixture.num = idx;
 285     EXECUTE_TEST_NO_TEARDOWN(execute_cts128);
 286 }
 287
 288 /**********************************************************************
 289  *
 290  * Test of gcm128
 291  *
 292  ***/
 293
 294 /* Test Case 1 */
 295 static const u8 K1[16], P1[] = { 0 }, A1[] = { 0 }, IV1[12], C1[] = { 0 };
 296 static const u8 T1[] = {
 297     0x58, 0xe2, 0xfc, 0xce, 0xfa, 0x7e, 0x30, 0x61,
 298     0x36, 0x7f, 0x1d, 0x57, 0xa4, 0xe7, 0x45, 0x5a
 299 };
 300
 301 /* Test Case 2 */
 302 # define K2 K1
 303 # define A2 A1
 304 # define IV2 IV1
 305 static const u8 P2[16];
 306 static const u8 C2[] = {
 307     0x03, 0x88, 0xda, 0xce, 0x60, 0xb6, 0xa3, 0x92,
 308     0xf3, 0x28, 0xc2, 0xb9, 0x71, 0xb2, 0xfe, 0x78
 309 };
 310
 311 static const u8 T2[] = {
 312     0xab, 0x6e, 0x47, 0xd4, 0x2c, 0xec, 0x13, 0xbd,
 313     0xf5, 0x3a, 0x67, 0xb2, 0x12, 0x57, 0xbd, 0xdf
 314 };
 315
 316 /* Test Case 3 */
 317 # define A3 A2
 318 static const u8 K3[] = {
 319     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
 320     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
 321 };
 322
 323 static const u8 P3[] = {
 324     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
 325     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
 326     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
 327     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
 328     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
 329     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
 330     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
 331     0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55
 332 };
 333
 334 static const u8 IV3[] = {
 335     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
 336     0xde, 0xca, 0xf8, 0x88
 337 };
 338
 339 static const u8 C3[] = {
 340     0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
 341     0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
 342     0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0,
 343     0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e,
 344     0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c,
 345     0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05,
 346     0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97,
 347     0x3d, 0x58, 0xe0, 0x91, 0x47, 0x3f, 0x59, 0x85
 348 };
 349
 350 static const u8 T3[] = {
 351     0x4d, 0x5c, 0x2a, 0xf3, 0x27, 0xcd, 0x64, 0xa6,
 352     0x2c, 0xf3, 0x5a, 0xbd, 0x2b, 0xa6, 0xfa, 0xb4
 353 };
 354
 355 /* Test Case 4 */
 356 # define K4 K3
 357 # define IV4 IV3
 358 static const u8 P4[] = {
 359     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
 360     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
 361     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
 362     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
 363     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
 364     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
 365     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
 366     0xba, 0x63, 0x7b, 0x39
 367 };
 368
 369 static const u8 A4[] = {
 370     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
 371     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
 372     0xab, 0xad, 0xda, 0xd2
 373 };
 374
 375 static const u8 C4[] = {
 376     0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
 377     0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
 378     0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0,
 379     0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e,
 380     0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c,
 381     0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05,
 382     0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97,
 383     0x3d, 0x58, 0xe0, 0x91
 384 };
 385
 386 static const u8 T4[] = {
 387     0x5b, 0xc9, 0x4f, 0xbc, 0x32, 0x21, 0xa5, 0xdb,
 388     0x94, 0xfa, 0xe9, 0x5a, 0xe7, 0x12, 0x1a, 0x47
 389 };
 390
 391 /* Test Case 5 */
 392 # define K5 K4
 393 # define P5 P4
 394 # define A5 A4
 395 static const u8 IV5[] = {
 396     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad
 397 };
 398
 399 static const u8 C5[] = {
 400     0x61, 0x35, 0x3b, 0x4c, 0x28, 0x06, 0x93, 0x4a,
 401     0x77, 0x7f, 0xf5, 0x1f, 0xa2, 0x2a, 0x47, 0x55,
 402     0x69, 0x9b, 0x2a, 0x71, 0x4f, 0xcd, 0xc6, 0xf8,
 403     0x37, 0x66, 0xe5, 0xf9, 0x7b, 0x6c, 0x74, 0x23,
 404     0x73, 0x80, 0x69, 0x00, 0xe4, 0x9f, 0x24, 0xb2,
 405     0x2b, 0x09, 0x75, 0x44, 0xd4, 0x89, 0x6b, 0x42,
 406     0x49, 0x89, 0xb5, 0xe1, 0xeb, 0xac, 0x0f, 0x07,
 407     0xc2, 0x3f, 0x45, 0x98
 408 };
 409
 410 static const u8 T5[] = {
 411     0x36, 0x12, 0xd2, 0xe7, 0x9e, 0x3b, 0x07, 0x85,
 412     0x56, 0x1b, 0xe1, 0x4a, 0xac, 0xa2, 0xfc, 0xcb
 413 };
 414
 415 /* Test Case 6 */
 416 # define K6 K5
 417 # define P6 P5
 418 # define A6 A5
 419 static const u8 IV6[] = {
 420     0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
 421     0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
 422     0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
 423     0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
 424     0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
 425     0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
 426     0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
 427     0xa6, 0x37, 0xb3, 0x9b
 428 };
 429
 430 static const u8 C6[] = {
 431     0x8c, 0xe2, 0x49, 0x98, 0x62, 0x56, 0x15, 0xb6,
 432     0x03, 0xa0, 0x33, 0xac, 0xa1, 0x3f, 0xb8, 0x94,
 433     0xbe, 0x91, 0x12, 0xa5, 0xc3, 0xa2, 0x11, 0xa8,
 434     0xba, 0x26, 0x2a, 0x3c, 0xca, 0x7e, 0x2c, 0xa7,
 435     0x01, 0xe4, 0xa9, 0xa4, 0xfb, 0xa4, 0x3c, 0x90,
 436     0xcc, 0xdc, 0xb2, 0x81, 0xd4, 0x8c, 0x7c, 0x6f,
 437     0xd6, 0x28, 0x75, 0xd2, 0xac, 0xa4, 0x17, 0x03,
 438     0x4c, 0x34, 0xae, 0xe5
 439 };
 440
 441 static const u8 T6[] = {
 442     0x61, 0x9c, 0xc5, 0xae, 0xff, 0xfe, 0x0b, 0xfa,
 443     0x46, 0x2a, 0xf4, 0x3c, 0x16, 0x99, 0xd0, 0x50
 444 };
 445
 446 /* Test Case 7 */
 447 static const u8 K7[24], P7[] = { 0 }, A7[] = { 0 }, IV7[12], C7[] = { 0 };
 448 static const u8 T7[] = {
 449     0xcd, 0x33, 0xb2, 0x8a, 0xc7, 0x73, 0xf7, 0x4b,
 450     0xa0, 0x0e, 0xd1, 0xf3, 0x12, 0x57, 0x24, 0x35
 451 };
 452
 453 /* Test Case 8 */
 454 # define K8 K7
 455 # define IV8 IV7
 456 # define A8 A7
 457 static const u8 P8[16];
 458 static const u8 C8[] = {
 459     0x98, 0xe7, 0x24, 0x7c, 0x07, 0xf0, 0xfe, 0x41,
 460     0x1c, 0x26, 0x7e, 0x43, 0x84, 0xb0, 0xf6, 0x00
 461 };
 462
 463 static const u8 T8[] = {
 464     0x2f, 0xf5, 0x8d, 0x80, 0x03, 0x39, 0x27, 0xab,
 465     0x8e, 0xf4, 0xd4, 0x58, 0x75, 0x14, 0xf0, 0xfb
 466 };
 467
 468 /* Test Case 9 */
 469 # define A9 A8
 470 static const u8 K9[] = {
 471     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
 472     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08,
 473     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c
 474 };
 475
 476 static const u8 P9[] = {
 477     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
 478     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
 479     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
 480     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
 481     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
 482     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
 483     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
 484     0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55
 485 };
 486
 487 static const u8 IV9[] = {
 488     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
 489     0xde, 0xca, 0xf8, 0x88
 490 };
 491
 492 static const u8 C9[] = {
 493     0x39, 0x80, 0xca, 0x0b, 0x3c, 0x00, 0xe8, 0x41,
 494     0xeb, 0x06, 0xfa, 0xc4, 0x87, 0x2a, 0x27, 0x57,
 495     0x85, 0x9e, 0x1c, 0xea, 0xa6, 0xef, 0xd9, 0x84,
 496     0x62, 0x85, 0x93, 0xb4, 0x0c, 0xa1, 0xe1, 0x9c,
 497     0x7d, 0x77, 0x3d, 0x00, 0xc1, 0x44, 0xc5, 0x25,
 498     0xac, 0x61, 0x9d, 0x18, 0xc8, 0x4a, 0x3f, 0x47,
 499     0x18, 0xe2, 0x44, 0x8b, 0x2f, 0xe3, 0x24, 0xd9,
 500     0xcc, 0xda, 0x27, 0x10, 0xac, 0xad, 0xe2, 0x56
 501 };
 502
 503 static const u8 T9[] = {
 504     0x99, 0x24, 0xa7, 0xc8, 0x58, 0x73, 0x36, 0xbf,
 505     0xb1, 0x18, 0x02, 0x4d, 0xb8, 0x67, 0x4a, 0x14
 506 };
 507
 508 /* Test Case 10 */
 509 # define K10 K9
 510 # define IV10 IV9
 511 static const u8 P10[] = {
 512     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
 513     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
 514     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
 515     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
 516     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
 517     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
 518     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
 519     0xba, 0x63, 0x7b, 0x39
 520 };
 521
 522 static const u8 A10[] = {
 523     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
 524     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
 525     0xab, 0xad, 0xda, 0xd2
 526 };
 527
 528 static const u8 C10[] = {
 529     0x39, 0x80, 0xca, 0x0b, 0x3c, 0x00, 0xe8, 0x41,
 530     0xeb, 0x06, 0xfa, 0xc4, 0x87, 0x2a, 0x27, 0x57,
 531     0x85, 0x9e, 0x1c, 0xea, 0xa6, 0xef, 0xd9, 0x84,
 532     0x62, 0x85, 0x93, 0xb4, 0x0c, 0xa1, 0xe1, 0x9c,
 533     0x7d, 0x77, 0x3d, 0x00, 0xc1, 0x44, 0xc5, 0x25,
 534     0xac, 0x61, 0x9d, 0x18, 0xc8, 0x4a, 0x3f, 0x47,
 535     0x18, 0xe2, 0x44, 0x8b, 0x2f, 0xe3, 0x24, 0xd9,
 536     0xcc, 0xda, 0x27, 0x10
 537 };
 538
 539 static const u8 T10[] = {
 540     0x25, 0x19, 0x49, 0x8e, 0x80, 0xf1, 0x47, 0x8f,
 541     0x37, 0xba, 0x55, 0xbd, 0x6d, 0x27, 0x61, 0x8c
 542 };
 543
 544 /* Test Case 11 */
 545 # define K11 K10
 546 # define P11 P10
 547 # define A11 A10
 548 static const u8 IV11[] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad };
 549
 550 static const u8 C11[] = {
 551     0x0f, 0x10, 0xf5, 0x99, 0xae, 0x14, 0xa1, 0x54,
 552     0xed, 0x24, 0xb3, 0x6e, 0x25, 0x32, 0x4d, 0xb8,
 553     0xc5, 0x66, 0x63, 0x2e, 0xf2, 0xbb, 0xb3, 0x4f,
 554     0x83, 0x47, 0x28, 0x0f, 0xc4, 0x50, 0x70, 0x57,
 555     0xfd, 0xdc, 0x29, 0xdf, 0x9a, 0x47, 0x1f, 0x75,
 556     0xc6, 0x65, 0x41, 0xd4, 0xd4, 0xda, 0xd1, 0xc9,
 557     0xe9, 0x3a, 0x19, 0xa5, 0x8e, 0x8b, 0x47, 0x3f,
 558     0xa0, 0xf0, 0x62, 0xf7
 559 };
 560
 561 static const u8 T11[] = {
 562     0x65, 0xdc, 0xc5, 0x7f, 0xcf, 0x62, 0x3a, 0x24,
 563     0x09, 0x4f, 0xcc, 0xa4, 0x0d, 0x35, 0x33, 0xf8
 564 };
 565
 566 /* Test Case 12 */
 567 # define K12 K11
 568 # define P12 P11
 569 # define A12 A11
 570 static const u8 IV12[] = {
 571     0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
 572     0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
 573     0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
 574     0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
 575     0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
 576     0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
 577     0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
 578     0xa6, 0x37, 0xb3, 0x9b
 579 };
 580
 581 static const u8 C12[] = {
 582     0xd2, 0x7e, 0x88, 0x68, 0x1c, 0xe3, 0x24, 0x3c,
 583     0x48, 0x30, 0x16, 0x5a, 0x8f, 0xdc, 0xf9, 0xff,
 584     0x1d, 0xe9, 0xa1, 0xd8, 0xe6, 0xb4, 0x47, 0xef,
 585     0x6e, 0xf7, 0xb7, 0x98, 0x28, 0x66, 0x6e, 0x45,
 586     0x81, 0xe7, 0x90, 0x12, 0xaf, 0x34, 0xdd, 0xd9,
 587     0xe2, 0xf0, 0x37, 0x58, 0x9b, 0x29, 0x2d, 0xb3,
 588     0xe6, 0x7c, 0x03, 0x67, 0x45, 0xfa, 0x22, 0xe7,
 589     0xe9, 0xb7, 0x37, 0x3b
 590 };
 591
 592 static const u8 T12[] = {
 593     0xdc, 0xf5, 0x66, 0xff, 0x29, 0x1c, 0x25, 0xbb,
 594     0xb8, 0x56, 0x8f, 0xc3, 0xd3, 0x76, 0xa6, 0xd9
 595 };
 596
 597 /* Test Case 13 */
 598 static const u8 K13[32], P13[] = { 0 }, A13[] = { 0 }, IV13[12], C13[] = { 0 };
 599 static const u8 T13[] = {
 600     0x53, 0x0f, 0x8a, 0xfb, 0xc7, 0x45, 0x36, 0xb9,
 601     0xa9, 0x63, 0xb4, 0xf1, 0xc4, 0xcb, 0x73, 0x8b
 602 };
 603
 604 /* Test Case 14 */
 605 # define K14 K13
 606 # define A14 A13
 607 static const u8 P14[16], IV14[12];
 608 static const u8 C14[] = {
 609     0xce, 0xa7, 0x40, 0x3d, 0x4d, 0x60, 0x6b, 0x6e,
 610     0x07, 0x4e, 0xc5, 0xd3, 0xba, 0xf3, 0x9d, 0x18
 611 };
 612
 613 static const u8 T14[] = {
 614     0xd0, 0xd1, 0xc8, 0xa7, 0x99, 0x99, 0x6b, 0xf0,
 615     0x26, 0x5b, 0x98, 0xb5, 0xd4, 0x8a, 0xb9, 0x19
 616 };
 617
 618 /* Test Case 15 */
 619 # define A15 A14
 620 static const u8 K15[] = {
 621     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
 622     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08,
 623     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
 624     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
 625 };
 626
 627 static const u8 P15[] = {
 628     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
 629     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
 630     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
 631     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
 632     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
 633     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
 634     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
 635     0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55
 636 };
 637
 638 static const u8 IV15[] = {
 639     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
 640     0xde, 0xca, 0xf8, 0x88
 641 };
 642
 643 static const u8 C15[] = {
 644     0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
 645     0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
 646     0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
 647     0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
 648     0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
 649     0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
 650     0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
 651     0xbc, 0xc9, 0xf6, 0x62, 0x89, 0x80, 0x15, 0xad
 652 };
 653
 654 static const u8 T15[] = {
 655     0xb0, 0x94, 0xda, 0xc5, 0xd9, 0x34, 0x71, 0xbd,
 656     0xec, 0x1a, 0x50, 0x22, 0x70, 0xe3, 0xcc, 0x6c
 657 };
 658
 659 /* Test Case 16 */
 660 # define K16 K15
 661 # define IV16 IV15
 662 static const u8 P16[] = {
 663     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
 664     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
 665     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
 666     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
 667     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
 668     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
 669     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
 670     0xba, 0x63, 0x7b, 0x39
 671 };
 672
 673 static const u8 A16[] = {
 674     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
 675     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
 676     0xab, 0xad, 0xda, 0xd2
 677 };
 678
 679 static const u8 C16[] = {
 680     0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
 681     0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
 682     0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
 683     0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
 684     0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
 685     0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
 686     0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
 687     0xbc, 0xc9, 0xf6, 0x62
 688 };
 689
 690 static const u8 T16[] = {
 691     0x76, 0xfc, 0x6e, 0xce, 0x0f, 0x4e, 0x17, 0x68,
 692     0xcd, 0xdf, 0x88, 0x53, 0xbb, 0x2d, 0x55, 0x1b
 693 };
 694
 695 /* Test Case 17 */
 696 # define K17 K16
 697 # define P17 P16
 698 # define A17 A16
 699 static const u8 IV17[] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad };
 700
 701 static const u8 C17[] = {
 702     0xc3, 0x76, 0x2d, 0xf1, 0xca, 0x78, 0x7d, 0x32,
 703     0xae, 0x47, 0xc1, 0x3b, 0xf1, 0x98, 0x44, 0xcb,
 704     0xaf, 0x1a, 0xe1, 0x4d, 0x0b, 0x97, 0x6a, 0xfa,
 705     0xc5, 0x2f, 0xf7, 0xd7, 0x9b, 0xba, 0x9d, 0xe0,
 706     0xfe, 0xb5, 0x82, 0xd3, 0x39, 0x34, 0xa4, 0xf0,
 707     0x95, 0x4c, 0xc2, 0x36, 0x3b, 0xc7, 0x3f, 0x78,
 708     0x62, 0xac, 0x43, 0x0e, 0x64, 0xab, 0xe4, 0x99,
 709     0xf4, 0x7c, 0x9b, 0x1f
 710 };
 711
 712 static const u8 T17[] = {
 713     0x3a, 0x33, 0x7d, 0xbf, 0x46, 0xa7, 0x92, 0xc4,
 714     0x5e, 0x45, 0x49, 0x13, 0xfe, 0x2e, 0xa8, 0xf2
 715 };
 716
 717 /* Test Case 18 */
 718 # define K18 K17
 719 # define P18 P17
 720 # define A18 A17
 721 static const u8 IV18[] = {
 722     0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
 723     0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
 724     0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
 725     0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
 726     0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
 727     0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
 728     0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
 729     0xa6, 0x37, 0xb3, 0x9b
 730 };
 731
 732 static const u8 C18[] = {
 733     0x5a, 0x8d, 0xef, 0x2f, 0x0c, 0x9e, 0x53, 0xf1,
 734     0xf7, 0x5d, 0x78, 0x53, 0x65, 0x9e, 0x2a, 0x20,
 735     0xee, 0xb2, 0xb2, 0x2a, 0xaf, 0xde, 0x64, 0x19,
 736     0xa0, 0x58, 0xab, 0x4f, 0x6f, 0x74, 0x6b, 0xf4,
 737     0x0f, 0xc0, 0xc3, 0xb7, 0x80, 0xf2, 0x44, 0x45,
 738     0x2d, 0xa3, 0xeb, 0xf1, 0xc5, 0xd8, 0x2c, 0xde,
 739     0xa2, 0x41, 0x89, 0x97, 0x20, 0x0e, 0xf8, 0x2e,
 740     0x44, 0xae, 0x7e, 0x3f
 741 };
 742
 743 static const u8 T18[] = {
 744     0xa4, 0x4a, 0x82, 0x66, 0xee, 0x1c, 0x8e, 0xb0,
 745     0xc8, 0xb5, 0xd4, 0xcf, 0x5a, 0xe9, 0xf1, 0x9a
 746 };
 747
 748 /* Test Case 19 */
 749 # define K19 K1
 750 # define P19 P1
 751 # define IV19 IV1
 752 # define C19 C1
 753 static const u8 A19[] = {
 754     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
 755     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
 756     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
 757     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
 758     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
 759     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
 760     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
 761     0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55,
 762     0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
 763     0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
 764     0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
 765     0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
 766     0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
 767     0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
 768     0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
 769     0xbc, 0xc9, 0xf6, 0x62, 0x89, 0x80, 0x15, 0xad
 770 };
 771
 772 static const u8 T19[] = {
 773     0x5f, 0xea, 0x79, 0x3a, 0x2d, 0x6f, 0x97, 0x4d,
 774     0x37, 0xe6, 0x8e, 0x0c, 0xb8, 0xff, 0x94, 0x92
 775 };
 776
 777 /* Test Case 20 */
 778 # define K20 K1
 779 # define A20 A1
 780 /* this results in 0xff in counter LSB */
 781 static const u8 IV20[64] = { 0xff, 0xff, 0xff, 0xff };
 782
 783 static const u8 P20[288];
 784 static const u8 C20[] = {
 785     0x56, 0xb3, 0x37, 0x3c, 0xa9, 0xef, 0x6e, 0x4a,
 786     0x2b, 0x64, 0xfe, 0x1e, 0x9a, 0x17, 0xb6, 0x14,
 787     0x25, 0xf1, 0x0d, 0x47, 0xa7, 0x5a, 0x5f, 0xce,
 788     0x13, 0xef, 0xc6, 0xbc, 0x78, 0x4a, 0xf2, 0x4f,
 789     0x41, 0x41, 0xbd, 0xd4, 0x8c, 0xf7, 0xc7, 0x70,
 790     0x88, 0x7a, 0xfd, 0x57, 0x3c, 0xca, 0x54, 0x18,
 791     0xa9, 0xae, 0xff, 0xcd, 0x7c, 0x5c, 0xed, 0xdf,
 792     0xc6, 0xa7, 0x83, 0x97, 0xb9, 0xa8, 0x5b, 0x49,
 793     0x9d, 0xa5, 0x58, 0x25, 0x72, 0x67, 0xca, 0xab,
 794     0x2a, 0xd0, 0xb2, 0x3c, 0xa4, 0x76, 0xa5, 0x3c,
 795     0xb1, 0x7f, 0xb4, 0x1c, 0x4b, 0x8b, 0x47, 0x5c,
 796     0xb4, 0xf3, 0xf7, 0x16, 0x50, 0x94, 0xc2, 0x29,
 797     0xc9, 0xe8, 0xc4, 0xdc, 0x0a, 0x2a, 0x5f, 0xf1,
 798     0x90, 0x3e, 0x50, 0x15, 0x11, 0x22, 0x13, 0x76,
 799     0xa1, 0xcd, 0xb8, 0x36, 0x4c, 0x50, 0x61, 0xa2,
 800     0x0c, 0xae, 0x74, 0xbc, 0x4a, 0xcd, 0x76, 0xce,
 801     0xb0, 0xab, 0xc9, 0xfd, 0x32, 0x17, 0xef, 0x9f,
 802     0x8c, 0x90, 0xbe, 0x40, 0x2d, 0xdf, 0x6d, 0x86,
 803     0x97, 0xf4, 0xf8, 0x80, 0xdf, 0xf1, 0x5b, 0xfb,
 804     0x7a, 0x6b, 0x28, 0x24, 0x1e, 0xc8, 0xfe, 0x18,
 805     0x3c, 0x2d, 0x59, 0xe3, 0xf9, 0xdf, 0xff, 0x65,
 806     0x3c, 0x71, 0x26, 0xf0, 0xac, 0xb9, 0xe6, 0x42,
 807     0x11, 0xf4, 0x2b, 0xae, 0x12, 0xaf, 0x46, 0x2b,
 808     0x10, 0x70, 0xbe, 0xf1, 0xab, 0x5e, 0x36, 0x06,
 809     0x87, 0x2c, 0xa1, 0x0d, 0xee, 0x15, 0xb3, 0x24,
 810     0x9b, 0x1a, 0x1b, 0x95, 0x8f, 0x23, 0x13, 0x4c,
 811     0x4b, 0xcc, 0xb7, 0xd0, 0x32, 0x00, 0xbc, 0xe4,
 812     0x20, 0xa2, 0xf8, 0xeb, 0x66, 0xdc, 0xf3, 0x64,
 813     0x4d, 0x14, 0x23, 0xc1, 0xb5, 0x69, 0x90, 0x03,
 814     0xc1, 0x3e, 0xce, 0xf4, 0xbf, 0x38, 0xa3, 0xb6,
 815     0x0e, 0xed, 0xc3, 0x40, 0x33, 0xba, 0xc1, 0x90,
 816     0x27, 0x83, 0xdc, 0x6d, 0x89, 0xe2, 0xe7, 0x74,
 817     0x18, 0x8a, 0x43, 0x9c, 0x7e, 0xbc, 0xc0, 0x67,
 818     0x2d, 0xbd, 0xa4, 0xdd, 0xcf, 0xb2, 0x79, 0x46,
 819     0x13, 0xb0, 0xbe, 0x41, 0x31, 0x5e, 0xf7, 0x78,
 820     0x70, 0x8a, 0x70, 0xee, 0x7d, 0x75, 0x16, 0x5c
 821 };
 822
 823 static const u8 T20[] = {
 824     0x8b, 0x30, 0x7f, 0x6b, 0x33, 0x28, 0x6d, 0x0a,
 825     0xb0, 0x26, 0xa9, 0xed, 0x3f, 0xe1, 0xe8, 0x5f
 826 };
 827
 828 #define GCM128_TEST_VECTOR(n)                   \
 829     {                                           \
 830         {sizeof(K##n), K##n},                   \
 831         {sizeof(IV##n), IV##n},                 \
 832         {sizeof(A##n), A##n},                   \
 833         {sizeof(P##n), P##n},                   \
 834         {sizeof(C##n), C##n},                   \
 835         {sizeof(T##n), T##n}                    \
 836     }
 837 static struct gcm128_data {
 838     const SIZED_DATA K;
 839     const SIZED_DATA IV;
 840     const SIZED_DATA A;
 841     const SIZED_DATA P;
 842     const SIZED_DATA C;
 843     const SIZED_DATA T;
 844 } gcm128_vectors[] = {
 845     GCM128_TEST_VECTOR(1),
 846     GCM128_TEST_VECTOR(2),
 847     GCM128_TEST_VECTOR(3),
 848     GCM128_TEST_VECTOR(4),
 849     GCM128_TEST_VECTOR(5),
 850     GCM128_TEST_VECTOR(6),
 851     GCM128_TEST_VECTOR(7),
 852     GCM128_TEST_VECTOR(8),
 853     GCM128_TEST_VECTOR(9),
 854     GCM128_TEST_VECTOR(10),
 855     GCM128_TEST_VECTOR(11),
 856     GCM128_TEST_VECTOR(12),
 857     GCM128_TEST_VECTOR(13),
 858     GCM128_TEST_VECTOR(14),
 859     GCM128_TEST_VECTOR(15),
 860     GCM128_TEST_VECTOR(16),
 861     GCM128_TEST_VECTOR(17),
 862     GCM128_TEST_VECTOR(18),
 863     GCM128_TEST_VECTOR(19),
 864     GCM128_TEST_VECTOR(20)
 865 };
 866
 867 static int test_gcm128(int idx)
 868 {
 869     unsigned char out[512];
 870     SIZED_DATA K = gcm128_vectors[idx].K;
 871     SIZED_DATA IV = gcm128_vectors[idx].IV;
 872     SIZED_DATA A = gcm128_vectors[idx].A;
 873     SIZED_DATA P = gcm128_vectors[idx].P;
 874     SIZED_DATA C = gcm128_vectors[idx].C;
 875     SIZED_DATA T = gcm128_vectors[idx].T;
 876     GCM128_CONTEXT ctx;
 877     AES_KEY key;
 878     int err = 0;
 879
 880     /* Size 1 inputs are special-cased to signal NULL. */
 881     if (A.size == 1)
 882         A.data = NULL;
 883     if (P.size == 1)
 884         P.data = NULL;
 885     if (C.size == 1)
 886         C.data = NULL;
 887
 888     AES_set_encrypt_key(K.data, K.size * 8, &key);
 889
 890     CRYPTO_gcm128_init(&ctx, &key, (block128_f)AES_encrypt);
 891     CRYPTO_gcm128_setiv(&ctx, IV.data, IV.size);
 892     memset(out, 0, P.size);
 893     if (A.data)
 894         CRYPTO_gcm128_aad(&ctx, A.data, A.size);
 895     if (P.data)
 896         CRYPTO_gcm128_encrypt( &ctx, P.data, out, P.size);
 897     if (CRYPTO_gcm128_finish(&ctx, T.data, 16)
 898         || (C.data && memcmp(out, C.data, P.size)))
 899         err++, fprintf(stderr, "encrypt test#%d failed.\n", idx);
 900
 901     CRYPTO_gcm128_setiv(&ctx, IV.data, IV.size);
 902     memset(out, 0, P.size);
 903     if (A.data)
 904         CRYPTO_gcm128_aad(&ctx, A.data, A.size);
 905     if (C.data)
 906         CRYPTO_gcm128_decrypt(&ctx, C.data, out, P.size);
 907     if (CRYPTO_gcm128_finish(&ctx, T.data, 16)
 908         || (P.data && memcmp(out, P.data, P.size)))
 909         err++, fprintf(stderr, "decrypt test#%d failed.\n", idx);
 910
 911     return err == 0;
 912 }
 913
 914 static void benchmark_gcm128(const unsigned char *K, size_t Klen,
 915                              const unsigned char *IV, size_t IVlen)
 916 {
 917 #ifdef OPENSSL_CPUID_OBJ
 918     GCM128_CONTEXT ctx;
 919     AES_KEY key;
 920     size_t start, gcm_t, ctr_t, OPENSSL_rdtsc();
 921     union {
 922         u64 u;
 923         u8 c[1024];
 924     } buf;
 925
 926     AES_set_encrypt_key(K, Klen * 8, &key);
 927     CRYPTO_gcm128_init(&ctx, &key, (block128_f) AES_encrypt);
 928     CRYPTO_gcm128_setiv(&ctx, IV, IVlen);
 929
 930     CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));
 931     start = OPENSSL_rdtsc();
 932     CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));
 933     gcm_t = OPENSSL_rdtsc() - start;
 934
 935     CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),
 936                           &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,
 937                           (block128_f) AES_encrypt);
 938     start = OPENSSL_rdtsc();
 939     CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),
 940                           &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,
 941                           (block128_f) AES_encrypt);
 942     ctr_t = OPENSSL_rdtsc() - start;
 943
 944     printf("%.2f-%.2f=%.2f\n",
 945            gcm_t / (double)sizeof(buf),
 946            ctr_t / (double)sizeof(buf),
 947            (gcm_t - ctr_t) / (double)sizeof(buf));
 948 # ifdef GHASH
 949     {
 950         void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
 951                              const u8 *inp, size_t len) = ctx.ghash;
 952
 953         GHASH((&ctx), buf.c, sizeof(buf));
 954         start = OPENSSL_rdtsc();
 955         for (i = 0; i < 100; ++i)
 956             GHASH((&ctx), buf.c, sizeof(buf));
 957         gcm_t = OPENSSL_rdtsc() - start;
 958         printf("%.2f\n", gcm_t / (double)sizeof(buf) / (double)i);
 959     }
 960 # endif
 961 #else
 962     fprintf(stderr,
 963             "Benchmarking of modes isn't available on this platform\n");
 964 #endif
 965 }
 966
 967 int main(int argc, char **argv)
 968 {
 969     int result = 0;
 970     int iter_argv;
 971     int benchmark = 0;
 972
 973     for (iter_argv = 1; iter_argv < argc; iter_argv++) {
 974         if (strcmp(argv[iter_argv], "-b") == 0)
 975             benchmark = 1;
 976         else if (strcmp(argv[iter_argv], "-h") == 0)
 977             goto help;
 978     }
 979
 980     ADD_ALL_TESTS(test_cts128, OSSL_NELEM(cts128_vectors));
 981     ADD_ALL_TESTS(test_cts128_nist, OSSL_NELEM(cts128_vectors));
 982     ADD_ALL_TESTS(test_gcm128, OSSL_NELEM(gcm128_vectors));
 983
 984     result = run_tests(argv[0]);
 985
 986     if (benchmark)
 987         benchmark_gcm128(K1, sizeof(K1), IV1, sizeof(IV1));
 988
 989     return result;
 990
 991  help:
 992     printf("-h\tThis help\n");
 993     printf("-b\tBenchmark gcm128 in addition to the tests\n");
 994
 995     return 0;
 996 }