release/src-rt/bcmcrypto/aes_vectors.h

   1 /*
   2  * aes_vectors.h
   3  * AES test vectors
   4  *
   5  * Copyright 2003, Broadcom Corporation
   6  * All Rights Reserved.
   7  *
   8  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation; the
   9  * contents of this file may not be disclosed to third parties, copied or
  10  * duplicated in any form, in whole or in part, without the prior written
  11  * permission of Broadcom Corporation.
  12  *
  13  * $Id: aes_vectors.h,v 1.6.218.1 2010-05-28 15:25:49 Exp $
  14  */
  15
  16 #include <typedefs.h>
  17
  18 /* Test vector data from NIST Special Publication 800-38A */
  19
  20 /* F.2.1 CBC-AES128.Encrypt and F.2.2 CBC-AES128.Decrypt */
  21 uint8 key_00[] = {
  22         0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
  23         0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
  24         };
  25
  26 uint8 nonce_00[] = {
  27         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  28         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
  29         };
  30
  31 uint8 input_00[] = {
  32         0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
  33         0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
  34         0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
  35         0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
  36         0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
  37         0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
  38         0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
  39         0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
  40         };
  41
  42 uint8 ref_00[] = {
  43         0x76, 0x49, 0xab, 0xac, 0x81, 0x19, 0xb2, 0x46,
  44         0xce, 0xe9, 0x8e, 0x9b, 0x12, 0xe9, 0x19, 0x7d,
  45         0x50, 0x86, 0xcb, 0x9b, 0x50, 0x72, 0x19, 0xee,
  46         0x95, 0xdb, 0x11, 0x3a, 0x91, 0x76, 0x78, 0xb2,
  47         0x73, 0xbe, 0xd6, 0xb8, 0xe3, 0xc1, 0x74, 0x3b,
  48         0x71, 0x16, 0xe6, 0x9e, 0x22, 0x22, 0x95, 0x16,
  49         0x3f, 0xf1, 0xca, 0xa1, 0x68, 0x1f, 0xac, 0x09,
  50         0x12, 0x0e, 0xca, 0x30, 0x75, 0x86, 0xe1, 0xa7
  51         };
  52
  53
  54 /* F.2.3 CBC-AES192.Encrypt and F.2.4 CBC-AES192.Decrypt */
  55 uint8 key_01[] = {
  56         0x8e, 0x73, 0xb0, 0xf7, 0xda, 0x0e, 0x64, 0x52,
  57         0xc8, 0x10, 0xf3, 0x2b, 0x80, 0x90, 0x79, 0xe5,
  58         0x62, 0xf8, 0xea, 0xd2, 0x52, 0x2c, 0x6b, 0x7b
  59         };
  60
  61 uint8 nonce_01[] = {
  62         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  63         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
  64         };
  65
  66 uint8 input_01[] = {
  67         0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
  68         0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
  69         0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
  70         0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
  71         0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
  72         0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
  73         0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
  74         0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
  75         };
  76
  77 uint8 ref_01[] = {
  78         0x4f, 0x02, 0x1d, 0xb2, 0x43, 0xbc, 0x63, 0x3d,
  79         0x71, 0x78, 0x18, 0x3a, 0x9f, 0xa0, 0x71, 0xe8,
  80         0xb4, 0xd9, 0xad, 0xa9, 0xad, 0x7d, 0xed, 0xf4,
  81         0xe5, 0xe7, 0x38, 0x76, 0x3f, 0x69, 0x14, 0x5a,
  82         0x57, 0x1b, 0x24, 0x20, 0x12, 0xfb, 0x7a, 0xe0,
  83         0x7f, 0xa9, 0xba, 0xac, 0x3d, 0xf1, 0x02, 0xe0,
  84         0x08, 0xb0, 0xe2, 0x79, 0x88, 0x59, 0x88, 0x81,
  85         0xd9, 0x20, 0xa9, 0xe6, 0x4f, 0x56, 0x15, 0xcd
  86         };
  87
  88
  89 /* F.2.5 CBC-AES256.Encrypt and F.2.6 CBC-AES256.Decrypt */
  90 uint8 key_02[] = {
  91         0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
  92         0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
  93         0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
  94         0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4
  95         };
  96
  97 uint8 nonce_02[] = {
  98         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  99         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
 100         };
 101
 102 uint8 input_02[] = {
 103         0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
 104         0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
 105         0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
 106         0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
 107         0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
 108         0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
 109         0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
 110         0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
 111         };
 112
 113 uint8 ref_02[] = {
 114         0xf5, 0x8c, 0x4c, 0x04, 0xd6, 0xe5, 0xf1, 0xba,
 115         0x77, 0x9e, 0xab, 0xfb, 0x5f, 0x7b, 0xfb, 0xd6,
 116         0x9c, 0xfc, 0x4e, 0x96, 0x7e, 0xdb, 0x80, 0x8d,
 117         0x67, 0x9f, 0x77, 0x7b, 0xc6, 0x70, 0x2c, 0x7d,
 118         0x39, 0xf2, 0x33, 0x69, 0xa9, 0xd9, 0xba, 0xcf,
 119         0xa5, 0x30, 0xe2, 0x63, 0x04, 0x23, 0x14, 0x61,
 120         0xb2, 0xeb, 0x05, 0xe2, 0xc3, 0x9b, 0xe9, 0xfc,
 121         0xda, 0x6c, 0x19, 0x07, 0x8c, 0x6a, 0x9d, 0x1b
 122         };
 123
 124
 125 /* F.5.1 CTR-AES128.Encrypt and F.5.2 CTR-AES128.Decrypt */
 126 uint8 key_03[] = {
 127         0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
 128         0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
 129         };
 130
 131 uint8 nonce_03[] = {
 132         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 133         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 134         };
 135
 136 uint8 input_03[] = {
 137         0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
 138         0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
 139         0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
 140         0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
 141         0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
 142         0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
 143         0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
 144         0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
 145         };
 146
 147 uint8 ref_03[] = {
 148         0x87, 0x4d, 0x61, 0x91, 0xb6, 0x20, 0xe3, 0x26,
 149         0x1b, 0xef, 0x68, 0x64, 0x99, 0x0d, 0xb6, 0xce,
 150         0x98, 0x06, 0xf6, 0x6b, 0x79, 0x70, 0xfd, 0xff,
 151         0x86, 0x17, 0x18, 0x7b, 0xb9, 0xff, 0xfd, 0xff,
 152         0x5a, 0xe4, 0xdf, 0x3e, 0xdb, 0xd5, 0xd3, 0x5e,
 153         0x5b, 0x4f, 0x09, 0x02, 0x0d, 0xb0, 0x3e, 0xab,
 154         0x1e, 0x03, 0x1d, 0xda, 0x2f, 0xbe, 0x03, 0xd1,
 155         0x79, 0x21, 0x70, 0xa0, 0xf3, 0x00, 0x9c, 0xee
 156         };
 157
 158
 159 /* F.5.3 CTR-AES192.Encrypt and F.5.4 CTR-AES192.Decrypt */
 160 uint8 key_04[] = {
 161         0x8e, 0x73, 0xb0, 0xf7, 0xda, 0x0e, 0x64, 0x52,
 162         0xc8, 0x10, 0xf3, 0x2b, 0x80, 0x90, 0x79, 0xe5,
 163         0x62, 0xf8, 0xea, 0xd2, 0x52, 0x2c, 0x6b, 0x7b
 164         };
 165
 166 uint8 nonce_04[] = {
 167         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 168         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 169         };
 170
 171 uint8 input_04[] = {
 172         0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
 173         0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
 174         0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
 175         0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
 176         0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
 177         0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
 178         0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
 179         0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
 180         };
 181
 182 uint8 ref_04[] = {
 183         0x1a, 0xbc, 0x93, 0x24, 0x17, 0x52, 0x1c, 0xa2,
 184         0x4f, 0x2b, 0x04, 0x59, 0xfe, 0x7e, 0x6e, 0x0b,
 185         0x09, 0x03, 0x39, 0xec, 0x0a, 0xa6, 0xfa, 0xef,
 186         0xd5, 0xcc, 0xc2, 0xc6, 0xf4, 0xce, 0x8e, 0x94,
 187         0x1e, 0x36, 0xb2, 0x6b, 0xd1, 0xeb, 0xc6, 0x70,
 188         0xd1, 0xbd, 0x1d, 0x66, 0x56, 0x20, 0xab, 0xf7,
 189         0x4f, 0x78, 0xa7, 0xf6, 0xd2, 0x98, 0x09, 0x58,
 190         0x5a, 0x97, 0xda, 0xec, 0x58, 0xc6, 0xb0, 0x50
 191         };
 192
 193 /* F.5.5 CTR-AES256.Encrypt and F.5.6 CTR-AES256.Decrypt */
 194 uint8 key_05[] = {
 195         0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
 196         0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
 197         0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
 198         0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4
 199         };
 200
 201 uint8 nonce_05[] = {
 202         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 203         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 204         };
 205
 206 uint8 input_05[] = {
 207         0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
 208         0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
 209         0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
 210         0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
 211         0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
 212         0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
 213         0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
 214         0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
 215         };
 216
 217 uint8 ref_05[] = {
 218         0x60, 0x1e, 0xc3, 0x13, 0x77, 0x57, 0x89, 0xa5,
 219         0xb7, 0xa7, 0xf5, 0x04, 0xbb, 0xf3, 0xd2, 0x28,
 220         0xf4, 0x43, 0xe3, 0xca, 0x4d, 0x62, 0xb5, 0x9a,
 221         0xca, 0x84, 0xe9, 0x90, 0xca, 0xca, 0xf5, 0xc5,
 222         0x2b, 0x09, 0x30, 0xda, 0xa2, 0x3d, 0xe9, 0x4c,
 223         0xe8, 0x70, 0x17, 0xba, 0x2d, 0x84, 0x98, 0x8d,
 224         0xdf, 0xc9, 0xc5, 0x8d, 0xb6, 0x7a, 0xad, 0xa6,
 225         0x13, 0xc2, 0xdd, 0x08, 0x45, 0x79, 0x41, 0xa6
 226         };
 227
 228
 229 typedef struct {
 230         int kl;
 231         uint8 *key;
 232         uint8 *nonce;
 233         int il;
 234         uint8 *input;
 235         uint8 *ref;
 236 } aes_vector_t;
 237
 238 #define AES_VECTOR_ENTRY(x)     \
 239         { sizeof(key_##x), key_##x, nonce_##x, sizeof(input_##x), input_##x, ref_##x }
 240
 241 aes_vector_t aes_cbc_vec[] = {
 242         AES_VECTOR_ENTRY(00),
 243         AES_VECTOR_ENTRY(01),
 244         AES_VECTOR_ENTRY(02),
 245         };
 246 #define NUM_CBC_VECTORS (sizeof(aes_cbc_vec)/sizeof(aes_cbc_vec[0]))
 247
 248 aes_vector_t aes_ctr_vec[] = {
 249         AES_VECTOR_ENTRY(03),
 250         AES_VECTOR_ENTRY(04),
 251         AES_VECTOR_ENTRY(05)
 252         };
 253 #define NUM_CTR_VECTORS (sizeof(aes_ctr_vec)/sizeof(aes_ctr_vec[0]))
 254
 255
 256 /* Test vector data from: RFC3610 Counter with CBC-MAC (CCM) */
 257
 258 /* Packet Vector #1 */
 259 uint8 key_06[] = {
 260         0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
 261         0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
 262         };
 263
 264 uint8 nonce_06[] = {
 265         0x00, 0x00, 0x00, 0x03, 0x02, 0x01, 0x00, 0xA0,
 266         0xA1, 0xA2, 0xA3, 0xA4, 0xA5
 267         };
 268
 269 uint8 aad_06[] = {
 270         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
 271         };
 272
 273 uint8 input_06[] = {
 274         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 275         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 276         0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E
 277         };
 278
 279 uint8 mac_06[] = {
 280         0x2D, 0xC6, 0x97, 0xE4, 0x11, 0xCA, 0x83, 0xA8
 281         };
 282
 283 uint8 ref_06[] = {
 284         0x58, 0x8C, 0x97, 0x9A, 0x61, 0xC6, 0x63, 0xD2,
 285         0xF0, 0x66, 0xD0, 0xC2, 0xC0, 0xF9, 0x89, 0x80,
 286         0x6D, 0x5F, 0x6B, 0x61, 0xDA, 0xC3, 0x84, 0x17,
 287         0xE8, 0xD1, 0x2C, 0xFD, 0xF9, 0x26, 0xE0
 288         };
 289
 290 /* Packet Vector #2 */
 291 uint8 key_07[] = {
 292         0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
 293         0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
 294         };
 295
 296 uint8 nonce_07[] = {
 297         0x00, 0x00, 0x00, 0x04, 0x03, 0x02, 0x01, 0xA0,
 298         0xA1, 0xA2, 0xA3, 0xA4, 0xA5
 299         };
 300
 301 uint8 aad_07[] = {
 302         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
 303         };
 304
 305 uint8 input_07[] = {
 306         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 307         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 308         0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F
 309         };
 310
 311 uint8 mac_07[] = {
 312         0xF7, 0xB9, 0x05, 0x6A, 0x86, 0x92, 0x6C, 0xF3
 313         };
 314
 315 uint8 ref_07[] = {
 316         0x72, 0xC9, 0x1A, 0x36, 0xE1, 0x35, 0xF8, 0xCF,
 317         0x29, 0x1C, 0xA8, 0x94, 0x08, 0x5C, 0x87, 0xE3,
 318         0xCC, 0x15, 0xC4, 0x39, 0xC9, 0xE4, 0x3A, 0x3B,
 319         0xA0, 0x91, 0xD5, 0x6E, 0x10, 0x40, 0x09, 0x16
 320         };
 321
 322 /* Packet Vector #3 */
 323 uint8 key_08[] = {
 324         0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
 325         0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
 326         };
 327
 328 uint8 nonce_08[] = {
 329         0x00, 0x00, 0x00, 0x05, 0x04, 0x03, 0x02, 0xA0,
 330         0xA1, 0xA2, 0xA3, 0xA4, 0xA5
 331         };
 332
 333 uint8 aad_08[] = {
 334         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
 335         };
 336
 337 uint8 input_08[] = {
 338         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 339         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 340         0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
 341         0x20
 342         };
 343
 344 uint8 mac_08[] = {
 345         0x73, 0xB4, 0x67, 0x75, 0xC0, 0x26, 0xDE, 0xAA
 346         };
 347
 348 uint8 ref_08[] = {
 349         0x51, 0xB1, 0xE5, 0xF4, 0x4A, 0x19, 0x7D, 0x1D,
 350         0xA4, 0x6B, 0x0F, 0x8E, 0x2D, 0x28, 0x2A, 0xE8,
 351         0x71, 0xE8, 0x38, 0xBB, 0x64, 0xDA, 0x85, 0x96,
 352         0x57, 0x4A, 0xDA, 0xA7, 0x6F, 0xBD, 0x9F, 0xB0,
 353         0xC5
 354         };
 355
 356 /* Packet Vector #4 */
 357 uint8 key_09[] = {
 358         0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
 359         0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
 360         };
 361
 362 uint8 nonce_09[] = {
 363         0x00, 0x00, 0x00, 0x06, 0x05, 0x04, 0x03, 0xA0,
 364         0xA1, 0xA2, 0xA3, 0xA4, 0xA5
 365         };
 366
 367 uint8 aad_09[] = {
 368         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 369         0x08, 0x09, 0x0A, 0x0B
 370         };
 371
 372 uint8 input_09[] = {
 373         0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13,
 374         0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B,
 375         0x1C, 0x1D, 0x1E
 376         };
 377
 378 uint8 mac_09[] = {
 379         0x4B, 0x4F, 0x4B, 0x39, 0xB5, 0x93, 0xE6, 0xBF
 380         };
 381
 382 uint8 ref_09[] = {
 383         0xA2, 0x8C, 0x68, 0x65, 0x93, 0x9A, 0x9A, 0x79,
 384         0xFA, 0xAA, 0x5C, 0x4C, 0x2A, 0x9D, 0x4A, 0x91,
 385         0xCD, 0xAC, 0x8C, 0x96, 0xC8, 0x61, 0xB9, 0xC9,
 386         0xE6, 0x1E, 0xF1
 387         };
 388
 389 /* Packet Vector #5 */
 390 uint8 key_10[] = {
 391         0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
 392         0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
 393         };
 394
 395 uint8 nonce_10[] = {
 396         0x00, 0x00, 0x00, 0x07, 0x06, 0x05, 0x04, 0xA0,
 397         0xA1, 0xA2, 0xA3, 0xA4, 0xA5
 398         };
 399
 400 uint8 aad_10[] = {
 401         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 402         0x08, 0x09, 0x0A, 0x0B
 403         };
 404
 405 uint8 input_10[] = {
 406         0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13,
 407         0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B,
 408         0x1C, 0x1D, 0x1E, 0x1F
 409         };
 410
 411 uint8 mac_10[] = {
 412         0x48, 0xB9, 0xE8, 0x82, 0x55, 0x05, 0x4A, 0xB5
 413         };
 414
 415 uint8 ref_10[] = {
 416         0xDC, 0xF1, 0xFB, 0x7B, 0x5D, 0x9E, 0x23, 0xFB,
 417         0x9D, 0x4E, 0x13, 0x12, 0x53, 0x65, 0x8A, 0xD8,
 418         0x6E, 0xBD, 0xCA, 0x3E, 0x51, 0xE8, 0x3F, 0x07,
 419         0x7D, 0x9C, 0x2D, 0x93
 420         };
 421
 422 /* Packet Vector #6 */
 423 uint8 key_11[] = {
 424         0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
 425         0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
 426         };
 427
 428 uint8 nonce_11[] = {
 429         0x00, 0x00, 0x00, 0x08, 0x07, 0x06, 0x05, 0xA0,
 430         0xA1, 0xA2, 0xA3, 0xA4, 0xA5
 431         };
 432
 433 uint8 aad_11[] = {
 434         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 435         0x08, 0x09, 0x0A, 0x0B
 436         };
 437
 438 uint8 input_11[] = {
 439         0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13,
 440         0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B,
 441         0x1C, 0x1D, 0x1E, 0x1F, 0x20
 442         };
 443
 444 uint8 mac_11[] = {
 445         0xA5, 0x27, 0xD8, 0x15, 0x6A, 0xC3, 0x59, 0xBF
 446         };
 447
 448 uint8 ref_11[] = {
 449         0x6F, 0xC1, 0xB0, 0x11, 0xF0, 0x06, 0x56, 0x8B,
 450         0x51, 0x71, 0xA4, 0x2D, 0x95, 0x3D, 0x46, 0x9B,
 451         0x25, 0x70, 0xA4, 0xBD, 0x87, 0x40, 0x5A, 0x04,
 452         0x43, 0xAC, 0x91, 0xCB, 0x94
 453         };
 454
 455
 456 typedef struct {
 457         int kl;
 458         uint8 *key;
 459         uint8 *nonce;
 460         int al;
 461         uint8 *aad;
 462         int il;
 463         uint8 *input;
 464         uint8 *mac;
 465         uint8 *ref;
 466 } aes_ccm_vector_t;
 467
 468 #define AES_CCM_VECTOR_ENTRY(x) \
 469 { \
 470         sizeof(key_##x), key_##x, nonce_##x, sizeof(aad_##x), aad_##x, \
 471         sizeof(input_##x), input_##x, mac_##x, ref_##x \
 472 }
 473
 474 aes_ccm_vector_t aes_ccm_vec[] = {
 475         AES_CCM_VECTOR_ENTRY(06),
 476         AES_CCM_VECTOR_ENTRY(07),
 477         AES_CCM_VECTOR_ENTRY(08),
 478         AES_CCM_VECTOR_ENTRY(09),
 479         AES_CCM_VECTOR_ENTRY(10),
 480         AES_CCM_VECTOR_ENTRY(11),
 481         AES_CCM_VECTOR_ENTRY(99)
 482         };
 483 #define NUM_CCM_VECTORS (sizeof(aes_ccm_vec)/sizeof(aes_ccm_vec[0]))
 484
 485
 486 /* Test vectors from 802.11i Draft 7.0 */
 487 /* CCMP test mpdu 1 - works for both legacy and new ucode, so try it both ways */
 488 uint8 key_20[] = {
 489         0xc9, 0x7c, 0x1f, 0x67, 0xce, 0x37, 0x11, 0x85,
 490         0x51, 0x4a, 0x8a, 0x19, 0xf2, 0xbd, 0xd5, 0x2f
 491         };
 492
 493 uint8 input_20[] = {
 494         0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28,
 495         0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 496         0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33,
 497         0x0c, 0xe7, 0x00, 0x20, 0x76, 0x97, 0x03, 0xb5,
 498         0xf8, 0xba, 0x1a, 0x55, 0xd0, 0x2f, 0x85, 0xae,
 499         0x96, 0x7b, 0xb6, 0x2f, 0xb6, 0xcd, 0xa8, 0xeb,
 500         0x7e, 0x78, 0xa0, 0x50
 501         };
 502
 503 uint8 ref_20[] = {
 504         0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28,
 505         0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 506         0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33,
 507         0x0c, 0xe7, 0x00, 0x20, 0x76, 0x97, 0x03, 0xb5,
 508         0xf3, 0xd0, 0xa2, 0xfe, 0x9a, 0x3d, 0xbf, 0x23,
 509         0x42, 0xa6, 0x43, 0xe4, 0x32, 0x46, 0xe8, 0x0c,
 510         0x3c, 0x04, 0xd0, 0x19, 0x78, 0x45, 0xce, 0x0b,
 511         0x16, 0xf9, 0x76, 0x23
 512         };
 513
 514 /* WDS, WME, legacy */
 515 bool flags_20[] = { FALSE, FALSE, TRUE };
 516
 517 uint8 key_21[] = {
 518         0xc9, 0x7c, 0x1f, 0x67, 0xce, 0x37, 0x11, 0x85,
 519         0x51, 0x4a, 0x8a, 0x19, 0xf2, 0xbd, 0xd5, 0x2f
 520         };
 521
 522 uint8 input_21[] = {
 523         0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28,
 524         0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 525         0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33,
 526         0x0c, 0xe7, 0x00, 0x20, 0x76, 0x97, 0x03, 0xb5,
 527         0xf8, 0xba, 0x1a, 0x55, 0xd0, 0x2f, 0x85, 0xae,
 528         0x96, 0x7b, 0xb6, 0x2f, 0xb6, 0xcd, 0xa8, 0xeb,
 529         0x7e, 0x78, 0xa0, 0x50
 530         };
 531
 532 uint8 ref_21[] = {
 533         0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28,
 534         0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 535         0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33,
 536         0x0c, 0xe7, 0x00, 0x20, 0x76, 0x97, 0x03, 0xb5,
 537         0xf3, 0xd0, 0xa2, 0xfe, 0x9a, 0x3d, 0xbf, 0x23,
 538         0x42, 0xa6, 0x43, 0xe4, 0x32, 0x46, 0xe8, 0x0c,
 539         0x3c, 0x04, 0xd0, 0x19, 0x78, 0x45, 0xce, 0x0b,
 540         0x16, 0xf9, 0x76, 0x23
 541         };
 542
 543 /* WDS, WME, legacy */
 544 bool flags_21[] = { FALSE, FALSE, FALSE };
 545
 546 /* CCMP test mpdu 2 */
 547 uint8 key_22[] = {
 548         0x8f, 0x7a, 0x05, 0x3f, 0xa5, 0x77, 0xa5, 0x59,
 549         0x75, 0x29, 0x27, 0x20, 0x97, 0xa6, 0x03, 0xd5
 550         };
 551
 552 uint8 input_22[] = {
 553         0x38, 0xc0, 0x6a, 0x51, 0xea, 0x10, 0x0c, 0x84,
 554         0x68, 0x50, 0xee, 0xc1, 0x76, 0x2c, 0x88, 0xde,
 555         0xaf, 0x2e, 0xe9, 0xf4, 0x6a, 0x07, 0xe0, 0xcc,
 556         0xea, 0x97, 0x00, 0xa0, 0xba, 0xcb, 0xf3, 0x31,
 557         0x83, 0xa0, 0x63, 0x4b, 0x5e, 0xd7, 0x62, 0x7e,
 558         0xb9, 0xdf, 0x22, 0x5e, 0x05, 0x74, 0x03, 0x42,
 559         0xde, 0x19, 0x41, 0x17
 560         };
 561
 562 uint8 ref_22[] = {
 563         0x38, 0xc0, 0x6a, 0x51, 0xea, 0x10, 0x0c, 0x84,
 564         0x68, 0x50, 0xee, 0xc1, 0x76, 0x2c, 0x88, 0xde,
 565         0xaf, 0x2e, 0xe9, 0xf4, 0x6a, 0x07, 0xe0, 0xcc,
 566         0xea, 0x97, 0x00, 0xa0, 0xba, 0xcb, 0xf3, 0x31,
 567         0x81, 0x4b, 0x69, 0x65, 0xd0, 0x5b, 0xf2, 0xb2,
 568         0xed, 0x38, 0xd4, 0xbe, 0xb0, 0x69, 0xfe, 0x82,
 569         0x71, 0x4a, 0x61, 0x0b, 0x54, 0x2f, 0xbf, 0x8d,
 570         0xa0, 0x6a, 0xa4, 0xae
 571         };
 572
 573 bool flags_22[] = { FALSE, FALSE, FALSE };
 574
 575 /* CCMP test mpdu 3 */
 576 uint8 key_23[] = {
 577         0x40, 0xcf, 0xb7, 0xa6, 0x2e, 0x88, 0x01, 0x3b,
 578         0xd6, 0xd3, 0xaf, 0xfc, 0xc1, 0x91, 0x04, 0x1e
 579         };
 580
 581 uint8 input_23[] = {
 582         0xb8, 0xc8, 0xdc, 0x61, 0xd9, 0x57, 0x7d, 0xf7,
 583         0x63, 0xc8, 0xb6, 0xa8, 0x8a, 0xdf, 0x36, 0x91,
 584         0xdc, 0x4a, 0x8b, 0xca, 0x94, 0xdd, 0x60, 0x82,
 585         0x20, 0x85, 0xae, 0xa5, 0x00, 0xa0, 0xf3, 0xa0,
 586         0xdc, 0x2f, 0x2c, 0x1b, 0xd0, 0x36, 0x83, 0x1c,
 587         0x95, 0x49, 0x6c, 0x5f, 0x4d, 0xbf, 0x3d, 0x55,
 588         0x9e, 0x72, 0xde, 0x80, 0x2a, 0x18
 589         };
 590
 591 uint8 ref_23[] = {
 592         0xb8, 0xc8, 0xdc, 0x61, 0xd9, 0x57, 0x7d, 0xf7,
 593         0x63, 0xc8, 0xb6, 0xa8, 0x8a, 0xdf, 0x36, 0x91,
 594         0xdc, 0x4a, 0x8b, 0xca, 0x94, 0xdd, 0x60, 0x82,
 595         0x20, 0x85, 0xae, 0xa5, 0x00, 0xa0, 0xf3, 0xa0,
 596         0xdc, 0x2f, 0x89, 0xd8, 0x58, 0x03, 0x40, 0xb6,
 597         0x26, 0xa0, 0xb6, 0xd4, 0xd0, 0x13, 0xbf, 0x18,
 598         0xf2, 0x91, 0xb8, 0x96, 0x46, 0xc8, 0xfd, 0x1f,
 599         0x1f, 0x61, 0xa9, 0xfb, 0x4b, 0xb3
 600         };
 601
 602 bool flags_23[] = { FALSE, TRUE, FALSE };
 603
 604 /* CCMP test mpdu 4 */
 605 uint8 key_24[] = {
 606         0x8c, 0x89, 0xa2, 0xeb, 0xc9, 0x6c, 0x76, 0x02,
 607         0x70, 0x7f, 0xcf, 0x24, 0xb3, 0x2d, 0x38, 0x33
 608         };
 609
 610 uint8 input_24[] = {
 611         0xa8, 0xca, 0x3a, 0x11, 0x71, 0x2a, 0x9d, 0xdf,
 612         0x11, 0xdb, 0x8e, 0xf8, 0x22, 0x73, 0x47, 0x01,
 613         0x59, 0x14, 0x0d, 0xd6, 0x46, 0xa2, 0xc0, 0x2f,
 614         0x67, 0xa5, 0xe3, 0x0f, 0x00, 0x20, 0x5a, 0xa5,
 615         0x70, 0xf6, 0x4f, 0xad, 0x2b, 0x1c, 0x29, 0x0f,
 616         0xa5, 0xeb, 0xd8, 0x72, 0xfb, 0xc3, 0xf3, 0xa0,
 617         0x74, 0x89, 0x8f, 0x8b, 0x2f, 0xbb
 618         };
 619
 620 uint8 ref_24[] = {
 621         0xa8, 0xca, 0x3a, 0x11, 0x71, 0x2a, 0x9d, 0xdf,
 622         0x11, 0xdb, 0x8e, 0xf8, 0x22, 0x73, 0x47, 0x01,
 623         0x59, 0x14, 0x0d, 0xd6, 0x46, 0xa2, 0xc0, 0x2f,
 624         0x67, 0xa5, 0xe3, 0x0f, 0x00, 0x20, 0x5a, 0xa5,
 625         0x70, 0xf6, 0x9d, 0x59, 0xb1, 0x5f, 0x37, 0x14,
 626         0x48, 0xc2, 0x30, 0xf4, 0xd7, 0x39, 0x05, 0x2e,
 627         0x13, 0xab, 0x3b, 0x1a, 0x7b, 0x10, 0x31, 0xfc,
 628         0x88, 0x00, 0x4f, 0x35, 0xee, 0x3d
 629         };
 630
 631 bool flags_24[] = { FALSE, TRUE, FALSE };
 632
 633 /* CCMP test mpdu 5 */
 634 uint8 key_25[] = {
 635         0xa5, 0x74, 0xd5, 0x14, 0x3b, 0xb2, 0x5e, 0xfd,
 636         0xde, 0xff, 0x30, 0x12, 0x2f, 0xdf, 0xd0, 0x66
 637         };
 638
 639 uint8 input_25[] = {
 640         0x88, 0xda, 0x18, 0x41, 0x45, 0xde, 0xc6, 0x9a,
 641         0x74, 0x80, 0xf3, 0x51, 0x94, 0x6b, 0xc9, 0x6b,
 642         0xe2, 0x76, 0xfb, 0xe6, 0xc1, 0x27, 0x80, 0xf2,
 643         0x4b, 0x19, 0x37, 0x0e, 0x00, 0xa0, 0x3c, 0xe0,
 644         0xff, 0xa7, 0x28, 0x96, 0x9b, 0x95, 0x4f, 0x26,
 645         0x3a, 0x80, 0x18, 0xa9, 0xef, 0x70, 0xa8, 0xb0,
 646         0x51, 0x46, 0x24, 0x81, 0x92, 0x2e
 647         };
 648
 649 uint8 ref_25[] = {
 650         0x88, 0xda, 0x18, 0x41, 0x45, 0xde, 0xc6, 0x9a,
 651         0x74, 0x80, 0xf3, 0x51, 0x94, 0x6b, 0xc9, 0x6b,
 652         0xe2, 0x76, 0xfb, 0xe6, 0xc1, 0x27, 0x80, 0xf2,
 653         0x4b, 0x19, 0x37, 0x0e, 0x00, 0xa0, 0x3c, 0xe0,
 654         0xff, 0xa7, 0xeb, 0x4a, 0xe4, 0x95, 0x6a, 0x80,
 655         0x1d, 0xa9, 0x62, 0x4b, 0x7e, 0x0c, 0x18, 0xb2,
 656         0x3e, 0x61, 0x5e, 0xc0, 0x3a, 0xf6, 0xce, 0x0c,
 657         0x3b, 0xe1, 0x97, 0xd3, 0x05, 0xeb
 658         };
 659
 660 bool flags_25[] = { FALSE, TRUE, FALSE };
 661
 662 /* CCMP test mpdu 6 */
 663 uint8 key_26[] = {
 664         0xf7, 0x1e, 0xea, 0x4e, 0x1f, 0x58, 0x80, 0x4b,
 665         0x97, 0x17, 0x23, 0x0a, 0xd0, 0x61, 0x46, 0x41
 666         };
 667
 668 uint8 input_26[] = {
 669         0x88, 0x52, 0xe1, 0x1f, 0x5a, 0xf2, 0x84, 0x30,
 670         0xfd, 0xab, 0xbf, 0xf9, 0x43, 0xb9, 0xf9, 0xa6,
 671         0xab, 0x1d, 0x98, 0xc7, 0xfe, 0x73, 0x50, 0x71,
 672         0x3d, 0x6a, 0x89, 0x89, 0x00, 0x60, 0xa4, 0xec,
 673         0x81, 0x6b, 0xab, 0xfd, 0xa2, 0x2d, 0x3a, 0x0b,
 674         0xfc, 0x9c, 0xc1, 0xfc, 0x07, 0x93, 0x63, 0xc2,
 675         0xfc, 0xa1, 0x43, 0xe6, 0xeb, 0x1d
 676         };
 677
 678 uint8 ref_26[] = {
 679         0x88, 0x52, 0xe1, 0x1f, 0x5a, 0xf2, 0x84, 0x30,
 680         0xfd, 0xab, 0xbf, 0xf9, 0x43, 0xb9, 0xf9, 0xa6,
 681         0xab, 0x1d, 0x98, 0xc7, 0xfe, 0x73, 0x50, 0x71,
 682         0x3d, 0x6a, 0x89, 0x89, 0x00, 0x60, 0xa4, 0xec,
 683         0x81, 0x6b, 0x9a, 0x70, 0x9b, 0x60, 0xa3, 0x9d,
 684         0x40, 0xb1, 0xdf, 0xb6, 0x12, 0xe1, 0x8b, 0x5f,
 685         0x11, 0x4b, 0xad, 0xb6, 0xcc, 0x86, 0x30, 0x9a,
 686         0x8d, 0x5c, 0x46, 0x6b, 0xbb, 0x71
 687         };
 688
 689 bool flags_26[] = { FALSE, TRUE, FALSE };
 690
 691 /* CCMP test mpdu 7 */
 692 uint8 key_27[] = {
 693         0x1b, 0xdb, 0x34, 0x98, 0x0e, 0x03, 0x81, 0x24,
 694         0xa1, 0xdb, 0x1a, 0x89, 0x2b, 0xec, 0x36, 0x6a
 695         };
 696
 697 uint8 input_27[] = {
 698         0x18, 0x79, 0x81, 0x46, 0x9b, 0x50, 0xf4, 0xfd,
 699         0x56, 0xf6, 0xef, 0xec, 0x95, 0x20, 0x16, 0x91,
 700         0x83, 0x57, 0x0c, 0x4c, 0xcd, 0xee, 0x20, 0xa0,
 701         0x23, 0xe7, 0x00, 0xe0, 0x73, 0x40, 0xec, 0x5e,
 702         0x98, 0xbe, 0xca, 0x86, 0xf4, 0xb3, 0x8d, 0xa2,
 703         0x0c, 0xfd, 0xf2, 0x47, 0x24, 0xc5, 0x8e, 0xb8,
 704         0x35, 0x66, 0x53, 0x39
 705         };
 706
 707 uint8 ref_27[] = {
 708         0x18, 0x79, 0x81, 0x46, 0x9b, 0x50, 0xf4, 0xfd,
 709         0x56, 0xf6, 0xef, 0xec, 0x95, 0x20, 0x16, 0x91,
 710         0x83, 0x57, 0x0c, 0x4c, 0xcd, 0xee, 0x20, 0xa0,
 711         0x23, 0xe7, 0x00, 0xe0, 0x73, 0x40, 0xec, 0x5e,
 712         0x12, 0xc5, 0x37, 0xeb, 0xf3, 0xab, 0x58, 0x4e,
 713         0xf1, 0xfe, 0xf9, 0xa1, 0xf3, 0x54, 0x7a, 0x8c,
 714         0x13, 0xb3, 0x22, 0x5a, 0x2d, 0x09, 0x57, 0xec,
 715         0xfa, 0xbe, 0x95, 0xb9
 716         };
 717
 718 bool flags_27[] = { FALSE, FALSE, FALSE };
 719
 720 /* CCMP test mpdu 8 */
 721 uint8 key_28[] = {
 722         0x6e, 0xac, 0x1b, 0xf5, 0x4b, 0xd5, 0x4e, 0xdb,
 723         0x23, 0x21, 0x75, 0x43, 0x03, 0x02, 0x4c, 0x71
 724         };
 725
 726 uint8 input_28[] = {
 727         0xb8, 0xd9, 0x4c, 0x72, 0x55, 0x2d, 0x5f, 0x72,
 728         0xbb, 0x70, 0xca, 0x3f, 0x3a, 0xae, 0x60, 0xc4,
 729         0x8b, 0xa9, 0xb5, 0xf8, 0x2c, 0x2f, 0x50, 0xeb,
 730         0x2a, 0x55, 0xdd, 0xcc, 0x00, 0xa0, 0x6e, 0x99,
 731         0xfd, 0xce, 0x57, 0xcb, 0x5c, 0x0e, 0x5f, 0xcd,
 732         0x88, 0x5e, 0x9a, 0x42, 0x39, 0xe9, 0xb9, 0xca,
 733         0xd6, 0x0d, 0x64, 0x37, 0x59, 0x79
 734         };
 735
 736 uint8 ref_28[] = {
 737         0xb8, 0xd9, 0x4c, 0x72, 0x55, 0x2d, 0x5f, 0x72,
 738         0xbb, 0x70, 0xca, 0x3f, 0x3a, 0xae, 0x60, 0xc4,
 739         0x8b, 0xa9, 0xb5, 0xf8, 0x2c, 0x2f, 0x50, 0xeb,
 740         0x2a, 0x55, 0xdd, 0xcc, 0x00, 0xa0, 0x6e, 0x99,
 741         0xfd, 0xce, 0x4b, 0xf2, 0x81, 0xef, 0x8e, 0xc7,
 742         0x73, 0x9f, 0x91, 0x59, 0x1b, 0x97, 0xa8, 0x7d,
 743         0xc1, 0x4b, 0x3f, 0xa1, 0x74, 0x62, 0x6d, 0xba,
 744         0x8e, 0xf7, 0xf0, 0x80, 0x87, 0xdd
 745         };
 746
 747 bool flags_28[] = { FALSE, TRUE, FALSE };
 748
 749 /* CCMP test mpdu 9 */
 750 uint8 key_29[] = {
 751         0x49, 0x4b, 0x50, 0x1e, 0x19, 0x46, 0x75, 0x97,
 752         0x1a, 0x48, 0xd0, 0x8c, 0x5b, 0xc3, 0x53, 0xcb
 753         };
 754
 755 uint8 input_29[] = {
 756         0xa8, 0xf9, 0xc8, 0x42, 0x9a, 0xfb, 0x79, 0x8b,
 757         0x8a, 0x4b, 0xa4, 0xad, 0x6d, 0x31, 0x99, 0x85,
 758         0xbc, 0x42, 0x9e, 0x8f, 0x0a, 0xfa, 0xf0, 0x7d,
 759         0x4a, 0x80, 0xb3, 0x37, 0x00, 0xe0, 0x34, 0xe9,
 760         0x82, 0xba, 0x25, 0xa9, 0x8f, 0x9c, 0x1b, 0xd9,
 761         0xc9, 0x3c, 0xf3, 0x83, 0xab, 0x9d, 0x98, 0x15,
 762         0x2d, 0x76, 0xcb, 0x4a, 0x32, 0xc6
 763         };
 764
 765 uint8 ref_29[] = {
 766         0xa8, 0xf9, 0xc8, 0x42, 0x9a, 0xfb, 0x79, 0x8b,
 767         0x8a, 0x4b, 0xa4, 0xad, 0x6d, 0x31, 0x99, 0x85,
 768         0xbc, 0x42, 0x9e, 0x8f, 0x0a, 0xfa, 0xf0, 0x7d,
 769         0x4a, 0x80, 0xb3, 0x37, 0x00, 0xe0, 0x34, 0xe9,
 770         0x82, 0xba, 0x56, 0x1a, 0x0d, 0x06, 0x8e, 0xac,
 771         0x2e, 0xad, 0xb0, 0xc5, 0x7f, 0xe2, 0xd0, 0xa6,
 772         0xcc, 0x73, 0x98, 0xb6, 0xdd, 0xbf, 0xcf, 0xe4,
 773         0x38, 0xcb, 0xea, 0x61, 0xfa, 0x9a
 774         };
 775
 776 bool flags_29[] = { FALSE, TRUE, FALSE };
 777
 778 /* CCMP test mpdu 10 */
 779 uint8 key_30[] = {
 780         0x48, 0x9e, 0x49, 0xbc, 0x3c, 0xfe, 0x3f, 0xce,
 781         0x38, 0x95, 0x82, 0x0e, 0x87, 0x2e, 0xe1, 0xa3
 782         };
 783
 784 uint8 input_30[] = {
 785         0x18, 0x4b, 0xe0, 0x63, 0x40, 0xec, 0x29, 0xfa,
 786         0x75, 0x9b, 0x53, 0xf8, 0x69, 0xfe, 0x27, 0x9a,
 787         0xf0, 0xf9, 0xf8, 0xa6, 0x54, 0x16, 0x80, 0xe3,
 788         0x52, 0xbf, 0xd2, 0x70, 0x3d, 0x24, 0xa9, 0xfe,
 789         0x00, 0x20, 0x75, 0x3e, 0x1d, 0xcf, 0x7f, 0x91,
 790         0xf2, 0x47, 0x2d, 0x7a, 0x12, 0x1c, 0x9c, 0xdd,
 791         0x4b, 0x6c, 0x90, 0x80, 0x67, 0x5a, 0x10, 0x20,
 792         0xaa, 0x00
 793         };
 794
 795 uint8 ref_30[] = {
 796         0x18, 0x4b, 0xe0, 0x63, 0x40, 0xec, 0x29, 0xfa,
 797         0x75, 0x9b, 0x53, 0xf8, 0x69, 0xfe, 0x27, 0x9a,
 798         0xf0, 0xf9, 0xf8, 0xa6, 0x54, 0x16, 0x80, 0xe3,
 799         0x52, 0xbf, 0xd2, 0x70, 0x3d, 0x24, 0xa9, 0xfe,
 800         0x00, 0x20, 0x75, 0x3e, 0x1d, 0xcf, 0x25, 0xdf,
 801         0x51, 0x73, 0x83, 0x5e, 0x4f, 0xba, 0x23, 0xbc,
 802         0x05, 0xa2, 0x53, 0x88, 0x5e, 0xbe, 0xd3, 0xac,
 803         0x48, 0x71, 0xc8, 0x68, 0xa7, 0x25, 0x55, 0x2c,
 804         0x55, 0x65
 805         };
 806
 807 bool flags_30[] = { TRUE, FALSE, FALSE };
 808
 809 /* CCMP test mpdu 11 */
 810 uint8 key_31[] = {
 811         0x02, 0xbe, 0x5c, 0x45, 0x45, 0x67, 0x2a, 0x07,
 812         0xe4, 0xe3, 0x14, 0xd7, 0x0f, 0x1f, 0x9e, 0x85
 813         };
 814
 815 uint8 input_31[] = {
 816         0xb8, 0xdb, 0x6a, 0x54, 0x29, 0x8c, 0x0b, 0xaa,
 817         0x91, 0x90, 0x34, 0x7c, 0xeb, 0x9a, 0xab, 0xff,
 818         0xd8, 0x3d, 0x48, 0x86, 0xe5, 0xc2, 0xe0, 0x53,
 819         0xe2, 0x9d, 0x52, 0x4a, 0xe1, 0x96, 0x3d, 0x62,
 820         0xd4, 0x55, 0x00, 0xe0, 0x6e, 0x59, 0xd6, 0xd2,
 821         0xf9, 0xa8, 0x12, 0xe4, 0xa2, 0x8a, 0xf7, 0xf3,
 822         0x71, 0x4d, 0x4b, 0xf6, 0x62, 0x2e, 0x59, 0x32,
 823         0xf2, 0x18, 0x45, 0x09
 824         };
 825
 826 uint8 ref_31[] = {
 827         0xb8, 0xdb, 0x6a, 0x54, 0x29, 0x8c, 0x0b, 0xaa,
 828         0x91, 0x90, 0x34, 0x7c, 0xeb, 0x9a, 0xab, 0xff,
 829         0xd8, 0x3d, 0x48, 0x86, 0xe5, 0xc2, 0xe0, 0x53,
 830         0xe2, 0x9d, 0x52, 0x4a, 0xe1, 0x96, 0x3d, 0x62,
 831         0xd4, 0x55, 0x00, 0xe0, 0x6e, 0x59, 0xd6, 0xd2,
 832         0x63, 0x15, 0x50, 0x0f, 0x92, 0x42, 0x95, 0xcd,
 833         0x3e, 0xaf, 0xbd, 0xc3, 0xe1, 0x51, 0xb1, 0xdf,
 834         0x46, 0x46, 0x5b, 0x71, 0x68, 0x1f, 0xde, 0xe8,
 835         0x51, 0x3c, 0x62, 0xdc
 836         };
 837
 838 bool flags_31[] = { TRUE, TRUE, FALSE };
 839
 840 /* CCMP test mpdu 12 */
 841 uint8 key_32[] = {
 842         0x77, 0x07, 0x7e, 0xd7, 0x94, 0x53, 0xe4, 0xa1,
 843         0x8d, 0x60, 0x43, 0x8c, 0xc6, 0x48, 0x4d, 0x6e
 844         };
 845
 846 uint8 input_32[] = {
 847         0x18, 0x6b, 0xd0, 0x27, 0xaa, 0x28, 0x8b, 0x84,
 848         0x35, 0xbc, 0xd8, 0xac, 0x5a, 0x7e, 0xc4, 0x44,
 849         0xe8, 0xb4, 0x62, 0x50, 0x53, 0x8b, 0x80, 0x62,
 850         0xe8, 0x14, 0x02, 0xc2, 0xee, 0x11, 0x8e, 0xfd,
 851         0x00, 0xe0, 0x77, 0x1e, 0xb0, 0x50, 0x43, 0x19,
 852         0x81, 0xa2, 0x33, 0x6d, 0x02, 0xf8, 0xcb, 0x84,
 853         0x48, 0xd5, 0x42, 0x89, 0x16, 0xbe, 0x95, 0x29,
 854         0x35, 0x37
 855         };
 856
 857 uint8 ref_32[] = {
 858         0x18, 0x6b, 0xd0, 0x27, 0xaa, 0x28, 0x8b, 0x84,
 859         0x35, 0xbc, 0xd8, 0xac, 0x5a, 0x7e, 0xc4, 0x44,
 860         0xe8, 0xb4, 0x62, 0x50, 0x53, 0x8b, 0x80, 0x62,
 861         0xe8, 0x14, 0x02, 0xc2, 0xee, 0x11, 0x8e, 0xfd,
 862         0x00, 0xe0, 0x77, 0x1e, 0xb0, 0x50, 0xcf, 0x71,
 863         0xb2, 0xcc, 0xbd, 0x59, 0x0b, 0x20, 0x80, 0x07,
 864         0x92, 0xf3, 0x59, 0xed, 0x1c, 0xfd, 0x74, 0xd8,
 865         0x00, 0xb4, 0xfd, 0x0f, 0x41, 0xf4, 0x26, 0xbb,
 866         0x8f, 0x30
 867         };
 868
 869 bool flags_32[] = { TRUE, FALSE, FALSE };
 870
 871
 872 /* Test vectors generated by legacy ucode */
 873 uint8 key_40[] = {
 874         0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,
 875         0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12
 876         };
 877
 878 uint8 input_40[] = {
 879         0x08, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 880         0xff, 0xff, 0x00, 0x10, 0x18, 0x90, 0x01, 0xee,
 881         0x56, 0xb9, 0x99, 0xdd, 0x40, 0x04, 0x30, 0x9f,
 882         0x07, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
 883         0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x06,
 884         0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01,
 885         0x00, 0x10, 0x18, 0x90, 0x01, 0xee, 0xc0, 0xa8,
 886         0x0a, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 887         0xc0, 0xa8, 0x0a, 0x01
 888         };
 889
 890 uint8 ref_40[] = {
 891         0x08, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 892         0xff, 0xff, 0x00, 0x10, 0x18, 0x90, 0x01, 0xee,
 893         0x56, 0xb9, 0x99, 0xdd, 0x40, 0x04, 0x30, 0x9f,
 894         0x07, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
 895         0x85, 0x7d, 0x0c, 0xf3, 0xe7, 0x0b, 0x05, 0xb2,
 896         0x66, 0x2f, 0xf4, 0xe1, 0xc4, 0x86, 0x1f, 0x94,
 897         0x02, 0x3f, 0x25, 0x41, 0xcf, 0x65, 0xec, 0xd1,
 898         0x33, 0x70, 0x8f, 0x62, 0x98, 0xa8, 0x72, 0x5f,
 899         0x67, 0xe3, 0xaf, 0x78, 0xb1, 0x0d, 0x04, 0x08,
 900         0x95, 0x2e, 0x11, 0x7a
 901         };
 902
 903 bool flags_40[] = { FALSE, FALSE, TRUE };
 904
 905 uint8 key_41[] = {
 906         0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,
 907         0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12
 908         };
 909
 910 uint8 input_41[] = {
 911         0x08, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 912         0xff, 0xff, 0x00, 0x10, 0x18, 0x90, 0x01, 0xee,
 913         0x56, 0xb9, 0x99, 0xdd, 0x40, 0x04, 0xb0, 0xa0,
 914         0x09, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
 915         0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x06,
 916         0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01,
 917         0x00, 0x10, 0x18, 0x90, 0x01, 0xee, 0xc0, 0xa8,
 918         0x0a, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 919         0xc0, 0xa8, 0x0a, 0x01
 920         };
 921
 922 uint8 ref_41[] = {
 923         0x08, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 924         0xff, 0xff, 0x00, 0x10, 0x18, 0x90, 0x01, 0xee,
 925         0x56, 0xb9, 0x99, 0xdd, 0x40, 0x04, 0xb0, 0xa0,
 926         0x09, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
 927         0x0a, 0xd4, 0xf2, 0x74, 0x0e, 0x45, 0x6f, 0x6a,
 928         0xe2, 0x7f, 0xcd, 0x98, 0xa6, 0x54, 0x51, 0xb3,
 929         0x08, 0x7f, 0xf5, 0x68, 0xbe, 0xcf, 0xd0, 0x98,
 930         0xbc, 0xbd, 0x70, 0x59, 0xa9, 0xc8, 0xc0, 0x09,
 931         0xcb, 0x5f, 0x1d, 0x99, 0x71, 0x74, 0x5d, 0x39,
 932         0xe5, 0x52, 0x92, 0xb9
 933         };
 934
 935 bool flags_41[] = { FALSE, FALSE, TRUE };
 936
 937 uint8 key_42[] = {
 938         0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,
 939         0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12
 940         };
 941
 942 uint8 input_42[] = {
 943         0x08, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 944         0xff, 0xff, 0x00, 0x10, 0x18, 0x90, 0x01, 0xee,
 945         0x56, 0xb9, 0x99, 0xdd, 0x40, 0x04, 0x70, 0xa1,
 946         0x0a, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
 947         0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x06,
 948         0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01,
 949         0x00, 0x10, 0x18, 0x90, 0x01, 0xee, 0xc0, 0xa8,
 950         0x0a, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 951         0xc0, 0xa8, 0x0a, 0x01
 952         };
 953
 954 uint8 ref_42[] = {
 955         0x08, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 956         0xff, 0xff, 0x00, 0x10, 0x18, 0x90, 0x01, 0xee,
 957         0x56, 0xb9, 0x99, 0xdd, 0x40, 0x04, 0x70, 0xa1,
 958         0x0a, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
 959         0x73, 0xb2, 0x72, 0x41, 0xb8, 0x18, 0x10, 0x27,
 960         0xbc, 0x2e, 0x94, 0x4f, 0x86, 0x14, 0xfb, 0x7d,
 961         0x54, 0x85, 0xa1, 0x39, 0x52, 0xf0, 0x73, 0x94,
 962         0x05, 0x8c, 0xe8, 0xf0, 0xf8, 0xc8, 0x09, 0xfb,
 963         0x3b, 0x99, 0x3a, 0x1d, 0x49, 0xb1, 0xd1, 0x44,
 964         0xe4, 0x4d, 0xab, 0xaa
 965         };
 966
 967 bool flags_42[] = { FALSE, FALSE, TRUE };
 968
 969 uint8 key_43[] = {
 970         0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,
 971         0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12
 972         };
 973
 974 uint8 input_43[] = {
 975         0x08, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 976         0xff, 0xff, 0x00, 0x10, 0x18, 0x90, 0x01, 0xee,
 977         0x56, 0xb9, 0x99, 0xdd, 0x40, 0x04, 0x20, 0xa2,
 978         0x0b, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
 979         0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x06,
 980         0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01,
 981         0x00, 0x10, 0x18, 0x90, 0x01, 0xee, 0xc0, 0xa8,
 982         0x0a, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 983         0xc0, 0xa8, 0x0a, 0x01
 984         };
 985
 986 uint8 ref_43[] = {
 987         0x08, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 988         0xff, 0xff, 0x00, 0x10, 0x18, 0x90, 0x01, 0xee,
 989         0x56, 0xb9, 0x99, 0xdd, 0x40, 0x04, 0x20, 0xa2,
 990         0x0b, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
 991         0xcf, 0x1c, 0x69, 0xfb, 0x5d, 0x67, 0xcd, 0xc2,
 992         0x9a, 0x93, 0x13, 0xec, 0x71, 0xc8, 0xb2, 0xbb,
 993         0x3e, 0x25, 0x0e, 0x4c, 0x1d, 0xcb, 0x44, 0x41,
 994         0x83, 0x6b, 0xc1, 0xb3, 0x25, 0x1d, 0xb0, 0xb2,
 995         0x58, 0x90, 0x5e, 0xa3, 0x5d, 0x3c, 0xf9, 0xcd,
 996         0x98, 0x4c, 0xad, 0xd9
 997         };
 998
 999 bool flags_43[] = { FALSE, FALSE, TRUE };
1000
1001 uint8 key_44[] = {
1002         0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,
1003         0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12,
1004         };
1005
1006 uint8 input_44[] = {
1007         0x08, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
1008         0xff, 0xff, 0x00, 0x10, 0x18, 0x90, 0x01, 0xee,
1009         0x56, 0xb9, 0x99, 0xdd, 0x40, 0x04, 0xd0, 0xa2,
1010         0x0c, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
1011         0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x06,
1012         0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01,
1013         0x00, 0x10, 0x18, 0x90, 0x01, 0xee, 0xc0, 0xa8,
1014         0x0a, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1015         0xc0, 0xa8, 0x0a, 0x01,
1016         };
1017
1018 uint8 ref_44[] = {
1019         0x08, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
1020         0xff, 0xff, 0x00, 0x10, 0x18, 0x90, 0x01, 0xee,
1021         0x56, 0xb9, 0x99, 0xdd, 0x40, 0x04, 0xd0, 0xa2,
1022         0x0c, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
1023         0xa5, 0x8a, 0xcf, 0x80, 0xe0, 0xe9, 0x96, 0x1f,
1024         0x95, 0x9e, 0x71, 0x57, 0x7b, 0x4a, 0x77, 0x1d,
1025         0x15, 0xae, 0x47, 0xa6, 0x2a, 0xfb, 0x9a, 0x65,
1026         0x3f, 0x3a, 0x19, 0x76, 0x9f, 0x73, 0xfa, 0xa6,
1027         0xa7, 0x85, 0x6f, 0xb8, 0x5b, 0x3e, 0x54, 0x25,
1028         0x34, 0x00, 0xa8, 0x44
1029         };
1030
1031 bool flags_44[] = { FALSE, FALSE, TRUE };
1032
1033
1034 typedef struct {
1035         int kl;
1036         uint8 *key;
1037         int il;
1038         uint8 *input;
1039         uint8 *ref;
1040         bool *flags;
1041 } aes_ccmp_vector_t;
1042
1043 #define AES_CCMP_VECTOR_ENTRY(x)        \
1044         { sizeof(key_##x), key_##x, sizeof(input_##x), input_##x, ref_##x, flags_##x }
1045
1046 aes_ccmp_vector_t aes_ccmp_vec[] = {
1047         AES_CCMP_VECTOR_ENTRY(20),
1048         AES_CCMP_VECTOR_ENTRY(21),
1049         AES_CCMP_VECTOR_ENTRY(22),
1050         AES_CCMP_VECTOR_ENTRY(23),
1051         AES_CCMP_VECTOR_ENTRY(24),
1052         AES_CCMP_VECTOR_ENTRY(25),
1053         AES_CCMP_VECTOR_ENTRY(26),
1054         AES_CCMP_VECTOR_ENTRY(27),
1055         AES_CCMP_VECTOR_ENTRY(28),
1056         AES_CCMP_VECTOR_ENTRY(29),
1057         AES_CCMP_VECTOR_ENTRY(30),
1058         AES_CCMP_VECTOR_ENTRY(31),
1059         AES_CCMP_VECTOR_ENTRY(32),
1060         AES_CCMP_VECTOR_ENTRY(40),
1061         AES_CCMP_VECTOR_ENTRY(41),
1062         AES_CCMP_VECTOR_ENTRY(42),
1063         AES_CCMP_VECTOR_ENTRY(43),
1064         AES_CCMP_VECTOR_ENTRY(44)
1065         };
1066 #define NUM_CCMP_VECTORS        (sizeof(aes_ccmp_vec)/sizeof(aes_ccmp_vec[0]))