crypto/tcrypt.h

   1 /*
   2  * Quick & dirty crypto testing module.
   3  *
   4  * This will only exist until we have a better testing mechanism
   5  * (e.g. a char device).
   6  *
   7  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
   8  * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by the Free
  12  * Software Foundation; either version 2 of the License, or (at your option)
  13  * any later version.
  14  *
  15  * 14 - 09 - 2003 Changes by Kartikey Mahendra Bhatt
  16  *
  17  */
  18 #ifndef _CRYPTO_TCRYPT_H
  19 #define _CRYPTO_TCRYPT_H
  20
  21 #define MAX_DIGEST_SIZE         64
  22 #define MAX_TAP                 8
  23
  24 #define MAX_KEYLEN              56
  25 #define MAX_IVLEN               32
  26
  27 struct hash_testvec {
  28         char plaintext[128];
  29         unsigned char psize;
  30         char digest[MAX_DIGEST_SIZE];
  31         unsigned char np;
  32         unsigned char tap[MAX_TAP];
  33         char key[128]; /* only used with keyed hash algorithms */
  34         unsigned char ksize;
  35 };
  36
  37 struct hmac_testvec {
  38         char key[128];
  39         unsigned char ksize;
  40         char plaintext[128];
  41         unsigned char psize;
  42         char digest[MAX_DIGEST_SIZE];
  43         unsigned char np;
  44         unsigned char tap[MAX_TAP];
  45 };
  46
  47 struct cipher_testvec {
  48         unsigned char fail;
  49         unsigned char wk; /* weak key flag */
  50         char key[MAX_KEYLEN];
  51         unsigned char klen;
  52         char iv[MAX_IVLEN];
  53         char input[48];
  54         unsigned char ilen;
  55         char result[48];
  56         unsigned char rlen;
  57         int np;
  58         unsigned char tap[MAX_TAP];
  59 };
  60
  61 /*
  62  * MD4 test vectors from RFC1320
  63  */
  64 #define MD4_TEST_VECTORS        7
  65
  66 struct hash_testvec md4_tv_template [] = {
  67         {
  68                 .plaintext = "",
  69                 .digest = { 0x31, 0xd6, 0xcf, 0xe0, 0xd1, 0x6a, 0xe9, 0x31,
  70                             0xb7, 0x3c, 0x59, 0xd7, 0xe0, 0xc0, 0x89, 0xc0 },
  71         }, {
  72                 .plaintext = "a",
  73                 .psize  = 1,
  74                 .digest = { 0xbd, 0xe5, 0x2c, 0xb3, 0x1d, 0xe3, 0x3e, 0x46,
  75                             0x24, 0x5e, 0x05, 0xfb, 0xdb, 0xd6, 0xfb, 0x24 },
  76         }, {
  77                 .plaintext = "abc",
  78                 .psize  = 3,
  79                 .digest = { 0xa4, 0x48, 0x01, 0x7a, 0xaf, 0x21, 0xd8, 0x52,
  80                             0x5f, 0xc1, 0x0a, 0xe8, 0x7a, 0xa6, 0x72, 0x9d },
  81         }, {
  82                 .plaintext = "message digest",
  83                 .psize  = 14,
  84                 .digest = { 0xd9, 0x13, 0x0a, 0x81, 0x64, 0x54, 0x9f, 0xe8,
  85                             0x18, 0x87, 0x48, 0x06, 0xe1, 0xc7, 0x01, 0x4b },
  86         }, {
  87                 .plaintext = "abcdefghijklmnopqrstuvwxyz",
  88                 .psize  = 26,
  89                 .digest = { 0xd7, 0x9e, 0x1c, 0x30, 0x8a, 0xa5, 0xbb, 0xcd,
  90                             0xee, 0xa8, 0xed, 0x63, 0xdf, 0x41, 0x2d, 0xa9 },
  91                 .np     = 2,
  92                 .tap    = { 13, 13 },
  93         }, {
  94                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
  95                 .psize  = 62,
  96                 .digest = { 0x04, 0x3f, 0x85, 0x82, 0xf2, 0x41, 0xdb, 0x35,
  97                             0x1c, 0xe6, 0x27, 0xe1, 0x53, 0xe7, 0xf0, 0xe4 },
  98         }, {
  99                 .plaintext = "123456789012345678901234567890123456789012345678901234567890123"
 100                              "45678901234567890",
 101                 .psize  = 80,
 102                 .digest = { 0xe3, 0x3b, 0x4d, 0xdc, 0x9c, 0x38, 0xf2, 0x19,
 103                             0x9c, 0x3e, 0x7b, 0x16, 0x4f, 0xcc, 0x05, 0x36 },
 104         },
 105 };
 106
 107 /*
 108  * MD5 test vectors from RFC1321
 109  */
 110 #define MD5_TEST_VECTORS        7
 111
 112 struct hash_testvec md5_tv_template[] = {
 113         {
 114                 .digest = { 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04,
 115                             0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e },
 116         }, {
 117                 .plaintext = "a",
 118                 .psize  = 1,
 119                 .digest = { 0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1, 0xb6, 0xa8,
 120                             0x31, 0xc3, 0x99, 0xe2, 0x69, 0x77, 0x26, 0x61 },
 121         }, {
 122                 .plaintext = "abc",
 123                 .psize  = 3,
 124                 .digest = { 0x90, 0x01, 0x50, 0x98, 0x3c, 0xd2, 0x4f, 0xb0,
 125                             0xd6, 0x96, 0x3f, 0x7d, 0x28, 0xe1, 0x7f, 0x72 },
 126         }, {
 127                 .plaintext = "message digest",
 128                 .psize  = 14,
 129                 .digest = { 0xf9, 0x6b, 0x69, 0x7d, 0x7c, 0xb7, 0x93, 0x8d,
 130                             0x52, 0x5a, 0x2f, 0x31, 0xaa, 0xf1, 0x61, 0xd0 },
 131         }, {
 132                 .plaintext = "abcdefghijklmnopqrstuvwxyz",
 133                 .psize  = 26,
 134                 .digest = { 0xc3, 0xfc, 0xd3, 0xd7, 0x61, 0x92, 0xe4, 0x00,
 135                             0x7d, 0xfb, 0x49, 0x6c, 0xca, 0x67, 0xe1, 0x3b },
 136                 .np     = 2,
 137                 .tap    = {13, 13}
 138         }, {
 139                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
 140                 .psize  = 62,
 141                 .digest = { 0xd1, 0x74, 0xab, 0x98, 0xd2, 0x77, 0xd9, 0xf5,
 142                             0xa5, 0x61, 0x1c, 0x2c, 0x9f, 0x41, 0x9d, 0x9f },
 143         }, {
 144                 .plaintext = "12345678901234567890123456789012345678901234567890123456789012"
 145                              "345678901234567890",
 146                 .psize  = 80,
 147                 .digest = { 0x57, 0xed, 0xf4, 0xa2, 0x2b, 0xe3, 0xc9, 0x55,
 148                             0xac, 0x49, 0xda, 0x2e, 0x21, 0x07, 0xb6, 0x7a },
 149         }
 150 };
 151
 152 /*
 153  * SHA1 test vectors  from from FIPS PUB 180-1
 154  */
 155 #define SHA1_TEST_VECTORS       2
 156
 157 struct hash_testvec sha1_tv_template[] = {
 158         {
 159                 .plaintext = "abc",
 160                 .psize  = 3,
 161                 .digest = { 0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a, 0xba, 0x3e,
 162                             0x25, 0x71, 0x78, 0x50, 0xc2, 0x6c, 0x9c, 0xd0, 0xd8, 0x9d },
 163         }, {
 164                 .plaintext = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 165                 .psize  = 56,
 166                 .digest = { 0x84, 0x98, 0x3e, 0x44, 0x1c, 0x3b, 0xd2, 0x6e, 0xba, 0xae,
 167                             0x4a, 0xa1, 0xf9, 0x51, 0x29, 0xe5, 0xe5, 0x46, 0x70, 0xf1 },
 168                 .np     = 2,
 169                 .tap    = { 28, 28 }
 170         }
 171 };
 172
 173 /*
 174  * SHA256 test vectors from from NIST
 175  */
 176 #define SHA256_TEST_VECTORS     2
 177
 178 struct hash_testvec sha256_tv_template[] = {
 179         {
 180                 .plaintext = "abc",
 181                 .psize  = 3,
 182                 .digest = { 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
 183                             0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23,
 184                             0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
 185                             0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad },
 186         }, {
 187                 .plaintext = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 188                 .psize  = 56,
 189                 .digest = { 0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8,
 190                             0xe5, 0xc0, 0x26, 0x93, 0x0c, 0x3e, 0x60, 0x39,
 191                             0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67,
 192                             0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1 },
 193                 .np     = 2,
 194                 .tap    = { 28, 28 }
 195         },
 196 };
 197
 198 /*
 199  * SHA384 test vectors from from NIST and kerneli
 200  */
 201 #define SHA384_TEST_VECTORS     4
 202
 203 struct hash_testvec sha384_tv_template[] = {
 204         {
 205                 .plaintext= "abc",
 206                 .psize  = 3,
 207                 .digest = { 0xcb, 0x00, 0x75, 0x3f, 0x45, 0xa3, 0x5e, 0x8b,
 208                             0xb5, 0xa0, 0x3d, 0x69, 0x9a, 0xc6, 0x50, 0x07,
 209                             0x27, 0x2c, 0x32, 0xab, 0x0e, 0xde, 0xd1, 0x63,
 210                             0x1a, 0x8b, 0x60, 0x5a, 0x43, 0xff, 0x5b, 0xed,
 211                             0x80, 0x86, 0x07, 0x2b, 0xa1, 0xe7, 0xcc, 0x23,
 212                             0x58, 0xba, 0xec, 0xa1, 0x34, 0xc8, 0x25, 0xa7 },
 213         }, {
 214                 .plaintext = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 215                 .psize  = 56,
 216                 .digest = { 0x33, 0x91, 0xfd, 0xdd, 0xfc, 0x8d, 0xc7, 0x39,
 217                             0x37, 0x07, 0xa6, 0x5b, 0x1b, 0x47, 0x09, 0x39,
 218                             0x7c, 0xf8, 0xb1, 0xd1, 0x62, 0xaf, 0x05, 0xab,
 219                             0xfe, 0x8f, 0x45, 0x0d, 0xe5, 0xf3, 0x6b, 0xc6,
 220                             0xb0, 0x45, 0x5a, 0x85, 0x20, 0xbc, 0x4e, 0x6f,
 221                             0x5f, 0xe9, 0x5b, 0x1f, 0xe3, 0xc8, 0x45, 0x2b},
 222         }, {
 223                 .plaintext = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
 224                              "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
 225                 .psize  = 112,
 226                 .digest = { 0x09, 0x33, 0x0c, 0x33, 0xf7, 0x11, 0x47, 0xe8,
 227                             0x3d, 0x19, 0x2f, 0xc7, 0x82, 0xcd, 0x1b, 0x47,
 228                             0x53, 0x11, 0x1b, 0x17, 0x3b, 0x3b, 0x05, 0xd2,
 229                             0x2f, 0xa0, 0x80, 0x86, 0xe3, 0xb0, 0xf7, 0x12,
 230                             0xfc, 0xc7, 0xc7, 0x1a, 0x55, 0x7e, 0x2d, 0xb9,
 231                             0x66, 0xc3, 0xe9, 0xfa, 0x91, 0x74, 0x60, 0x39  },
 232         }, {
 233                 .plaintext = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
 234                              "efghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
 235                 .psize  = 104,
 236                 .digest = { 0x3d, 0x20, 0x89, 0x73, 0xab, 0x35, 0x08, 0xdb,
 237                             0xbd, 0x7e, 0x2c, 0x28, 0x62, 0xba, 0x29, 0x0a,
 238                             0xd3, 0x01, 0x0e, 0x49, 0x78, 0xc1, 0x98, 0xdc,
 239                             0x4d, 0x8f, 0xd0, 0x14, 0xe5, 0x82, 0x82, 0x3a,
 240                             0x89, 0xe1, 0x6f, 0x9b, 0x2a, 0x7b, 0xbc, 0x1a,
 241                             0xc9, 0x38, 0xe2, 0xd1, 0x99, 0xe8, 0xbe, 0xa4 },
 242                 .np     = 4,
 243                 .tap    = { 26, 26, 26, 26 }
 244         },
 245 };
 246
 247 /*
 248  * SHA512 test vectors from from NIST and kerneli
 249  */
 250 #define SHA512_TEST_VECTORS     4
 251
 252 struct hash_testvec sha512_tv_template[] = {
 253         {
 254                 .plaintext = "abc",
 255                 .psize  = 3,
 256                 .digest = { 0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba,
 257                             0xcc, 0x41, 0x73, 0x49, 0xae, 0x20, 0x41, 0x31,
 258                             0x12, 0xe6, 0xfa, 0x4e, 0x89, 0xa9, 0x7e, 0xa2,
 259                             0x0a, 0x9e, 0xee, 0xe6, 0x4b, 0x55, 0xd3, 0x9a,
 260                             0x21, 0x92, 0x99, 0x2a, 0x27, 0x4f, 0xc1, 0xa8,
 261                             0x36, 0xba, 0x3c, 0x23, 0xa3, 0xfe, 0xeb, 0xbd,
 262                             0x45, 0x4d, 0x44, 0x23, 0x64, 0x3c, 0xe8, 0x0e,
 263                             0x2a, 0x9a, 0xc9, 0x4f, 0xa5, 0x4c, 0xa4, 0x9f },
 264         }, {
 265                 .plaintext = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 266                 .psize  = 56,
 267                 .digest = { 0x20, 0x4a, 0x8f, 0xc6, 0xdd, 0xa8, 0x2f, 0x0a,
 268                             0x0c, 0xed, 0x7b, 0xeb, 0x8e, 0x08, 0xa4, 0x16,
 269                             0x57, 0xc1, 0x6e, 0xf4, 0x68, 0xb2, 0x28, 0xa8,
 270                             0x27, 0x9b, 0xe3, 0x31, 0xa7, 0x03, 0xc3, 0x35,
 271                             0x96, 0xfd, 0x15, 0xc1, 0x3b, 0x1b, 0x07, 0xf9,
 272                             0xaa, 0x1d, 0x3b, 0xea, 0x57, 0x78, 0x9c, 0xa0,
 273                             0x31, 0xad, 0x85, 0xc7, 0xa7, 0x1d, 0xd7, 0x03,
 274                             0x54, 0xec, 0x63, 0x12, 0x38, 0xca, 0x34, 0x45 },
 275         }, {
 276                 .plaintext = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
 277                              "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
 278                 .psize  = 112,
 279                 .digest = { 0x8e, 0x95, 0x9b, 0x75, 0xda, 0xe3, 0x13, 0xda,
 280                             0x8c, 0xf4, 0xf7, 0x28, 0x14, 0xfc, 0x14, 0x3f,
 281                             0x8f, 0x77, 0x79, 0xc6, 0xeb, 0x9f, 0x7f, 0xa1,
 282                             0x72, 0x99, 0xae, 0xad, 0xb6, 0x88, 0x90, 0x18,
 283                             0x50, 0x1d, 0x28, 0x9e, 0x49, 0x00, 0xf7, 0xe4,
 284                             0x33, 0x1b, 0x99, 0xde, 0xc4, 0xb5, 0x43, 0x3a,
 285                             0xc7, 0xd3, 0x29, 0xee, 0xb6, 0xdd, 0x26, 0x54,
 286                             0x5e, 0x96, 0xe5, 0x5b, 0x87, 0x4b, 0xe9, 0x09 },
 287         }, {
 288                 .plaintext = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
 289                              "efghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
 290                 .psize  = 104,
 291                 .digest = { 0x93, 0x0d, 0x0c, 0xef, 0xcb, 0x30, 0xff, 0x11,
 292                             0x33, 0xb6, 0x89, 0x81, 0x21, 0xf1, 0xcf, 0x3d,
 293                             0x27, 0x57, 0x8a, 0xfc, 0xaf, 0xe8, 0x67, 0x7c,
 294                             0x52, 0x57, 0xcf, 0x06, 0x99, 0x11, 0xf7, 0x5d,
 295                             0x8f, 0x58, 0x31, 0xb5, 0x6e, 0xbf, 0xda, 0x67,
 296                             0xb2, 0x78, 0xe6, 0x6d, 0xff, 0x8b, 0x84, 0xfe,
 297                             0x2b, 0x28, 0x70, 0xf7, 0x42, 0xa5, 0x80, 0xd8,
 298                             0xed, 0xb4, 0x19, 0x87, 0x23, 0x28, 0x50, 0xc9 },
 299                 .np     = 4,
 300                 .tap    = { 26, 26, 26, 26 }
 301         },
 302 };
 303
 304 #ifdef CONFIG_CRYPTO_HMAC
 305 /*
 306  * HMAC-MD5 test vectors from RFC2202
 307  * (These need to be fixed to not use strlen).
 308  */
 309 #define HMAC_MD5_TEST_VECTORS   7
 310
 311 struct hmac_testvec hmac_md5_tv_template[] =
 312 {
 313         {
 314                 .key    = { [0 ... 15] =  0x0b },
 315                 .ksize  = 16,
 316                 .plaintext = "Hi There",
 317                 .psize  = 8,
 318                 .digest = { 0x92, 0x94, 0x72, 0x7a, 0x36, 0x38, 0xbb, 0x1c,
 319                             0x13, 0xf4, 0x8e, 0xf8, 0x15, 0x8b, 0xfc, 0x9d },
 320         }, {
 321                 .key    = { 'J', 'e', 'f', 'e' },
 322                 .ksize  = 4,
 323                 .plaintext = "what do ya want for nothing?",
 324                 .psize  = 28,
 325                 .digest = { 0x75, 0x0c, 0x78, 0x3e, 0x6a, 0xb0, 0xb5, 0x03,
 326                             0xea, 0xa8, 0x6e, 0x31, 0x0a, 0x5d, 0xb7, 0x38 },
 327                 .np     = 2,
 328                 .tap    = {14, 14}
 329         }, {
 330                 .key    = { [0 ... 15] = 0xaa },
 331                 .ksize  = 16,
 332                 .plaintext = { [0 ... 49] =  0xdd },
 333                 .psize  = 50,
 334                 .digest = { 0x56, 0xbe, 0x34, 0x52, 0x1d, 0x14, 0x4c, 0x88,
 335                             0xdb, 0xb8, 0xc7, 0x33, 0xf0, 0xe8, 0xb3, 0xf6 },
 336         }, {
 337                 .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 338                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 339                             0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, },
 340                 .ksize  = 25,
 341                 .plaintext = { [0 ... 49] =  0xcd },
 342                 .psize  = 50,
 343                 .digest = { 0x69, 0x7e, 0xaf, 0x0a, 0xca, 0x3a, 0x3a, 0xea,
 344                             0x3a, 0x75, 0x16, 0x47, 0x46, 0xff, 0xaa, 0x79 },
 345         }, {
 346                 .key    = { [0 ... 15] = 0x0c },
 347                 .ksize  = 16,
 348                 .plaintext = "Test With Truncation",
 349                 .psize  = 20,
 350                 .digest = { 0x56, 0x46, 0x1e, 0xf2, 0x34, 0x2e, 0xdc, 0x00,
 351                             0xf9, 0xba, 0xb9, 0x95, 0x69, 0x0e, 0xfd, 0x4c },
 352         }, {
 353                 .key    = { [0 ... 79] =  0xaa },
 354                 .ksize  = 80,
 355                 .plaintext = "Test Using Larger Than Block-Size Key - Hash Key First",
 356                 .psize  = 54,
 357                 .digest = { 0x6b, 0x1a, 0xb7, 0xfe, 0x4b, 0xd7, 0xbf, 0x8f,
 358                             0x0b, 0x62, 0xe6, 0xce, 0x61, 0xb9, 0xd0, 0xcd },
 359         }, {
 360                 .key    = { [0 ... 79] =  0xaa },
 361                 .ksize  = 80,
 362                 .plaintext = "Test Using Larger Than Block-Size Key and Larger Than One "
 363                              "Block-Size Data",
 364                 .psize  = 73,
 365                 .digest = { 0x6f, 0x63, 0x0f, 0xad, 0x67, 0xcd, 0xa0, 0xee,
 366                             0x1f, 0xb1, 0xf5, 0x62, 0xdb, 0x3a, 0xa5, 0x3e },
 367         },
 368 };
 369
 370 /*
 371  * HMAC-SHA1 test vectors from RFC2202
 372  */
 373 #define HMAC_SHA1_TEST_VECTORS  7
 374
 375 struct hmac_testvec hmac_sha1_tv_template[] = {
 376         {
 377                 .key    = { [0 ... 19] = 0x0b },
 378                 .ksize  = 20,
 379                 .plaintext = "Hi There",
 380                 .psize  = 8,
 381                 .digest = { 0xb6, 0x17, 0x31, 0x86, 0x55, 0x05, 0x72, 0x64,
 382                             0xe2, 0x8b, 0xc0, 0xb6, 0xfb, 0x37, 0x8c, 0x8e, 0xf1,
 383                             0x46, 0xbe },
 384         }, {
 385                 .key    = { 'J', 'e', 'f', 'e' },
 386                 .ksize  = 4,
 387                 .plaintext = "what do ya want for nothing?",
 388                 .psize  = 28,
 389                 .digest = { 0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, 0x2f, 0xa2, 0xd2, 0x74,
 390                             0x16, 0xd5, 0xf1, 0x84, 0xdf, 0x9c, 0x25, 0x9a, 0x7c, 0x79 },
 391                 .np     = 2,
 392                 .tap    = { 14, 14 }
 393         }, {
 394                 .key    = { [0 ... 19] = 0xaa },
 395                 .ksize  = 20,
 396                 .plaintext = { [0 ... 49] = 0xdd },
 397                 .psize  = 50,
 398                 .digest = { 0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, 0x11, 0xcd, 0x91, 0xa3,
 399                             0x9a, 0xf4, 0x8a, 0xa1, 0x7b, 0x4f, 0x63, 0xf1, 0x75, 0xd3 },
 400         }, {
 401                 .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 402                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 403                             0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 },
 404                 .ksize  = 25,
 405                 .plaintext = { [0 ... 49] = 0xcd },
 406                 .psize  = 50,
 407                 .digest = { 0x4c, 0x90, 0x07, 0xf4, 0x02, 0x62, 0x50, 0xc6, 0xbc, 0x84,
 408                             0x14, 0xf9, 0xbf, 0x50, 0xc8, 0x6c, 0x2d, 0x72, 0x35, 0xda },
 409         }, {
 410                 .key    = { [0 ... 19] = 0x0c },
 411                 .ksize  = 20,
 412                 .plaintext = "Test With Truncation",
 413                 .psize  = 20,
 414                 .digest = { 0x4c, 0x1a, 0x03, 0x42, 0x4b, 0x55, 0xe0, 0x7f, 0xe7, 0xf2,
 415                             0x7b, 0xe1, 0xd5, 0x8b, 0xb9, 0x32, 0x4a, 0x9a, 0x5a, 0x04 },
 416         }, {
 417                 .key    = { [0 ... 79] = 0xaa },
 418                 .ksize  = 80,
 419                 .plaintext = "Test Using Larger Than Block-Size Key - Hash Key First",
 420                 .psize  = 54,
 421                 .digest = { 0xaa, 0x4a, 0xe5, 0xe1, 0x52, 0x72, 0xd0, 0x0e, 0x95, 0x70,
 422                             0x56, 0x37, 0xce, 0x8a, 0x3b, 0x55, 0xed, 0x40, 0x21, 0x12 },
 423         }, {
 424                 .key    = { [0 ... 79] = 0xaa },
 425                 .ksize  = 80,
 426                 .plaintext = "Test Using Larger Than Block-Size Key and Larger Than One "
 427                              "Block-Size Data",
 428                 .psize  = 73,
 429                 .digest = { 0xe8, 0xe9, 0x9d, 0x0f, 0x45, 0x23, 0x7d, 0x78, 0x6d, 0x6b,
 430                             0xba, 0xa7, 0x96, 0x5c, 0x78, 0x08, 0xbb, 0xff, 0x1a, 0x91 },
 431         },
 432 };
 433
 434 /*
 435  * HMAC-SHA256 test vectors from
 436  * draft-ietf-ipsec-ciph-sha-256-01.txt
 437  */
 438 #define HMAC_SHA256_TEST_VECTORS        10
 439
 440 struct hmac_testvec hmac_sha256_tv_template[] = {
 441         {
 442                 .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 443                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 444                             0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
 445                             0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20},
 446                 .ksize  = 32,
 447                 .plaintext = "abc",
 448                 .psize  = 3,
 449                 .digest = { 0xa2, 0x1b, 0x1f, 0x5d, 0x4c, 0xf4, 0xf7, 0x3a,
 450                             0x4d, 0xd9, 0x39, 0x75, 0x0f, 0x7a, 0x06, 0x6a,
 451                             0x7f, 0x98, 0xcc, 0x13, 0x1c, 0xb1, 0x6a, 0x66,
 452                             0x92, 0x75, 0x90, 0x21, 0xcf, 0xab, 0x81, 0x81 },
 453         }, {
 454                 .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 455                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 456                             0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
 457                             0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20 },
 458                 .ksize  = 32,
 459                 .plaintext = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 460                 .psize  = 56,
 461                 .digest = { 0x10, 0x4f, 0xdc, 0x12, 0x57, 0x32, 0x8f, 0x08,
 462                             0x18, 0x4b, 0xa7, 0x31, 0x31, 0xc5, 0x3c, 0xae,
 463                             0xe6, 0x98, 0xe3, 0x61, 0x19, 0x42, 0x11, 0x49,
 464                             0xea, 0x8c, 0x71, 0x24, 0x56, 0x69, 0x7d, 0x30 },
 465         }, {
 466                 .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 467                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 468                             0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
 469                             0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20 },
 470                 .ksize  = 32,
 471                 .plaintext = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
 472                              "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 473                 .psize  = 112,
 474                 .digest = { 0x47, 0x03, 0x05, 0xfc, 0x7e, 0x40, 0xfe, 0x34,
 475                             0xd3, 0xee, 0xb3, 0xe7, 0x73, 0xd9, 0x5a, 0xab,
 476                             0x73, 0xac, 0xf0, 0xfd, 0x06, 0x04, 0x47, 0xa5,
 477                             0xeb, 0x45, 0x95, 0xbf, 0x33, 0xa9, 0xd1, 0xa3 },
 478         }, {
 479                 .key    = { [0 ... 31] = 0x0b },
 480                 .ksize  = 32,
 481                 .plaintext = "Hi There",
 482                 .psize  = 8,
 483                 .digest = { 0x19, 0x8a, 0x60, 0x7e, 0xb4, 0x4b, 0xfb, 0xc6,
 484                             0x99, 0x03, 0xa0, 0xf1, 0xcf, 0x2b, 0xbd, 0xc5,
 485                             0xba, 0x0a, 0xa3, 0xf3, 0xd9, 0xae, 0x3c, 0x1c,
 486                             0x7a, 0x3b, 0x16, 0x96, 0xa0, 0xb6, 0x8c, 0xf7 },
 487         }, {
 488                 .key    = "Jefe",
 489                 .ksize  = 4,
 490                 .plaintext = "what do ya want for nothing?",
 491                 .psize  = 28,
 492                 .digest = { 0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e,
 493                             0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7,
 494                             0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83,
 495                             0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43 },
 496                 .np     = 2,
 497                 .tap    = { 14, 14 }
 498         }, {
 499                 .key    = { [0 ... 31] = 0xaa },
 500                 .ksize  = 32,
 501                 .plaintext = { [0 ... 49] = 0xdd },
 502                 .psize  = 50,
 503                 .digest = { 0xcd, 0xcb, 0x12, 0x20, 0xd1, 0xec, 0xcc, 0xea,
 504                             0x91, 0xe5, 0x3a, 0xba, 0x30, 0x92, 0xf9, 0x62,
 505                             0xe5, 0x49, 0xfe, 0x6c, 0xe9, 0xed, 0x7f, 0xdc,
 506                             0x43, 0x19, 0x1f, 0xbd, 0xe4, 0x5c, 0x30, 0xb0 },
 507         }, {
 508                 .key    = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 509                             0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 510                             0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
 511                             0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
 512                             0x21, 0x22, 0x23, 0x24, 0x25 },
 513                 .ksize  = 37,
 514                 .plaintext = { [0 ... 49] = 0xcd },
 515                 .psize  = 50,
 516                 .digest = { 0xd4, 0x63, 0x3c, 0x17, 0xf6, 0xfb, 0x8d, 0x74,
 517                             0x4c, 0x66, 0xde, 0xe0, 0xf8, 0xf0, 0x74, 0x55,
 518                             0x6e, 0xc4, 0xaf, 0x55, 0xef, 0x07, 0x99, 0x85,
 519                             0x41, 0x46, 0x8e, 0xb4, 0x9b, 0xd2, 0xe9, 0x17 },
 520         }, {
 521                 .key    = { [0 ... 31] = 0x0c },
 522                 .ksize  = 32,
 523                 .plaintext = "Test With Truncation",
 524                 .psize  = 20,
 525                 .digest = { 0x75, 0x46, 0xaf, 0x01, 0x84, 0x1f, 0xc0, 0x9b,
 526                             0x1a, 0xb9, 0xc3, 0x74, 0x9a, 0x5f, 0x1c, 0x17,
 527                             0xd4, 0xf5, 0x89, 0x66, 0x8a, 0x58, 0x7b, 0x27,
 528                             0x00, 0xa9, 0xc9, 0x7c, 0x11, 0x93, 0xcf, 0x42 },
 529         }, {
 530                 .key    = { [0 ... 79] = 0xaa },
 531                 .ksize  = 80,
 532                 .plaintext = "Test Using Larger Than Block-Size Key - Hash Key First",
 533                 .psize  = 54,
 534                 .digest = { 0x69, 0x53, 0x02, 0x5e, 0xd9, 0x6f, 0x0c, 0x09,
 535                             0xf8, 0x0a, 0x96, 0xf7, 0x8e, 0x65, 0x38, 0xdb,
 536                             0xe2, 0xe7, 0xb8, 0x20, 0xe3, 0xdd, 0x97, 0x0e,
 537                             0x7d, 0xdd, 0x39, 0x09, 0x1b, 0x32, 0x35, 0x2f },
 538         }, {
 539                 .key    = { [0 ... 79] = 0xaa },
 540                 .ksize  = 80,
 541                 .plaintext = "Test Using Larger Than Block-Size Key and Larger Than "
 542                              "One Block-Size Data",
 543                 .psize  = 73,
 544                 .digest = { 0x63, 0x55, 0xac, 0x22, 0xe8, 0x90, 0xd0, 0xa3,
 545                             0xc8, 0x48, 0x1a, 0x5c, 0xa4, 0x82, 0x5b, 0xc8,
 546                             0x84, 0xd3, 0xe7, 0xa1, 0xff, 0x98, 0xa2, 0xfc,
 547                             0x2a, 0xc7, 0xd8, 0xe0, 0x64, 0xc3, 0xb2, 0xe6 },
 548         },
 549 };
 550
 551 #endif  /* CONFIG_CRYPTO_HMAC */
 552
 553 /*
 554  * WHIRLPOOL test vectors from Whirlpool package
 555  * by Vincent Rijmen and Paulo S. L. M. Barreto as part of the NESSIE
 556  * submission
 557  */
 558 #define WP512_TEST_VECTORS      8
 559
 560 struct hash_testvec wp512_tv_template[] = {
 561         {
 562                 .plaintext = "",
 563                 .psize  = 0,
 564                 .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66,
 565                             0x9B, 0x44, 0xE3, 0x9C, 0x1D, 0x2E, 0x17, 0x26,
 566                             0xC5, 0x30, 0x23, 0x21, 0x30, 0xD4, 0x07, 0xF8,
 567                             0x9A, 0xFE, 0xE0, 0x96, 0x49, 0x97, 0xF7, 0xA7,
 568                             0x3E, 0x83, 0xBE, 0x69, 0x8B, 0x28, 0x8F, 0xEB,
 569                             0xCF, 0x88, 0xE3, 0xE0, 0x3C, 0x4F, 0x07, 0x57,
 570                             0xEA, 0x89, 0x64, 0xE5, 0x9B, 0x63, 0xD9, 0x37,
 571                             0x08, 0xB1, 0x38, 0xCC, 0x42, 0xA6, 0x6E, 0xB3 },
 572
 573
 574         }, {
 575                 .plaintext = "a",
 576                 .psize  = 1,
 577                 .digest = { 0x8A, 0xCA, 0x26, 0x02, 0x79, 0x2A, 0xEC, 0x6F,
 578                             0x11, 0xA6, 0x72, 0x06, 0x53, 0x1F, 0xB7, 0xD7,
 579                             0xF0, 0xDF, 0xF5, 0x94, 0x13, 0x14, 0x5E, 0x69,
 580                             0x73, 0xC4, 0x50, 0x01, 0xD0, 0x08, 0x7B, 0x42,
 581                             0xD1, 0x1B, 0xC6, 0x45, 0x41, 0x3A, 0xEF, 0xF6,
 582                             0x3A, 0x42, 0x39, 0x1A, 0x39, 0x14, 0x5A, 0x59,
 583                             0x1A, 0x92, 0x20, 0x0D, 0x56, 0x01, 0x95, 0xE5,
 584                             0x3B, 0x47, 0x85, 0x84, 0xFD, 0xAE, 0x23, 0x1A },
 585         }, {
 586                 .plaintext = "abc",
 587                 .psize  = 3,
 588                 .digest = { 0x4E, 0x24, 0x48, 0xA4, 0xC6, 0xF4, 0x86, 0xBB,
 589                             0x16, 0xB6, 0x56, 0x2C, 0x73, 0xB4, 0x02, 0x0B,
 590                             0xF3, 0x04, 0x3E, 0x3A, 0x73, 0x1B, 0xCE, 0x72,
 591                             0x1A, 0xE1, 0xB3, 0x03, 0xD9, 0x7E, 0x6D, 0x4C,
 592                             0x71, 0x81, 0xEE, 0xBD, 0xB6, 0xC5, 0x7E, 0x27,
 593                             0x7D, 0x0E, 0x34, 0x95, 0x71, 0x14, 0xCB, 0xD6,
 594                             0xC7, 0x97, 0xFC, 0x9D, 0x95, 0xD8, 0xB5, 0x82,
 595                             0xD2, 0x25, 0x29, 0x20, 0x76, 0xD4, 0xEE, 0xF5 },
 596         }, {
 597                 .plaintext = "message digest",
 598                 .psize  = 14,
 599                 .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6,
 600                             0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC,
 601                             0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C,
 602                             0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B,
 603                             0x84, 0x21, 0x55, 0x76, 0x59, 0xEF, 0x55, 0xC1,
 604                             0x06, 0xB4, 0xB5, 0x2A, 0xC5, 0xA4, 0xAA, 0xA6,
 605                             0x92, 0xED, 0x92, 0x00, 0x52, 0x83, 0x8F, 0x33,
 606                             0x62, 0xE8, 0x6D, 0xBD, 0x37, 0xA8, 0x90, 0x3E },
 607         }, {
 608                 .plaintext = "abcdefghijklmnopqrstuvwxyz",
 609                 .psize  = 26,
 610                 .digest = { 0xF1, 0xD7, 0x54, 0x66, 0x26, 0x36, 0xFF, 0xE9,
 611                             0x2C, 0x82, 0xEB, 0xB9, 0x21, 0x2A, 0x48, 0x4A,
 612                             0x8D, 0x38, 0x63, 0x1E, 0xAD, 0x42, 0x38, 0xF5,
 613                             0x44, 0x2E, 0xE1, 0x3B, 0x80, 0x54, 0xE4, 0x1B,
 614                             0x08, 0xBF, 0x2A, 0x92, 0x51, 0xC3, 0x0B, 0x6A,
 615                             0x0B, 0x8A, 0xAE, 0x86, 0x17, 0x7A, 0xB4, 0xA6,
 616                             0xF6, 0x8F, 0x67, 0x3E, 0x72, 0x07, 0x86, 0x5D,
 617                             0x5D, 0x98, 0x19, 0xA3, 0xDB, 0xA4, 0xEB, 0x3B },
 618         }, {
 619                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 620                              "abcdefghijklmnopqrstuvwxyz0123456789",
 621                 .psize  = 62,
 622                 .digest = { 0xDC, 0x37, 0xE0, 0x08, 0xCF, 0x9E, 0xE6, 0x9B,
 623                             0xF1, 0x1F, 0x00, 0xED, 0x9A, 0xBA, 0x26, 0x90,
 624                             0x1D, 0xD7, 0xC2, 0x8C, 0xDE, 0xC0, 0x66, 0xCC,
 625                             0x6A, 0xF4, 0x2E, 0x40, 0xF8, 0x2F, 0x3A, 0x1E,
 626                             0x08, 0xEB, 0xA2, 0x66, 0x29, 0x12, 0x9D, 0x8F,
 627                             0xB7, 0xCB, 0x57, 0x21, 0x1B, 0x92, 0x81, 0xA6,
 628                             0x55, 0x17, 0xCC, 0x87, 0x9D, 0x7B, 0x96, 0x21,
 629                             0x42, 0xC6, 0x5F, 0x5A, 0x7A, 0xF0, 0x14, 0x67 },
 630         }, {
 631                 .plaintext = "1234567890123456789012345678901234567890"
 632                              "1234567890123456789012345678901234567890",
 633                 .psize  = 80,
 634                 .digest = { 0x46, 0x6E, 0xF1, 0x8B, 0xAB, 0xB0, 0x15, 0x4D,
 635                             0x25, 0xB9, 0xD3, 0x8A, 0x64, 0x14, 0xF5, 0xC0,
 636                             0x87, 0x84, 0x37, 0x2B, 0xCC, 0xB2, 0x04, 0xD6,
 637                             0x54, 0x9C, 0x4A, 0xFA, 0xDB, 0x60, 0x14, 0x29,
 638                             0x4D, 0x5B, 0xD8, 0xDF, 0x2A, 0x6C, 0x44, 0xE5,
 639                             0x38, 0xCD, 0x04, 0x7B, 0x26, 0x81, 0xA5, 0x1A,
 640                             0x2C, 0x60, 0x48, 0x1E, 0x88, 0xC5, 0xA2, 0x0B,
 641                             0x2C, 0x2A, 0x80, 0xCF, 0x3A, 0x9A, 0x08, 0x3B },
 642         }, {
 643                 .plaintext = "abcdbcdecdefdefgefghfghighijhijk",
 644                 .psize  = 32,
 645                 .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61,
 646                             0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48,
 647                             0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62,
 648                             0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69,
 649                             0x16, 0xBD, 0xC8, 0x03, 0x1B, 0xC5, 0xBE, 0x1B,
 650                             0x7B, 0x94, 0x76, 0x39, 0xFE, 0x05, 0x0B, 0x56,
 651                             0x93, 0x9B, 0xAA, 0xA0, 0xAD, 0xFF, 0x9A, 0xE6,
 652                             0x74, 0x5B, 0x7B, 0x18, 0x1C, 0x3B, 0xE3, 0xFD },
 653         },
 654 };
 655
 656 #define WP384_TEST_VECTORS      8
 657
 658 struct hash_testvec wp384_tv_template[] = {
 659         {
 660                 .plaintext = "",
 661                 .psize  = 0,
 662                 .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66,
 663                             0x9B, 0x44, 0xE3, 0x9C, 0x1D, 0x2E, 0x17, 0x26,
 664                             0xC5, 0x30, 0x23, 0x21, 0x30, 0xD4, 0x07, 0xF8,
 665                             0x9A, 0xFE, 0xE0, 0x96, 0x49, 0x97, 0xF7, 0xA7,
 666                             0x3E, 0x83, 0xBE, 0x69, 0x8B, 0x28, 0x8F, 0xEB,
 667                             0xCF, 0x88, 0xE3, 0xE0, 0x3C, 0x4F, 0x07, 0x57 },
 668
 669
 670         }, {
 671                 .plaintext = "a",
 672                 .psize  = 1,
 673                 .digest = { 0x8A, 0xCA, 0x26, 0x02, 0x79, 0x2A, 0xEC, 0x6F,
 674                             0x11, 0xA6, 0x72, 0x06, 0x53, 0x1F, 0xB7, 0xD7,
 675                             0xF0, 0xDF, 0xF5, 0x94, 0x13, 0x14, 0x5E, 0x69,
 676                             0x73, 0xC4, 0x50, 0x01, 0xD0, 0x08, 0x7B, 0x42,
 677                             0xD1, 0x1B, 0xC6, 0x45, 0x41, 0x3A, 0xEF, 0xF6,
 678                             0x3A, 0x42, 0x39, 0x1A, 0x39, 0x14, 0x5A, 0x59 },
 679         }, {
 680                 .plaintext = "abc",
 681                 .psize  = 3,
 682                 .digest = { 0x4E, 0x24, 0x48, 0xA4, 0xC6, 0xF4, 0x86, 0xBB,
 683                             0x16, 0xB6, 0x56, 0x2C, 0x73, 0xB4, 0x02, 0x0B,
 684                             0xF3, 0x04, 0x3E, 0x3A, 0x73, 0x1B, 0xCE, 0x72,
 685                             0x1A, 0xE1, 0xB3, 0x03, 0xD9, 0x7E, 0x6D, 0x4C,
 686                             0x71, 0x81, 0xEE, 0xBD, 0xB6, 0xC5, 0x7E, 0x27,
 687                             0x7D, 0x0E, 0x34, 0x95, 0x71, 0x14, 0xCB, 0xD6 },
 688         }, {
 689                 .plaintext = "message digest",
 690                 .psize  = 14,
 691                 .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6,
 692                             0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC,
 693                             0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C,
 694                             0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B,
 695                             0x84, 0x21, 0x55, 0x76, 0x59, 0xEF, 0x55, 0xC1,
 696                             0x06, 0xB4, 0xB5, 0x2A, 0xC5, 0xA4, 0xAA, 0xA6 },
 697         }, {
 698                 .plaintext = "abcdefghijklmnopqrstuvwxyz",
 699                 .psize  = 26,
 700                 .digest = { 0xF1, 0xD7, 0x54, 0x66, 0x26, 0x36, 0xFF, 0xE9,
 701                             0x2C, 0x82, 0xEB, 0xB9, 0x21, 0x2A, 0x48, 0x4A,
 702                             0x8D, 0x38, 0x63, 0x1E, 0xAD, 0x42, 0x38, 0xF5,
 703                             0x44, 0x2E, 0xE1, 0x3B, 0x80, 0x54, 0xE4, 0x1B,
 704                             0x08, 0xBF, 0x2A, 0x92, 0x51, 0xC3, 0x0B, 0x6A,
 705                             0x0B, 0x8A, 0xAE, 0x86, 0x17, 0x7A, 0xB4, 0xA6 },
 706         }, {
 707                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 708                              "abcdefghijklmnopqrstuvwxyz0123456789",
 709                 .psize  = 62,
 710                 .digest = { 0xDC, 0x37, 0xE0, 0x08, 0xCF, 0x9E, 0xE6, 0x9B,
 711                             0xF1, 0x1F, 0x00, 0xED, 0x9A, 0xBA, 0x26, 0x90,
 712                             0x1D, 0xD7, 0xC2, 0x8C, 0xDE, 0xC0, 0x66, 0xCC,
 713                             0x6A, 0xF4, 0x2E, 0x40, 0xF8, 0x2F, 0x3A, 0x1E,
 714                             0x08, 0xEB, 0xA2, 0x66, 0x29, 0x12, 0x9D, 0x8F,
 715                             0xB7, 0xCB, 0x57, 0x21, 0x1B, 0x92, 0x81, 0xA6 },
 716         }, {
 717                 .plaintext = "1234567890123456789012345678901234567890"
 718                              "1234567890123456789012345678901234567890",
 719                 .psize  = 80,
 720                 .digest = { 0x46, 0x6E, 0xF1, 0x8B, 0xAB, 0xB0, 0x15, 0x4D,
 721                             0x25, 0xB9, 0xD3, 0x8A, 0x64, 0x14, 0xF5, 0xC0,
 722                             0x87, 0x84, 0x37, 0x2B, 0xCC, 0xB2, 0x04, 0xD6,
 723                             0x54, 0x9C, 0x4A, 0xFA, 0xDB, 0x60, 0x14, 0x29,
 724                             0x4D, 0x5B, 0xD8, 0xDF, 0x2A, 0x6C, 0x44, 0xE5,
 725                             0x38, 0xCD, 0x04, 0x7B, 0x26, 0x81, 0xA5, 0x1A },
 726         }, {
 727                 .plaintext = "abcdbcdecdefdefgefghfghighijhijk",
 728                 .psize  = 32,
 729                 .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61,
 730                             0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48,
 731                             0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62,
 732                             0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69,
 733                             0x16, 0xBD, 0xC8, 0x03, 0x1B, 0xC5, 0xBE, 0x1B,
 734                             0x7B, 0x94, 0x76, 0x39, 0xFE, 0x05, 0x0B, 0x56 },
 735         },
 736 };
 737
 738 #define WP256_TEST_VECTORS      8
 739
 740 struct hash_testvec wp256_tv_template[] = {
 741         {
 742                 .plaintext = "",
 743                 .psize  = 0,
 744                 .digest = { 0x19, 0xFA, 0x61, 0xD7, 0x55, 0x22, 0xA4, 0x66,
 745                             0x9B, 0x44, 0xE3, 0x9C, 0x1D, 0x2E, 0x17, 0x26,
 746                             0xC5, 0x30, 0x23, 0x21, 0x30, 0xD4, 0x07, 0xF8,
 747                             0x9A, 0xFE, 0xE0, 0x96, 0x49, 0x97, 0xF7, 0xA7 },
 748
 749
 750         }, {
 751                 .plaintext = "a",
 752                 .psize  = 1,
 753                 .digest = { 0x8A, 0xCA, 0x26, 0x02, 0x79, 0x2A, 0xEC, 0x6F,
 754                             0x11, 0xA6, 0x72, 0x06, 0x53, 0x1F, 0xB7, 0xD7,
 755                             0xF0, 0xDF, 0xF5, 0x94, 0x13, 0x14, 0x5E, 0x69,
 756                             0x73, 0xC4, 0x50, 0x01, 0xD0, 0x08, 0x7B, 0x42 },
 757         }, {
 758                 .plaintext = "abc",
 759                 .psize  = 3,
 760                 .digest = { 0x4E, 0x24, 0x48, 0xA4, 0xC6, 0xF4, 0x86, 0xBB,
 761                             0x16, 0xB6, 0x56, 0x2C, 0x73, 0xB4, 0x02, 0x0B,
 762                             0xF3, 0x04, 0x3E, 0x3A, 0x73, 0x1B, 0xCE, 0x72,
 763                             0x1A, 0xE1, 0xB3, 0x03, 0xD9, 0x7E, 0x6D, 0x4C },
 764         }, {
 765                 .plaintext = "message digest",
 766                 .psize  = 14,
 767                 .digest = { 0x37, 0x8C, 0x84, 0xA4, 0x12, 0x6E, 0x2D, 0xC6,
 768                             0xE5, 0x6D, 0xCC, 0x74, 0x58, 0x37, 0x7A, 0xAC,
 769                             0x83, 0x8D, 0x00, 0x03, 0x22, 0x30, 0xF5, 0x3C,
 770                             0xE1, 0xF5, 0x70, 0x0C, 0x0F, 0xFB, 0x4D, 0x3B },
 771         }, {
 772                 .plaintext = "abcdefghijklmnopqrstuvwxyz",
 773                 .psize  = 26,
 774                 .digest = { 0xF1, 0xD7, 0x54, 0x66, 0x26, 0x36, 0xFF, 0xE9,
 775                             0x2C, 0x82, 0xEB, 0xB9, 0x21, 0x2A, 0x48, 0x4A,
 776                             0x8D, 0x38, 0x63, 0x1E, 0xAD, 0x42, 0x38, 0xF5,
 777                             0x44, 0x2E, 0xE1, 0x3B, 0x80, 0x54, 0xE4, 0x1B },
 778         }, {
 779                 .plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 780                              "abcdefghijklmnopqrstuvwxyz0123456789",
 781                 .psize  = 62,
 782                 .digest = { 0xDC, 0x37, 0xE0, 0x08, 0xCF, 0x9E, 0xE6, 0x9B,
 783                             0xF1, 0x1F, 0x00, 0xED, 0x9A, 0xBA, 0x26, 0x90,
 784                             0x1D, 0xD7, 0xC2, 0x8C, 0xDE, 0xC0, 0x66, 0xCC,
 785                             0x6A, 0xF4, 0x2E, 0x40, 0xF8, 0x2F, 0x3A, 0x1E },
 786         }, {
 787                 .plaintext = "1234567890123456789012345678901234567890"
 788                              "1234567890123456789012345678901234567890",
 789                 .psize  = 80,
 790                 .digest = { 0x46, 0x6E, 0xF1, 0x8B, 0xAB, 0xB0, 0x15, 0x4D,
 791                             0x25, 0xB9, 0xD3, 0x8A, 0x64, 0x14, 0xF5, 0xC0,
 792                             0x87, 0x84, 0x37, 0x2B, 0xCC, 0xB2, 0x04, 0xD6,
 793                             0x54, 0x9C, 0x4A, 0xFA, 0xDB, 0x60, 0x14, 0x29 },
 794         }, {
 795                 .plaintext = "abcdbcdecdefdefgefghfghighijhijk",
 796                 .psize  = 32,
 797                 .digest = { 0x2A, 0x98, 0x7E, 0xA4, 0x0F, 0x91, 0x70, 0x61,
 798                             0xF5, 0xD6, 0xF0, 0xA0, 0xE4, 0x64, 0x4F, 0x48,
 799                             0x8A, 0x7A, 0x5A, 0x52, 0xDE, 0xEE, 0x65, 0x62,
 800                             0x07, 0xC5, 0x62, 0xF9, 0x88, 0xE9, 0x5C, 0x69 },
 801         },
 802 };
 803
 804 /*
 805  * DES test vectors.
 806  */
 807 #define DES_ENC_TEST_VECTORS            10
 808 #define DES_DEC_TEST_VECTORS            4
 809 #define DES_CBC_ENC_TEST_VECTORS        5
 810 #define DES_CBC_DEC_TEST_VECTORS        4
 811 #define DES3_EDE_ENC_TEST_VECTORS       3
 812 #define DES3_EDE_DEC_TEST_VECTORS       3
 813
 814 struct cipher_testvec des_enc_tv_template[] = {
 815         { /* From Applied Cryptography */
 816                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 817                 .klen   = 8,
 818                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
 819                 .ilen   = 8,
 820                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d },
 821                 .rlen   = 8,
 822         }, { /* Same key, different plaintext block */
 823                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 824                 .klen   = 8,
 825                 .input  = { 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 },
 826                 .ilen   = 8,
 827                 .result = { 0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
 828                 .rlen   = 8,
 829         }, { /* Sbox test from NBS */
 830                 .key    = { 0x7c, 0xa1, 0x10, 0x45, 0x4a, 0x1a, 0x6e, 0x57 },
 831                 .klen   = 8,
 832                 .input  = { 0x01, 0xa1, 0xd6, 0xd0, 0x39, 0x77, 0x67, 0x42 },
 833                 .ilen   = 8,
 834                 .result = { 0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b },
 835                 .rlen   = 8,
 836         }, { /* Three blocks */
 837                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 838                 .klen   = 8,
 839                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
 840                             0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99,
 841                             0xca, 0xfe, 0xba, 0xbe, 0xfe, 0xed, 0xbe, 0xef },
 842                 .ilen   = 24,
 843                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
 844                             0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b,
 845                             0xb4, 0x99, 0x26, 0xf7, 0x1f, 0xe1, 0xd4, 0x90 },
 846                 .rlen   = 24,
 847         }, { /* Weak key */
 848                 .fail   = 1,
 849                 .wk     = 1,
 850                 .key    = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
 851                 .klen   = 8,
 852                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
 853                 .ilen   = 8,
 854                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d },
 855                 .rlen   = 8,
 856         }, { /* Two blocks -- for testing encryption across pages */
 857                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 858                 .klen   = 8,
 859                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
 860                             0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 },
 861                 .ilen   = 16,
 862                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
 863                             0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
 864                 .rlen   = 16,
 865                 .np     = 2,
 866                 .tap    = { 8, 8 }
 867         }, { /* Four blocks -- for testing encryption with chunking */
 868                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 869                 .klen   = 8,
 870                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
 871                             0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99,
 872                             0xca, 0xfe, 0xba, 0xbe, 0xfe, 0xed, 0xbe, 0xef,
 873                             0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 },
 874                 .ilen   = 32,
 875                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
 876                             0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b,
 877                             0xb4, 0x99, 0x26, 0xf7, 0x1f, 0xe1, 0xd4, 0x90,
 878                             0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
 879                 .rlen   = 32,
 880                 .np     = 3,
 881                 .tap    = { 14, 10, 8 }
 882         }, {
 883                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 884                 .klen   = 8,
 885                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
 886                             0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99,
 887                             0xca, 0xfe, 0xba, 0xbe, 0xfe, 0xed, 0xbe, 0xef },
 888                 .ilen   = 24,
 889                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
 890                             0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b,
 891                             0xb4, 0x99, 0x26, 0xf7, 0x1f, 0xe1, 0xd4, 0x90 },
 892                 .rlen   = 24,
 893                 .np     = 4,
 894                 .tap    = { 2, 1, 3, 18 }
 895         }, {
 896                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 897                 .klen   = 8,
 898                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
 899                             0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 },
 900                 .ilen   = 16,
 901                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
 902                             0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
 903                 .rlen   = 16,
 904                 .np     = 5,
 905                 .tap    = { 2, 2, 2, 2, 8 }
 906         }, {
 907                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 908                 .klen   = 8,
 909                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
 910                 .ilen   = 8,
 911                 .result = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d },
 912                 .rlen   = 8,
 913                 .np     = 8,
 914                 .tap    = { 1, 1, 1, 1, 1, 1, 1, 1 }
 915         },
 916 };
 917
 918 struct cipher_testvec des_dec_tv_template[] = {
 919         { /* From Applied Cryptography */
 920                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 921                 .klen   = 8,
 922                 .input  = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d },
 923                 .ilen   = 8,
 924                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
 925                 .rlen   = 8,
 926         }, { /* Sbox test from NBS */
 927                 .key    = { 0x7c, 0xa1, 0x10, 0x45, 0x4a, 0x1a, 0x6e, 0x57 },
 928                 .klen   = 8,
 929                 .input  = { 0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b },
 930                 .ilen   = 8,
 931                 .result = { 0x01, 0xa1, 0xd6, 0xd0, 0x39, 0x77, 0x67, 0x42 },
 932                 .rlen   = 8,
 933         }, { /* Two blocks, for chunking test */
 934                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 935                 .klen   = 8,
 936                 .input  = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
 937                             0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b },
 938                 .ilen   = 16,
 939                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
 940                             0xa3, 0x99, 0x7b, 0xca, 0xaf, 0x69, 0xa0, 0xf5 },
 941                 .rlen   = 16,
 942                 .np     = 2,
 943                 .tap    = { 8, 8 }
 944         }, {
 945                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 946                 .klen   = 8,
 947                 .input  = { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
 948                             0x69, 0x0f, 0x5b, 0x0d, 0x9a, 0x26, 0x93, 0x9b },
 949                 .ilen   = 16,
 950                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
 951                             0xa3, 0x99, 0x7b, 0xca, 0xaf, 0x69, 0xa0, 0xf5 },
 952                 .rlen   = 16,
 953                 .np     = 3,
 954                 .tap    = { 3, 12, 1 }
 955         },
 956 };
 957
 958 struct cipher_testvec des_cbc_enc_tv_template[] = {
 959         { /* From OpenSSL */
 960                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
 961                 .klen   = 8,
 962                 .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
 963                 .input  = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
 964                             0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
 965                             0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
 966                 .ilen   = 24,
 967                 .result = { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
 968                             0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
 969                             0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68 },
 970                 .rlen   = 24,
 971         }, { /* FIPS Pub 81 */
 972                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 973                 .klen   = 8,
 974                 .iv     = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef },
 975                 .input  = { 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74 },
 976                 .ilen   = 8,
 977                 .result = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
 978                 .rlen   = 8,
 979         }, {
 980                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 981                 .klen   = 8,
 982                 .iv     = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
 983                 .input  = { 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
 984                 .ilen   = 8,
 985                 .result = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
 986                 .rlen   = 8,
 987         }, {
 988                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 989                 .klen   = 8,
 990                 .iv     = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
 991                 .input  = { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
 992                 .ilen   = 8,
 993                 .result = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
 994                 .rlen   = 8,
 995         }, { /* Copy of openssl vector for chunk testing */
 996              /* From OpenSSL */
 997                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
 998                 .klen   = 8,
 999                 .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
1000                 .input  = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1001                             0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1002                             0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
1003                 .ilen   = 24,
1004                 .result = { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
1005                             0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
1006                             0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68 },
1007                 .rlen   = 24,
1008                 .np     = 2,
1009                 .tap    = { 13, 11 }
1010         },
1011 };
1012
1013 struct cipher_testvec des_cbc_dec_tv_template[] = {
1014         { /* FIPS Pub 81 */
1015                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1016                 .klen   = 8,
1017                 .iv     = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef },
1018                 .input  = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
1019                 .ilen   = 8,
1020                 .result = { 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74 },
1021                 .rlen   = 8,
1022         }, {
1023                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1024                 .klen   = 8,
1025                 .iv     = { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
1026                 .input  = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
1027                 .ilen   = 8,
1028                 .result = { 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
1029                 .rlen   = 8,
1030         }, {
1031                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1032                 .klen   = 8,
1033                 .iv     = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
1034                 .input  = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
1035                 .ilen   = 8,
1036                 .result = { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
1037                 .rlen   = 8,
1038         }, { /* Copy of above, for chunk testing */
1039                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1040                 .klen   = 8,
1041                 .iv     = { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
1042                 .input  = { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
1043                 .ilen   = 8,
1044                 .result = { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
1045                 .rlen   = 8,
1046                 .np     = 2,
1047                 .tap    = { 4, 4 }
1048         },
1049 };
1050
1051 /*
1052  * We really need some more test vectors, especially for DES3 CBC.
1053  */
1054 struct cipher_testvec des3_ede_enc_tv_template[] = {
1055         { /* These are from openssl */
1056                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1057                             0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
1058                             0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
1059                 .klen   = 24,
1060                 .input  = { 0x73, 0x6f, 0x6d, 0x65, 0x64, 0x61, 0x74, 0x61 },
1061                 .ilen   = 8,
1062                 .result = { 0x18, 0xd7, 0x48, 0xe5, 0x63, 0x62, 0x05, 0x72 },
1063                 .rlen   = 8,
1064         }, {
1065                 .key    = { 0x03, 0x52, 0x02, 0x07, 0x67, 0x20, 0x82, 0x17,
1066                             0x86, 0x02, 0x87, 0x66, 0x59, 0x08, 0x21, 0x98,
1067                             0x64, 0x05, 0x6a, 0xbd, 0xfe, 0xa9, 0x34, 0x57 },
1068                 .klen   = 24,
1069                 .input  = { 0x73, 0x71, 0x75, 0x69, 0x67, 0x67, 0x6c, 0x65 },
1070                 .ilen   = 8,
1071                 .result = { 0xc0, 0x7d, 0x2a, 0x0f, 0xa5, 0x66, 0xfa, 0x30 },
1072                 .rlen   = 8,
1073         }, {
1074                 .key    = { 0x10, 0x46, 0x10, 0x34, 0x89, 0x98, 0x80, 0x20,
1075                             0x91, 0x07, 0xd0, 0x15, 0x89, 0x19, 0x01, 0x01,
1076                             0x19, 0x07, 0x92, 0x10, 0x98, 0x1a, 0x01, 0x01 },
1077                 .klen   = 24,
1078                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1079                 .ilen   = 8,
1080                 .result = { 0xe1, 0xef, 0x62, 0xc3, 0x32, 0xfe, 0x82, 0x5b },
1081                 .rlen   = 8,
1082         },
1083 };
1084
1085 struct cipher_testvec des3_ede_dec_tv_template[] = {
1086         { /* These are from openssl */
1087                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1088                             0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
1089                             0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
1090                 .klen   = 24,
1091                 .input  = { 0x18, 0xd7, 0x48, 0xe5, 0x63, 0x62, 0x05, 0x72 },
1092                 .ilen   = 8,
1093                 .result = { 0x73, 0x6f, 0x6d, 0x65, 0x64, 0x61, 0x74, 0x61 },
1094                 .rlen   = 8,
1095         }, {
1096                 .key    = { 0x03, 0x52, 0x02, 0x07, 0x67, 0x20, 0x82, 0x17,
1097                             0x86, 0x02, 0x87, 0x66, 0x59, 0x08, 0x21, 0x98,
1098                             0x64, 0x05, 0x6a, 0xbd, 0xfe, 0xa9, 0x34, 0x57 },
1099                 .klen   = 24,
1100                 .input  = { 0xc0, 0x7d, 0x2a, 0x0f, 0xa5, 0x66, 0xfa, 0x30 },
1101                 .ilen   = 8,
1102                 .result = { 0x73, 0x71, 0x75, 0x69, 0x67, 0x67, 0x6c, 0x65 },
1103                 .rlen   = 8,
1104         }, {
1105                 .key    = { 0x10, 0x46, 0x10, 0x34, 0x89, 0x98, 0x80, 0x20,
1106                             0x91, 0x07, 0xd0, 0x15, 0x89, 0x19, 0x01, 0x01,
1107                             0x19, 0x07, 0x92, 0x10, 0x98, 0x1a, 0x01, 0x01 },
1108                 .klen   = 24,
1109                 .input  = { 0xe1, 0xef, 0x62, 0xc3, 0x32, 0xfe, 0x82, 0x5b },
1110                 .ilen   = 8,
1111                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1112                 .rlen   = 8,
1113         },
1114 };
1115
1116 /*
1117  * Blowfish test vectors.
1118  */
1119 #define BF_ENC_TEST_VECTORS     6
1120 #define BF_DEC_TEST_VECTORS     6
1121 #define BF_CBC_ENC_TEST_VECTORS 1
1122 #define BF_CBC_DEC_TEST_VECTORS 1
1123
1124 struct cipher_testvec bf_enc_tv_template[] = {
1125         { /* DES test vectors from OpenSSL */
1126                 .key    = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
1127                 .klen   = 8,
1128                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1129                 .ilen   = 8,
1130                 .result = { 0x4e, 0xf9, 0x97, 0x45, 0x61, 0x98, 0xdd, 0x78 },
1131                 .rlen   = 8,
1132         }, {
1133                 .key    = { 0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e },
1134                 .klen   = 8,
1135                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1136                 .ilen   = 8,
1137                 .result = { 0xa7, 0x90, 0x79, 0x51, 0x08, 0xea, 0x3c, 0xae },
1138                 .rlen   = 8,
1139         }, {
1140                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 },
1141                 .klen   = 8,
1142                 .input  = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1143                 .ilen   = 8,
1144                 .result = { 0xe8, 0x7a, 0x24, 0x4e, 0x2c, 0xc8, 0x5e, 0x82 },
1145                 .rlen   = 8,
1146         }, { /* Vary the keylength... */
1147                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1148                             0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f },
1149                 .klen   = 16,
1150                 .input  = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1151                 .ilen   = 8,
1152                 .result = { 0x93, 0x14, 0x28, 0x87, 0xee, 0x3b, 0xe1, 0x5c },
1153                 .rlen   = 8,
1154         }, {
1155                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1156                             0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
1157                             0x00, 0x11, 0x22, 0x33, 0x44 },
1158                 .klen   = 21,
1159                 .input  = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1160                 .ilen   = 8,
1161                 .result = { 0xe6, 0xf5, 0x1e, 0xd7, 0x9b, 0x9d, 0xb2, 0x1f },
1162                 .rlen   = 8,
1163         }, { /* Generated with bf488 */
1164                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1165                             0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
1166                             0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1167                             0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f,
1168                             0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76,
1169                             0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e,
1170                             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },
1171                 .klen   = 56,
1172                 .input  = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1173                 .ilen   = 8,
1174                 .result = { 0xc0, 0x45, 0x04, 0x01, 0x2e, 0x4e, 0x1f, 0x53 },
1175                 .rlen   = 8,
1176         },
1177 };
1178
1179 struct cipher_testvec bf_dec_tv_template[] = {
1180         { /* DES test vectors from OpenSSL */
1181                 .key    = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1182                 .klen   = 8,
1183                 .input  = { 0x4e, 0xf9, 0x97, 0x45, 0x61, 0x98, 0xdd, 0x78 },
1184                 .ilen   = 8,
1185                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1186                 .rlen   = 8,
1187         }, {
1188                 .key    = { 0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e },
1189                 .klen   = 8,
1190                 .input  = { 0xa7, 0x90, 0x79, 0x51, 0x08, 0xea, 0x3c, 0xae },
1191                 .ilen   = 8,
1192                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1193                 .rlen   = 8,
1194         }, {
1195                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 },
1196                 .klen   = 8,
1197                 .input  = { 0xe8, 0x7a, 0x24, 0x4e, 0x2c, 0xc8, 0x5e, 0x82 },
1198                 .ilen   = 8,
1199                 .result = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1200                 .rlen   = 8,
1201         }, { /* Vary the keylength... */
1202                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1203                             0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f },
1204                 .klen   = 16,
1205                 .input  = { 0x93, 0x14, 0x28, 0x87, 0xee, 0x3b, 0xe1, 0x5c },
1206                 .ilen   = 8,
1207                 .result = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1208                 .rlen   = 8,
1209         }, {
1210                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1211                             0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
1212                             0x00, 0x11, 0x22, 0x33, 0x44 },
1213                 .klen   = 21,
1214                 .input  = { 0xe6, 0xf5, 0x1e, 0xd7, 0x9b, 0x9d, 0xb2, 0x1f },
1215                 .ilen   = 8,
1216                 .result = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1217                 .rlen   = 8,
1218         }, { /* Generated with bf488, using OpenSSL, Libgcrypt and Nettle */
1219                 .key    = { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
1220                             0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
1221                             0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1222                             0x04, 0x68, 0x91, 0x04, 0xc2, 0xfd, 0x3b, 0x2f,
1223                             0x58, 0x40, 0x23, 0x64, 0x1a, 0xba, 0x61, 0x76,
1224                             0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e,
1225                             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },
1226                 .klen   = 56,
1227                 .input  = { 0xc0, 0x45, 0x04, 0x01, 0x2e, 0x4e, 0x1f, 0x53 },
1228                 .ilen   = 8,
1229                 .result = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1230                 .rlen   = 8,
1231         },
1232 };
1233
1234 struct cipher_testvec bf_cbc_enc_tv_template[] = {
1235         { /* From OpenSSL */
1236                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1237                             0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 },
1238                 .klen   = 16,
1239                 .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1240                 .input  = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1241                             0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1242                             0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
1243                             0x66, 0x6f, 0x72, 0x20, 0x00, 0x00, 0x00, 0x00 },
1244                 .ilen   = 32,
1245                 .result = { 0x6b, 0x77, 0xb4, 0xd6, 0x30, 0x06, 0xde, 0xe6,
1246                             0x05, 0xb1, 0x56, 0xe2, 0x74, 0x03, 0x97, 0x93,
1247                             0x58, 0xde, 0xb9, 0xe7, 0x15, 0x46, 0x16, 0xd9,
1248                             0x59, 0xf1, 0x65, 0x2b, 0xd5, 0xff, 0x92, 0xcc },
1249                 .rlen   = 32,
1250         },
1251 };
1252
1253 struct cipher_testvec bf_cbc_dec_tv_template[] = {
1254         { /* From OpenSSL */
1255                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1256                             0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 },
1257                 .klen   = 16,
1258                 .iv     = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 },
1259                 .input  = { 0x6b, 0x77, 0xb4, 0xd6, 0x30, 0x06, 0xde, 0xe6,
1260                             0x05, 0xb1, 0x56, 0xe2, 0x74, 0x03, 0x97, 0x93,
1261                             0x58, 0xde, 0xb9, 0xe7, 0x15, 0x46, 0x16, 0xd9,
1262                             0x59, 0xf1, 0x65, 0x2b, 0xd5, 0xff, 0x92, 0xcc },
1263                 .ilen   = 32,
1264                 .result = { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
1265                             0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
1266                             0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
1267                             0x66, 0x6f, 0x72, 0x20, 0x00, 0x00, 0x00, 0x00 },
1268                 .rlen   = 32,
1269         },
1270 };
1271
1272 /*
1273  * Twofish test vectors.
1274  */
1275 #define TF_ENC_TEST_VECTORS             3
1276 #define TF_DEC_TEST_VECTORS             3
1277 #define TF_CBC_ENC_TEST_VECTORS         4
1278 #define TF_CBC_DEC_TEST_VECTORS         4
1279
1280 struct cipher_testvec tf_enc_tv_template[] = {
1281         {
1282                 .key    = { [0 ... 15] = 0x00 },
1283                 .klen   = 16,
1284                 .input  = { [0 ... 15] = 0x00 },
1285                 .ilen   = 16,
1286                 .result = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1287                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1288                 .rlen   = 16,
1289         }, {
1290                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1291                             0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
1292                             0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 },
1293                 .klen   = 24,
1294                 .input  = { [0 ... 15] = 0x00 },
1295                 .ilen   = 16,
1296                 .result = { 0xcf, 0xd1, 0xd2, 0xe5, 0xa9, 0xbe, 0x9c, 0xdf,
1297                             0x50, 0x1f, 0x13, 0xb8, 0x92, 0xbd, 0x22, 0x48 },
1298                 .rlen   = 16,
1299         }, {
1300                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1301                             0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
1302                             0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1303                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1304                 .klen   = 32,
1305                 .input  = { [0 ... 15] = 0x00 },
1306                 .ilen   = 16,
1307                 .result = { 0x37, 0x52, 0x7b, 0xe0, 0x05, 0x23, 0x34, 0xb8,
1308                             0x9f, 0x0c, 0xfc, 0xca, 0xe8, 0x7c, 0xfa, 0x20 },
1309                 .rlen   = 16,
1310         },
1311 };
1312
1313 struct cipher_testvec tf_dec_tv_template[] = {
1314         {
1315                 .key    = { [0 ... 15] = 0x00 },
1316                 .klen   = 16,
1317                 .input  = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1318                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1319                 .ilen   = 16,
1320                 .result = { [0 ... 15] = 0x00 },
1321                 .rlen   = 16,
1322         }, {
1323                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1324                             0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
1325                             0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 },
1326                 .klen   = 24,
1327                 .input  = { 0xcf, 0xd1, 0xd2, 0xe5, 0xa9, 0xbe, 0x9c, 0xdf,
1328                             0x50, 0x1f, 0x13, 0xb8, 0x92, 0xbd, 0x22, 0x48 },
1329                 .ilen   = 16,
1330                 .result = { [0 ... 15] = 0x00 },
1331                 .rlen   = 16,
1332         }, {
1333                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
1334                             0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
1335                             0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1336                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1337                 .klen   = 32,
1338                 .input  = { 0x37, 0x52, 0x7b, 0xe0, 0x05, 0x23, 0x34, 0xb8,
1339                             0x9f, 0x0c, 0xfc, 0xca, 0xe8, 0x7c, 0xfa, 0x20 },
1340                 .ilen   = 16,
1341                 .result = { [0 ... 15] = 0x00 },
1342                 .rlen   = 16,
1343         },
1344 };
1345
1346 struct cipher_testvec tf_cbc_enc_tv_template[] = {
1347         { /* Generated with Nettle */
1348                 .key    = { [0 ... 15] = 0x00 },
1349                 .klen   = 16,
1350                 .iv     = { [0 ... 15] = 0x00 },
1351                 .input  = { [0 ... 15] = 0x00 },
1352                 .ilen   = 16,
1353                 .result = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1354                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1355                 .rlen   = 16,
1356         }, {
1357                 .key    = { [0 ... 15] = 0x00 },
1358                 .klen   = 16,
1359                 .iv     = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1360                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1361                 .input  = { [0 ... 15] = 0x00 },
1362                 .ilen   = 16,
1363                 .result = { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
1364                             0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19 },
1365                 .rlen   = 16,
1366         }, {
1367                 .key    = { [0 ... 15] = 0x00 },
1368                 .klen   = 16,
1369                 .iv     = { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
1370                             0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19 },
1371                 .input  = { [0 ... 15] = 0x00 },
1372                 .ilen   = 16,
1373                 .result = { 0x05, 0xef, 0x8c, 0x61, 0xa8, 0x11, 0x58, 0x26,
1374                             0x34, 0xba, 0x5c, 0xb7, 0x10, 0x6a, 0xa6, 0x41 },
1375                 .rlen   = 16,
1376         }, {
1377                 .key    = { [0 ... 15] = 0x00 },
1378                 .klen   = 16,
1379                 .iv     = { [0 ... 15] = 0x00 },
1380                 .input  = { [0 ... 47] = 0x00 },
1381                 .ilen   = 48,
1382                 .result = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1383                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a,
1384                             0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
1385                             0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19,
1386                             0x05, 0xef, 0x8c, 0x61, 0xa8, 0x11, 0x58, 0x26,
1387                             0x34, 0xba, 0x5c, 0xb7, 0x10, 0x6a, 0xa6, 0x41 },
1388                 .rlen   = 48,
1389         },
1390 };
1391
1392 struct cipher_testvec tf_cbc_dec_tv_template[] = {
1393         { /* Reverse of the first four above */
1394                 .key    = { [0 ... 15] = 0x00 },
1395                 .klen   = 16,
1396                 .iv     = { [0 ... 15] = 0x00 },
1397                 .input  = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1398                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1399                 .ilen   = 16,
1400                 .result = { [0 ... 15] = 0x00 },
1401                 .rlen   = 16,
1402         }, {
1403                 .key    = { [0 ... 15] = 0x00 },
1404                 .klen   = 16,
1405                 .iv     = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1406                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
1407                 .input  = { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
1408                             0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19 },
1409                 .ilen   = 16,
1410                 .result = { [0 ... 15] = 0x00 },
1411                 .rlen   = 16,
1412         }, {
1413                 .key    = { [0 ... 15] = 0x00 },
1414                 .klen   = 16,
1415                 .iv     = { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
1416                             0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19 },
1417                 .input  = { 0x05, 0xef, 0x8c, 0x61, 0xa8, 0x11, 0x58, 0x26,
1418                             0x34, 0xba, 0x5c, 0xb7, 0x10, 0x6a, 0xa6, 0x41 },
1419                 .ilen   = 16,
1420                 .result = { [0 ... 15] = 0x00 },
1421                 .rlen   = 16,
1422         }, {
1423                 .key    = { [0 ... 15] = 0x00 },
1424                 .klen   = 16,
1425                 .iv     = { [0 ... 15] = 0x00 },
1426                 .input  = { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
1427                             0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a,
1428                             0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
1429                             0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19,
1430                             0x05, 0xef, 0x8c, 0x61, 0xa8, 0x11, 0x58, 0x26,
1431                             0x34, 0xba, 0x5c, 0xb7, 0x10, 0x6a, 0xa6, 0x41 },
1432                 .ilen   = 48,
1433                 .result = { [0 ... 47] = 0x00 },
1434                 .rlen   = 48,
1435         },
1436 };
1437
1438 /*
1439  * Serpent test vectors.  These are backwards because Serpent writes
1440  * octet sequences in right-to-left mode.
1441  */
1442 #define SERPENT_ENC_TEST_VECTORS        4
1443 #define SERPENT_DEC_TEST_VECTORS        4
1444
1445 #define TNEPRES_ENC_TEST_VECTORS        4
1446 #define TNEPRES_DEC_TEST_VECTORS        4
1447
1448 struct cipher_testvec serpent_enc_tv_template[] =
1449 {
1450         {
1451                 .input  = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1452                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1453                 .ilen   = 16,
1454                 .result = { 0x12, 0x07, 0xfc, 0xce, 0x9b, 0xd0, 0xd6, 0x47,
1455                             0x6a, 0xe9, 0x8f, 0xbe, 0xd1, 0x43, 0xa0, 0xe2 },
1456                 .rlen   = 16,
1457         }, {
1458                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1459                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1460                 .klen   = 16,
1461                 .input  = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1462                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1463                 .ilen   = 16,
1464                 .result = { 0x4c, 0x7d, 0x8a, 0x32, 0x80, 0x72, 0xa2, 0x2c,
1465                             0x82, 0x3e, 0x4a, 0x1f, 0x3a, 0xcd, 0xa1, 0x6d },
1466                 .rlen   = 16,
1467         }, {
1468                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1469                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1470                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1471                             0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
1472                 .klen   = 32,
1473                 .input  = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1474                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1475                 .ilen   = 16,
1476                 .result = { 0xde, 0x26, 0x9f, 0xf8, 0x33, 0xe4, 0x32, 0xb8,
1477                             0x5b, 0x2e, 0x88, 0xd2, 0x70, 0x1c, 0xe7, 0x5c },
1478                 .rlen   = 16,
1479         }, {
1480                 .key    = { [15] = 0x80 },
1481                 .klen   = 16,
1482                 .input  = { [0 ... 15] = 0x00 },
1483                 .ilen   = 16,
1484                 .result = { 0xdd, 0xd2, 0x6b, 0x98, 0xa5, 0xff, 0xd8, 0x2c,
1485                             0x05, 0x34, 0x5a, 0x9d, 0xad, 0xbf, 0xaf, 0x49},
1486                 .rlen   = 16,
1487         },
1488 };
1489
1490 struct cipher_testvec tnepres_enc_tv_template[] =
1491 {
1492         { /* KeySize=128, PT=0, I=1 */
1493                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1494                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1495                 .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1496                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1497                 .klen   = 16,
1498                 .ilen   = 16,
1499                 .result = { 0x49, 0xaf, 0xbf, 0xad, 0x9d, 0x5a, 0x34, 0x05,
1500                             0x2c, 0xd8, 0xff, 0xa5, 0x98, 0x6b, 0xd2, 0xdd },
1501                 .rlen   = 16,
1502         }, { /* KeySize=192, PT=0, I=1 */
1503                 .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1504                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1505                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1506                 .klen   = 24,
1507                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1508                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1509                 .ilen   = 16,
1510                 .result = { 0xe7, 0x8e, 0x54, 0x02, 0xc7, 0x19, 0x55, 0x68,
1511                             0xac, 0x36, 0x78, 0xf7, 0xa3, 0xf6, 0x0c, 0x66 },
1512                 .rlen   = 16,
1513         }, { /* KeySize=256, PT=0, I=1 */
1514                 .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1515                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1516                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1517                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1518                 .klen   = 32,
1519                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1520                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1521                 .ilen   = 16,
1522                 .result = { 0xab, 0xed, 0x96, 0xe7, 0x66, 0xbf, 0x28, 0xcb,
1523                             0xc0, 0xeb, 0xd2, 0x1a, 0x82, 0xef, 0x08, 0x19 },
1524                 .rlen   = 16,
1525         }, { /* KeySize=256, I=257 */
1526                 .key    = { 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18,
1527                             0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
1528                             0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
1529                             0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 },
1530                 .klen   = 32,
1531                 .input  = { 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
1532                             0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 },
1533                 .ilen   = 16,
1534                 .result = { 0x5c, 0xe7, 0x1c, 0x70, 0xd2, 0x88, 0x2e, 0x5b,
1535                             0xb8, 0x32, 0xe4, 0x33, 0xf8, 0x9f, 0x26, 0xde },
1536                 .rlen   = 16,
1537         },
1538 };
1539
1540
1541 struct cipher_testvec serpent_dec_tv_template[] =
1542 {
1543         {
1544                 .input  = { 0x12, 0x07, 0xfc, 0xce, 0x9b, 0xd0, 0xd6, 0x47,
1545                             0x6a, 0xe9, 0x8f, 0xbe, 0xd1, 0x43, 0xa0, 0xe2 },
1546                 .ilen   = 16,
1547                 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1548                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1549                 .rlen   = 16,
1550         }, {
1551                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1552                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1553                 .klen   = 16,
1554                 .input  = { 0x4c, 0x7d, 0x8a, 0x32, 0x80, 0x72, 0xa2, 0x2c,
1555                             0x82, 0x3e, 0x4a, 0x1f, 0x3a, 0xcd, 0xa1, 0x6d },
1556                 .ilen   = 16,
1557                 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1558                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1559                 .rlen   = 16,
1560         }, {
1561                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1562                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1563                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1564                             0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
1565                 .klen   = 32,
1566                 .input  = { 0xde, 0x26, 0x9f, 0xf8, 0x33, 0xe4, 0x32, 0xb8,
1567                             0x5b, 0x2e, 0x88, 0xd2, 0x70, 0x1c, 0xe7, 0x5c },
1568                 .ilen   = 16,
1569                 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1570                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1571                 .rlen   = 16,
1572         }, {
1573                 .key    = { [15] = 0x80 },
1574                 .klen   = 16,
1575                 .input  = { 0xdd, 0xd2, 0x6b, 0x98, 0xa5, 0xff, 0xd8, 0x2c,
1576                             0x05, 0x34, 0x5a, 0x9d, 0xad, 0xbf, 0xaf, 0x49},
1577                 .ilen   = 16,
1578                 .result = { [0 ... 15] = 0x00 },
1579                 .rlen   = 16,
1580         },
1581 };
1582
1583 struct cipher_testvec tnepres_dec_tv_template[] =
1584 {
1585         {
1586                 .input  = { 0x41, 0xcc, 0x6b, 0x31, 0x59, 0x31, 0x45, 0x97,
1587                             0x6d, 0x6f, 0xbb, 0x38, 0x4b, 0x37, 0x21, 0x28 },
1588                 .ilen   = 16,
1589                 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1590                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1591                 .rlen   = 16,
1592         }, {
1593                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1594                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1595                 .klen   = 16,
1596                 .input  = { 0xea, 0xf4, 0xd7, 0xfc, 0xd8, 0x01, 0x34, 0x47,
1597                             0x81, 0x45, 0x0b, 0xfa, 0x0c, 0xd6, 0xad, 0x6e },
1598                 .ilen   = 16,
1599                 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1600                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1601                 .rlen   = 16,
1602         }, {
1603                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1604                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1605                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1606                             0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
1607                 .klen   = 32,
1608                 .input  = { 0x64, 0xa9, 0x1a, 0x37, 0xed, 0x9f, 0xe7, 0x49,
1609                             0xa8, 0x4e, 0x76, 0xd6, 0xf5, 0x0d, 0x78, 0xee },
1610                 .ilen   = 16,
1611                 .result = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1612                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1613                 .rlen   = 16,
1614         }, { /* KeySize=128, I=121 */
1615                 .key    = { [15] = 0x80 },
1616                 .klen   = 16,
1617                 .input  = { 0x3d, 0xda, 0xbf, 0xc0, 0x06, 0xda, 0xab, 0x06,
1618                             0x46, 0x2a, 0xf4, 0xef, 0x81, 0x54, 0x4e, 0x26 },
1619                 .ilen   = 16,
1620                 .result = { [0 ... 15] = 0x00 },
1621                 .rlen   = 16,
1622         },
1623 };
1624
1625
1626 /* Cast6 test vectors from RFC 2612 */
1627 #define CAST6_ENC_TEST_VECTORS  3
1628 #define CAST6_DEC_TEST_VECTORS  3
1629
1630 struct cipher_testvec cast6_enc_tv_template[] =
1631 {
1632         {
1633                 .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1634                             0x0a, 0xf7, 0x56, 0x47, 0xf2, 0x9f, 0x61, 0x5d },
1635                 .klen   = 16,
1636                 .input  = { [0 ... 15] = 0x00 },
1637                 .ilen   = 16,
1638                 .result = { 0xc8, 0x42, 0xa0, 0x89, 0x72, 0xb4, 0x3d, 0x20,
1639                             0x83, 0x6c, 0x91, 0xd1, 0xb7, 0x53, 0x0f, 0x6b },
1640                 .rlen   = 16,
1641         }, {
1642                 .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1643                             0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
1644                             0xba, 0xc7, 0x7a, 0x77, 0x17, 0x94, 0x28, 0x63 },
1645                 .klen   = 24,
1646                 .input  = { [0 ... 15] = 0x00 },
1647                 .ilen   = 16,
1648                 .result = { 0x1b, 0x38, 0x6c, 0x02, 0x10, 0xdc, 0xad, 0xcb,
1649                             0xdd, 0x0e, 0x41, 0xaa, 0x08, 0xa7, 0xa7, 0xe8 },
1650                 .rlen   = 16,
1651         }, {
1652                 .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1653                             0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
1654                             0x8d, 0x7c, 0x47, 0xce, 0x26, 0x49, 0x08, 0x46,
1655                             0x1c, 0xc1, 0xb5, 0x13, 0x7a, 0xe6, 0xb6, 0x04 },
1656                 .klen   = 32,
1657                 .input  = { [0 ... 15] = 0x00 },
1658                 .ilen   = 16,
1659                 .result = { 0x4f, 0x6a, 0x20, 0x38, 0x28, 0x68, 0x97, 0xb9,
1660                             0xc9, 0x87, 0x01, 0x36, 0x55, 0x33, 0x17, 0xfa },
1661                 .rlen   = 16,
1662         },
1663 };
1664
1665 struct cipher_testvec cast6_dec_tv_template[] =
1666 {
1667         {
1668                 .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1669                             0x0a, 0xf7, 0x56, 0x47, 0xf2, 0x9f, 0x61, 0x5d },
1670                 .klen   = 16,
1671                 .input  = { 0xc8, 0x42, 0xa0, 0x89, 0x72, 0xb4, 0x3d, 0x20,
1672                             0x83, 0x6c, 0x91, 0xd1, 0xb7, 0x53, 0x0f, 0x6b },
1673                 .ilen   = 16,
1674                 .result = { [0 ... 15] = 0x00 },
1675                 .rlen   = 16,
1676         }, {
1677                 .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1678                             0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
1679                             0xba, 0xc7, 0x7a, 0x77, 0x17, 0x94, 0x28, 0x63 },
1680                 .klen   = 24,
1681                 .input  = { 0x1b, 0x38, 0x6c, 0x02, 0x10, 0xdc, 0xad, 0xcb,
1682                             0xdd, 0x0e, 0x41, 0xaa, 0x08, 0xa7, 0xa7, 0xe8 },
1683                 .ilen   = 16,
1684                 .result = { [0 ... 15] = 0x00 },
1685                 .rlen   = 16,
1686         }, {
1687                 .key    = { 0x23, 0x42, 0xbb, 0x9e, 0xfa, 0x38, 0x54, 0x2c,
1688                             0xbe, 0xd0, 0xac, 0x83, 0x94, 0x0a, 0xc2, 0x98,
1689                             0x8d, 0x7c, 0x47, 0xce, 0x26, 0x49, 0x08, 0x46,
1690                             0x1c, 0xc1, 0xb5, 0x13, 0x7a, 0xe6, 0xb6, 0x04 },
1691                 .klen   = 32,
1692                 .input  = { 0x4f, 0x6a, 0x20, 0x38, 0x28, 0x68, 0x97, 0xb9,
1693                             0xc9, 0x87, 0x01, 0x36, 0x55, 0x33, 0x17, 0xfa },
1694                 .ilen   = 16,
1695                 .result = { [0 ... 15] = 0x00 },
1696                 .rlen   = 16,
1697         },
1698 };
1699
1700
1701 /*
1702  * AES test vectors.
1703  */
1704 #define AES_ENC_TEST_VECTORS 3
1705 #define AES_DEC_TEST_VECTORS 3
1706
1707 struct cipher_testvec aes_enc_tv_template[] = {
1708         { /* From FIPS-197 */
1709                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1710                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1711                 .klen   = 16,
1712                 .input  = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1713                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1714                 .ilen   = 16,
1715                 .result = { 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30,
1716                             0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a },
1717                 .rlen   = 16,
1718         }, {
1719                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1720                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1721                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 },
1722                 .klen   = 24,
1723                 .input  = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1724                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1725                 .ilen   = 16,
1726                 .result = { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0,
1727                             0x6e, 0xaf, 0x70, 0xa0, 0xec, 0x0d, 0x71, 0x91 },
1728                 .rlen   = 16,
1729         }, {
1730                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1731                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1732                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1733                             0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
1734                 .klen   = 32,
1735                 .input  = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1736                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1737                 .ilen   = 16,
1738                 .result = { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf,
1739                             0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89 },
1740                 .rlen   = 16,
1741         },
1742 };
1743
1744 struct cipher_testvec aes_dec_tv_template[] = {
1745         { /* From FIPS-197 */
1746                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1747                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1748                 .klen   = 16,
1749                 .input  = { 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30,
1750                             0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a },
1751                 .ilen   = 16,
1752                 .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1753                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1754                 .rlen   = 16,
1755         }, {
1756                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1757                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1758                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 },
1759                 .klen   = 24,
1760                 .input  = { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0,
1761                             0x6e, 0xaf, 0x70, 0xa0, 0xec, 0x0d, 0x71, 0x91 },
1762                 .ilen   = 16,
1763                 .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1764                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1765                 .rlen   = 16,
1766         }, {
1767                 .key    = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1768                             0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1769                             0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1770                             0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
1771                 .klen   = 32,
1772                 .input  = { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf,
1773                             0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89 },
1774                 .ilen   = 16,
1775                 .result = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
1776                             0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
1777                 .rlen   = 16,
1778         },
1779 };
1780
1781 /* Cast5 test vectors from RFC 2144 */
1782 #define CAST5_ENC_TEST_VECTORS  3
1783 #define CAST5_DEC_TEST_VECTORS  3
1784
1785 struct cipher_testvec cast5_enc_tv_template[] =
1786 {
1787         {
1788                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78,
1789                             0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a },
1790                 .klen   = 16,
1791                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1792                 .ilen   = 8,
1793                 .result = { 0x23, 0x8b, 0x4f, 0xe5, 0x84, 0x7e, 0x44, 0xb2 },
1794                 .rlen   = 8,
1795         }, {
1796                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78,
1797                             0x23, 0x45 },
1798                 .klen   = 10,
1799                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1800                 .ilen   = 8,
1801                 .result = { 0xeb, 0x6a, 0x71, 0x1a, 0x2c, 0x02, 0x27, 0x1b },
1802                 .rlen   = 8,
1803         }, {
1804                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x12 },
1805                 .klen   = 5,
1806                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1807                 .ilen   = 8,
1808                 .result = { 0x7a, 0xc8, 0x16, 0xd1, 0x6e, 0x9b, 0x30, 0x2e },
1809                 .rlen   = 8,
1810         },
1811 };
1812
1813 struct cipher_testvec cast5_dec_tv_template[] =
1814 {
1815         {
1816                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78,
1817                             0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a },
1818                 .klen   = 16,
1819                 .input  = { 0x23, 0x8b, 0x4f, 0xe5, 0x84, 0x7e, 0x44, 0xb2 },
1820                 .ilen   = 8,
1821                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1822                 .rlen   = 8,
1823         }, {
1824                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78,
1825                             0x23, 0x45 },
1826                 .klen   = 10,
1827                 .input  = { 0xeb, 0x6a, 0x71, 0x1a, 0x2c, 0x02, 0x27, 0x1b },
1828                 .ilen   = 8,
1829                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1830                 .rlen   = 8,
1831         }, {
1832                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x12 },
1833                 .klen   = 5,
1834                 .input  = { 0x7a, 0xc8, 0x16, 0xd1, 0x6e, 0x9b, 0x30, 0x2e },
1835                 .ilen   = 8,
1836                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1837                 .rlen   = 8,
1838         },
1839 };
1840
1841 /*
1842  * ARC4 test vectors from OpenSSL
1843  */
1844 #define ARC4_ENC_TEST_VECTORS   7
1845 #define ARC4_DEC_TEST_VECTORS   7
1846
1847 struct cipher_testvec arc4_enc_tv_template[] =
1848 {
1849         {
1850                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1851                 .klen   = 8,
1852                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1853                 .ilen   = 8,
1854                 .result = { 0x75, 0xb7, 0x87, 0x80, 0x99, 0xe0, 0xc5, 0x96 },
1855                 .rlen   = 8,
1856         }, {
1857                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1858                 .klen   = 8,
1859                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1860                 .ilen   = 8,
1861                 .result = { 0x74, 0x94, 0xc2, 0xe7, 0x10, 0x4b, 0x08, 0x79 },
1862                 .rlen   = 8,
1863         }, {
1864                 .key    = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1865                 .klen   = 8,
1866                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1867                 .ilen   = 8,
1868                 .result = { 0xde, 0x18, 0x89, 0x41, 0xa3, 0x37, 0x5d, 0x3a },
1869                 .rlen   = 8,
1870         }, {
1871                 .key    = { 0xef, 0x01, 0x23, 0x45},
1872                 .klen   = 4,
1873                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1874                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1875                             0x00, 0x00, 0x00, 0x00 },
1876                 .ilen   = 20,
1877                 .result = { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
1878                             0xbd, 0x61, 0x5a, 0x11, 0x62, 0xe1, 0xc7, 0xba,
1879                             0x36, 0xb6, 0x78, 0x58 },
1880                 .rlen   = 20,
1881         }, {
1882                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1883                 .klen   = 8,
1884                 .input  = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
1885                             0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
1886                             0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
1887                             0x12, 0x34, 0x56, 0x78 },
1888                 .ilen   = 28,
1889                 .result = { 0x66, 0xa0, 0x94, 0x9f, 0x8a, 0xf7, 0xd6, 0x89,
1890                             0x1f, 0x7f, 0x83, 0x2b, 0xa8, 0x33, 0xc0, 0x0c,
1891                             0x89, 0x2e, 0xbe, 0x30, 0x14, 0x3c, 0xe2, 0x87,
1892                             0x40, 0x01, 0x1e, 0xcf },
1893                 .rlen   = 28,
1894         }, {
1895                 .key    = { 0xef, 0x01, 0x23, 0x45 },
1896                 .klen   = 4,
1897                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1898                             0x00, 0x00 },
1899                 .ilen   = 10,
1900                 .result = { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
1901                             0xbd, 0x61 },
1902                 .rlen   = 10,
1903         }, {
1904                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
1905                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1906                 .klen   = 16,
1907                 .input  = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
1908                 .ilen   = 8,
1909                 .result = { 0x69, 0x72, 0x36, 0x59, 0x1B, 0x52, 0x42, 0xB1 },
1910                 .rlen   = 8,
1911         },
1912 };
1913
1914 struct cipher_testvec arc4_dec_tv_template[] =
1915 {
1916         {
1917                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1918                 .klen   = 8,
1919                 .input  = { 0x75, 0xb7, 0x87, 0x80, 0x99, 0xe0, 0xc5, 0x96 },
1920                 .ilen   = 8,
1921                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1922                 .rlen   = 8,
1923         }, {
1924                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1925                 .klen   = 8,
1926                 .input  = { 0x74, 0x94, 0xc2, 0xe7, 0x10, 0x4b, 0x08, 0x79 },
1927                 .ilen   = 8,
1928                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1929                 .rlen   = 8,
1930         }, {
1931                 .key    = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1932                 .klen   = 8,
1933                 .input  = { 0xde, 0x18, 0x89, 0x41, 0xa3, 0x37, 0x5d, 0x3a },
1934                 .ilen   = 8,
1935                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1936                 .rlen   = 8,
1937         }, {
1938                 .key    = { 0xef, 0x01, 0x23, 0x45},
1939                 .klen   = 4,
1940                 .input  = { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
1941                             0xbd, 0x61, 0x5a, 0x11, 0x62, 0xe1, 0xc7, 0xba,
1942                             0x36, 0xb6, 0x78, 0x58 },
1943                 .ilen   = 20,
1944                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1945                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1946                             0x00, 0x00, 0x00, 0x00 },
1947                 .rlen   = 20,
1948         }, {
1949                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
1950                 .klen   = 8,
1951                 .input  = { 0x66, 0xa0, 0x94, 0x9f, 0x8a, 0xf7, 0xd6, 0x89,
1952                             0x1f, 0x7f, 0x83, 0x2b, 0xa8, 0x33, 0xc0, 0x0c,
1953                             0x89, 0x2e, 0xbe, 0x30, 0x14, 0x3c, 0xe2, 0x87,
1954                             0x40, 0x01, 0x1e, 0xcf },
1955                 .ilen   = 28,
1956                 .result = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
1957                             0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
1958                             0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
1959                             0x12, 0x34, 0x56, 0x78 },
1960                 .rlen   = 28,
1961         }, {
1962                 .key    = { 0xef, 0x01, 0x23, 0x45 },
1963                 .klen   = 4,
1964                 .input  = { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
1965                             0xbd, 0x61 },
1966                 .ilen   = 10,
1967                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1968                             0x00, 0x00 },
1969                 .rlen   = 10,
1970         }, {
1971                 .key    = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
1972                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1973                 .klen   = 16,
1974                 .input  = { 0x69, 0x72, 0x36, 0x59, 0x1B, 0x52, 0x42, 0xB1 },
1975                 .ilen   = 8,
1976                 .result = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
1977                 .rlen   = 8,
1978         },
1979 };
1980
1981 /*
1982  * TEA test vectors
1983  */
1984 #define TEA_ENC_TEST_VECTORS    4
1985 #define TEA_DEC_TEST_VECTORS    4
1986
1987 struct cipher_testvec tea_enc_tv_template[] =
1988 {
1989         {
1990                 .key    = { [0 ... 15] = 0x00 },
1991                 .klen   = 16,
1992                 .input  = { [0 ... 8] = 0x00 },
1993                 .ilen   = 8,
1994                 .result = { 0x0a, 0x3a, 0xea, 0x41, 0x40, 0xa9, 0xba, 0x94 },
1995                 .rlen   = 8,
1996         }, {
1997                 .key    = { 0x2b, 0x02, 0x05, 0x68, 0x06, 0x14, 0x49, 0x76,
1998                             0x77, 0x5d, 0x0e, 0x26, 0x6c, 0x28, 0x78, 0x43 },
1999                 .klen   = 16,
2000                 .input  = { 0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x2e },
2001                 .ilen   = 8,
2002                 .result = { 0x77, 0x5d, 0x2a, 0x6a, 0xf6, 0xce, 0x92, 0x09 },
2003                 .rlen   = 8,
2004         }, {
2005                 .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2006                             0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2007                 .klen   = 16,
2008                 .input  = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2009                             0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2010                 .ilen   = 16,
2011                 .result = { 0xbe, 0x7a, 0xbb, 0x81, 0x95, 0x2d, 0x1f, 0x1e,
2012                             0xdd, 0x89, 0xa1, 0x25, 0x04, 0x21, 0xdf, 0x95 },
2013                 .rlen   = 16,
2014         }, {
2015                 .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2016                             0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2017                 .klen   = 16,
2018                 .input  = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2019                             0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2020                             0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2021                             0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2022                 .ilen   = 32,
2023                 .result = { 0xe0, 0x4d, 0x5d, 0x3c, 0xb7, 0x8c, 0x36, 0x47,
2024                             0x94, 0x18, 0x95, 0x91, 0xa9, 0xfc, 0x49, 0xf8,
2025                             0x44, 0xd1, 0x2d, 0xc2, 0x99, 0xb8, 0x08, 0x2a,
2026                             0x07, 0x89, 0x73, 0xc2, 0x45, 0x92, 0xc6, 0x90 },
2027                 .rlen   = 32,
2028         }
2029 };
2030
2031 struct cipher_testvec tea_dec_tv_template[] =
2032 {
2033         {
2034                 .key    = { [0 ... 15] = 0x00 },
2035                 .klen   = 16,
2036                 .input  = { 0x0a, 0x3a, 0xea, 0x41, 0x40, 0xa9, 0xba, 0x94 },
2037                 .ilen   = 8,
2038                 .result = { [0 ... 8] = 0x00 },
2039                 .rlen   = 8,
2040         }, {
2041                 .key    = { 0x2b, 0x02, 0x05, 0x68, 0x06, 0x14, 0x49, 0x76,
2042                             0x77, 0x5d, 0x0e, 0x26, 0x6c, 0x28, 0x78, 0x43 },
2043                 .klen   = 16,
2044                 .input  = { 0x77, 0x5d, 0x2a, 0x6a, 0xf6, 0xce, 0x92, 0x09 },
2045                 .ilen   = 8,
2046                 .result = { 0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x2e },
2047                 .rlen   = 8,
2048         }, {
2049                 .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2050                             0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2051                 .klen   = 16,
2052                 .input  = { 0xbe, 0x7a, 0xbb, 0x81, 0x95, 0x2d, 0x1f, 0x1e,
2053                             0xdd, 0x89, 0xa1, 0x25, 0x04, 0x21, 0xdf, 0x95 },
2054                 .ilen   = 16,
2055                 .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2056                             0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2057                 .rlen   = 16,
2058         }, {
2059                 .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2060                             0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2061                 .klen   = 16,
2062                 .input  = { 0xe0, 0x4d, 0x5d, 0x3c, 0xb7, 0x8c, 0x36, 0x47,
2063                             0x94, 0x18, 0x95, 0x91, 0xa9, 0xfc, 0x49, 0xf8,
2064                             0x44, 0xd1, 0x2d, 0xc2, 0x99, 0xb8, 0x08, 0x2a,
2065                             0x07, 0x89, 0x73, 0xc2, 0x45, 0x92, 0xc6, 0x90 },
2066                 .ilen   = 32,
2067                 .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2068                             0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2069                             0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2070                             0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2071                 .rlen   = 32,
2072         }
2073 };
2074
2075 /*
2076  * XTEA test vectors
2077  */
2078 #define XTEA_ENC_TEST_VECTORS   4
2079 #define XTEA_DEC_TEST_VECTORS   4
2080
2081 struct cipher_testvec xtea_enc_tv_template[] =
2082 {
2083         {
2084                 .key    = { [0 ... 15] = 0x00 },
2085                 .klen   = 16,
2086                 .input  = { [0 ... 8] = 0x00 },
2087                 .ilen   = 8,
2088                 .result = { 0xd8, 0xd4, 0xe9, 0xde, 0xd9, 0x1e, 0x13, 0xf7 },
2089                 .rlen   = 8,
2090         }, {
2091                 .key    = { 0x2b, 0x02, 0x05, 0x68, 0x06, 0x14, 0x49, 0x76,
2092                             0x77, 0x5d, 0x0e, 0x26, 0x6c, 0x28, 0x78, 0x43 },
2093                 .klen   = 16,
2094                 .input  = { 0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x2e },
2095                 .ilen   = 8,
2096                 .result = { 0x94, 0xeb, 0xc8, 0x96, 0x84, 0x6a, 0x49, 0xa8 },
2097                 .rlen   = 8,
2098         }, {
2099                 .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2100                             0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2101                 .klen   = 16,
2102                 .input  = { 0x3e, 0xce, 0xae, 0x22, 0x60, 0x56, 0xa8, 0x9d,
2103                             0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2104                 .ilen   = 16,
2105                 .result = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea,
2106                             0x61, 0x35, 0xaa, 0xed, 0xb5, 0xcb, 0x71, 0x2c },
2107                 .rlen   = 16,
2108         }, {
2109                 .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2110                             0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2111                 .klen   = 16,
2112                 .input  = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2113                             0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2114                             0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2115                             0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2116                 .ilen   = 32,
2117                 .result = { 0x99, 0x81, 0x9f, 0x5d, 0x6f, 0x4b, 0x31, 0x3a,
2118                             0x86, 0xff, 0x6f, 0xd0, 0xe3, 0x87, 0x70, 0x07,
2119                             0x4d, 0xb8, 0xcf, 0xf3, 0x99, 0x50, 0xb3, 0xd4,
2120                             0x73, 0xa2, 0xfa, 0xc9, 0x16, 0x59, 0x5d, 0x81 },
2121                 .rlen   = 32,
2122         }
2123 };
2124
2125 struct cipher_testvec xtea_dec_tv_template[] =
2126 {
2127         {
2128                 .key    = { [0 ... 15] = 0x00 },
2129                 .klen   = 16,
2130                 .input  = { 0xd8, 0xd4, 0xe9, 0xde, 0xd9, 0x1e, 0x13, 0xf7 },
2131                 .ilen   = 8,
2132                 .result = { [0 ... 8] = 0x00 },
2133                 .rlen   = 8,
2134         }, {
2135                 .key    = { 0x2b, 0x02, 0x05, 0x68, 0x06, 0x14, 0x49, 0x76,
2136                             0x77, 0x5d, 0x0e, 0x26, 0x6c, 0x28, 0x78, 0x43 },
2137                 .klen   = 16,
2138                 .input  = { 0x94, 0xeb, 0xc8, 0x96, 0x84, 0x6a, 0x49, 0xa8 },
2139                 .ilen   = 8,
2140                 .result = { 0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x2e },
2141                 .rlen   = 8,
2142         }, {
2143                 .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2144                             0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2145                 .klen   = 16,
2146                 .input  = { 0x3e, 0xce, 0xae, 0x22, 0x60, 0x56, 0xa8, 0x9d,
2147                             0x77, 0x4d, 0xd4, 0xb4, 0x87, 0x24, 0xe3, 0x9a },
2148                 .ilen   = 16,
2149                 .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2150                             0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2151                 .rlen   = 16,
2152         }, {
2153                 .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2154                             0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2155                 .klen   = 16,
2156                 .input  = { 0x99, 0x81, 0x9f, 0x5d, 0x6f, 0x4b, 0x31, 0x3a,
2157                             0x86, 0xff, 0x6f, 0xd0, 0xe3, 0x87, 0x70, 0x07,
2158                             0x4d, 0xb8, 0xcf, 0xf3, 0x99, 0x50, 0xb3, 0xd4,
2159                             0x73, 0xa2, 0xfa, 0xc9, 0x16, 0x59, 0x5d, 0x81 },
2160                 .ilen   = 32,
2161                 .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2162                             0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2163                             0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2164                             0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2165                 .rlen   = 32,
2166         }
2167 };
2168
2169 /*
2170  * KHAZAD test vectors.
2171  */
2172 #define KHAZAD_ENC_TEST_VECTORS 5
2173 #define KHAZAD_DEC_TEST_VECTORS 5
2174
2175 struct cipher_testvec khazad_enc_tv_template[] = {
2176         {
2177                 .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2178                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2179                 .klen   = 16,
2180                 .input  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2181                 .ilen   = 8,
2182                 .result = { 0x49, 0xa4, 0xce, 0x32, 0xac, 0x19, 0x0e, 0x3f },
2183                 .rlen   = 8,
2184         }, {
2185                 .key    = { 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
2186                             0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38 },
2187                 .klen   = 16,
2188                 .input  = { 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38 },
2189                 .ilen   = 8,
2190                 .result = { 0x7e, 0x82, 0x12, 0xa1, 0Xd9, 0X5b, 0Xe4, 0Xf9 },
2191                 .rlen   = 8,
2192         }, {
2193                 .key    = { 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2,
2194                             0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2 },
2195                 .klen   = 16,
2196                 .input  = { 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2 },
2197                 .ilen   = 8,
2198                 .result = { 0Xaa, 0Xbe, 0Xc1, 0X95, 0Xc5, 0X94, 0X1a, 0X9c },
2199                 .rlen   = 8,
2200         }, {
2201                 .key    = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f,
2202                             0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2203                 .klen   = 16,
2204                 .input  = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2205                 .ilen   = 8,
2206                 .result = { 0X04, 0X74, 0Xf5, 0X70, 0X50, 0X16, 0Xd3, 0Xb8 },
2207                 .rlen   = 8,
2208         }, {
2209                 .key    = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f,
2210                             0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2211                 .klen   = 16,
2212                 .input  = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f ,
2213                             0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2214                 .ilen   = 16,
2215                 .result = { 0X04, 0X74, 0Xf5, 0X70, 0X50, 0X16, 0Xd3, 0Xb8 ,
2216                             0X04, 0X74, 0Xf5, 0X70, 0X50, 0X16, 0Xd3, 0Xb8 },
2217                 .rlen   = 16,
2218         },
2219 };
2220
2221 struct cipher_testvec khazad_dec_tv_template[] = {
2222         {
2223                 .key    = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2224                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2225                 .klen   = 16,
2226                 .input  = { 0X49, 0Xa4, 0Xce, 0X32, 0Xac, 0X19, 0X0e, 0X3f },
2227                 .ilen   = 8,
2228                 .result = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2229                 .rlen   = 8,
2230         }, {
2231                 .key    = { 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
2232                             0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38 },
2233                 .klen   = 16,
2234                 .input  = { 0X7e, 0X82, 0X12, 0Xa1, 0Xd9, 0X5b, 0Xe4, 0Xf9 },
2235                 .ilen   = 8,
2236                 .result = { 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38 },
2237                 .rlen   = 8,
2238         }, {
2239                 .key    = { 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2,
2240                             0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2 },
2241                 .klen   = 16,
2242                 .input  = { 0Xaa, 0Xbe, 0Xc1, 0X95, 0Xc5, 0X94, 0X1a, 0X9c },
2243                 .ilen   = 8,
2244                 .result = { 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2, 0Xa2 },
2245                 .rlen   = 8,
2246         }, {
2247                 .key    = { 0x2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f,
2248                             0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2249                 .klen   = 16,
2250                 .input = { 0X04, 0X74, 0Xf5, 0X70, 0X50, 0X16, 0Xd3, 0Xb8 },
2251                 .ilen   = 8,
2252                 .result = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2253                 .rlen   = 8,
2254         }, {
2255                 .key    = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f,
2256                             0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2257                 .klen   = 16,
2258                 .input = { 0X04, 0X74, 0Xf5, 0X70, 0X50, 0X16, 0Xd3, 0Xb8 ,
2259                             0X04, 0X74, 0Xf5, 0X70, 0X50, 0X16, 0Xd3, 0Xb8 },
2260                 .ilen   = 16,
2261                 .result = { 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f ,
2262                             0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f, 0X2f },
2263                 .rlen   = 16,
2264         },
2265 };
2266
2267 /*
2268  * Anubis test vectors.
2269  */
2270
2271 #define ANUBIS_ENC_TEST_VECTORS                 5
2272 #define ANUBIS_DEC_TEST_VECTORS                 5
2273 #define ANUBIS_CBC_ENC_TEST_VECTORS             2
2274 #define ANUBIS_CBC_DEC_TEST_VECTORS             2
2275
2276 struct cipher_testvec anubis_enc_tv_template[] = {
2277         {
2278                 .key    = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2279                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2280                 .klen   = 16,
2281                 .input  = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2282                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2283                 .ilen   = 16,
2284                 .result = { 0x6d, 0xc5, 0xda, 0xa2, 0x26, 0x7d, 0x62, 0x6f,
2285                             0x08, 0xb7, 0x52, 0x8e, 0x6e, 0x6e, 0x86, 0x90 },
2286                 .rlen   = 16,
2287         }, {
2288
2289                 .key    = { 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
2290                             0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
2291                             0x03, 0x03, 0x03, 0x03 },
2292                 .klen   = 20,
2293                 .input  = { 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
2294                             0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03 },
2295                 .ilen   = 16,
2296                 .result = { 0xdb, 0xf1, 0x42, 0xf4, 0xd1, 0x8a, 0xc7, 0x49,
2297                             0x87, 0x41, 0x6f, 0x82, 0x0a, 0x98, 0x64, 0xae },
2298                 .rlen   = 16,
2299         }, {
2300                 .key    = { 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2301                             0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2302                             0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2303                             0x24, 0x24, 0x24, 0x24 },
2304                 .klen   = 28,
2305                 .input  = { 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2306                             0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24 },
2307                 .ilen   = 16,
2308                 .result = { 0xfd, 0x1b, 0x4a, 0xe3, 0xbf, 0xf0, 0xad, 0x3d,
2309                             0x06, 0xd3, 0x61, 0x27, 0xfd, 0x13, 0x9e, 0xde },
2310                 .rlen   = 16,
2311         }, {
2312                 .key    = { 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2313                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2314                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2315                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25 },
2316                 .klen   = 32,
2317                 .input  = { 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2318                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25 },
2319                 .ilen   = 16,
2320                 .result = { 0x1a, 0x91, 0xfb, 0x2b, 0xb7, 0x78, 0x6b, 0xc4,
2321                             0x17, 0xd9, 0xff, 0x40, 0x3b, 0x0e, 0xe5, 0xfe },
2322                 .rlen   = 16,
2323         }, {
2324                 .key    = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2325                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2326                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2327                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2328                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2329                 .klen   = 40,
2330                 .input  = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2331                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2332                 .ilen   = 16,
2333                 .result = { 0xa5, 0x2c, 0x85, 0x6f, 0x9c, 0xba, 0xa0, 0x97,
2334                             0x9e, 0xc6, 0x84, 0x0f, 0x17, 0x21, 0x07, 0xee },
2335                 .rlen   = 16,
2336         },
2337 };
2338
2339 struct cipher_testvec anubis_dec_tv_template[] = {
2340         {
2341                 .key    = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2342                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2343                 .klen   = 16,
2344                 .input  = { 0x6d, 0xc5, 0xda, 0xa2, 0x26, 0x7d, 0x62, 0x6f,
2345                             0x08, 0xb7, 0x52, 0x8e, 0x6e, 0x6e, 0x86, 0x90 },
2346                 .ilen   = 16,
2347                 .result = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2348                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2349                 .rlen   = 16,
2350         }, {
2351
2352                 .key    = { 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
2353                             0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
2354                             0x03, 0x03, 0x03, 0x03 },
2355                 .klen   = 20,
2356                 .input  = { 0xdb, 0xf1, 0x42, 0xf4, 0xd1, 0x8a, 0xc7, 0x49,
2357                             0x87, 0x41, 0x6f, 0x82, 0x0a, 0x98, 0x64, 0xae },
2358                 .ilen   = 16,
2359                 .result = { 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
2360                             0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03 },
2361                 .rlen   = 16,
2362         }, {
2363                 .key    = { 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2364                             0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2365                             0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2366                             0x24, 0x24, 0x24, 0x24 },
2367                 .klen   = 28,
2368                 .input  = { 0xfd, 0x1b, 0x4a, 0xe3, 0xbf, 0xf0, 0xad, 0x3d,
2369                             0x06, 0xd3, 0x61, 0x27, 0xfd, 0x13, 0x9e, 0xde },
2370                 .ilen   = 16,
2371                 .result = { 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
2372                             0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24 },
2373                 .rlen   = 16,
2374         }, {
2375                 .key    = { 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2376                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2377                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2378                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25 },
2379                 .klen   = 32,
2380                 .input  = { 0x1a, 0x91, 0xfb, 0x2b, 0xb7, 0x78, 0x6b, 0xc4,
2381                             0x17, 0xd9, 0xff, 0x40, 0x3b, 0x0e, 0xe5, 0xfe },
2382                 .ilen   = 16,
2383                 .result = { 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
2384                             0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25 },
2385                 .rlen   = 16,
2386         }, {
2387                 .key    = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2388                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2389                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2390                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2391                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2392                 .input = {  0xa5, 0x2c, 0x85, 0x6f, 0x9c, 0xba, 0xa0, 0x97,
2393                             0x9e, 0xc6, 0x84, 0x0f, 0x17, 0x21, 0x07, 0xee },
2394                 .klen   = 40,
2395                 .ilen   = 16,
2396                 .result = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2397                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2398                 .rlen   = 16,
2399         },
2400 };
2401
2402 struct cipher_testvec anubis_cbc_enc_tv_template[] = {
2403         {
2404                 .key    = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2405                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2406                 .klen   = 16,
2407                 .input  = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2408                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2409                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2410                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2411                 .ilen   = 32,
2412                 .result = { 0x6d, 0xc5, 0xda, 0xa2, 0x26, 0x7d, 0x62, 0x6f,
2413                             0x08, 0xb7, 0x52, 0x8e, 0x6e, 0x6e, 0x86, 0x90,
2414                             0x86, 0xd8, 0xb5, 0x6f, 0x98, 0x5e, 0x8a, 0x66,
2415                             0x4f, 0x1f, 0x78, 0xa1, 0xbb, 0x37, 0xf1, 0xbe },
2416                 .rlen   = 32,
2417         }, {
2418                 .key    = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2419                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2420                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2421                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2422                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2423                 .klen   = 40,
2424                 .input  = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2425                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2426                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2427                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2428                 .ilen   = 32,
2429                 .result = { 0xa5, 0x2c, 0x85, 0x6f, 0x9c, 0xba, 0xa0, 0x97,
2430                             0x9e, 0xc6, 0x84, 0x0f, 0x17, 0x21, 0x07, 0xee,
2431                             0xa2, 0xbc, 0x06, 0x98, 0xc6, 0x4b, 0xda, 0x75,
2432                             0x2e, 0xaa, 0xbe, 0x58, 0xce, 0x01, 0x5b, 0xc7 },
2433                 .rlen   = 32,
2434         },
2435 };
2436
2437 struct cipher_testvec anubis_cbc_dec_tv_template[] = {
2438         {
2439                 .key    = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2440                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2441                 .klen   = 16,
2442                 .input  = { 0x6d, 0xc5, 0xda, 0xa2, 0x26, 0x7d, 0x62, 0x6f,
2443                             0x08, 0xb7, 0x52, 0x8e, 0x6e, 0x6e, 0x86, 0x90,
2444                             0x86, 0xd8, 0xb5, 0x6f, 0x98, 0x5e, 0x8a, 0x66,
2445                             0x4f, 0x1f, 0x78, 0xa1, 0xbb, 0x37, 0xf1, 0xbe },
2446                 .ilen   = 32,
2447                 .result = { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2448                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2449                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
2450                             0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe },
2451                 .rlen   = 32,
2452         }, {
2453                 .key    = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2454                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2455                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2456                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2457                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2458                 .klen   = 40,
2459                 .input = { 0xa5, 0x2c, 0x85, 0x6f, 0x9c, 0xba, 0xa0, 0x97,
2460                             0x9e, 0xc6, 0x84, 0x0f, 0x17, 0x21, 0x07, 0xee,
2461                             0xa2, 0xbc, 0x06, 0x98, 0xc6, 0x4b, 0xda, 0x75,
2462                             0x2e, 0xaa, 0xbe, 0x58, 0xce, 0x01, 0x5b, 0xc7 },
2463                 .ilen   = 32,
2464                 .result = { 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2465                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2466                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
2467                             0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35 },
2468                 .rlen   = 32,
2469         },
2470 };
2471
2472 /*
2473  * XETA test vectors
2474  */
2475 #define XETA_ENC_TEST_VECTORS   4
2476 #define XETA_DEC_TEST_VECTORS   4
2477
2478 struct cipher_testvec xeta_enc_tv_template[] =
2479 {
2480         {
2481                 .key    = { [0 ... 15] = 0x00 },
2482                 .klen   = 16,
2483                 .input  = { [0 ... 8] = 0x00 },
2484                 .ilen   = 8,
2485                 .result = { 0xaa, 0x22, 0x96, 0xe5, 0x6c, 0x61, 0xf3, 0x45 },
2486                 .rlen   = 8,
2487         }, {
2488                 .key    = { 0x2b, 0x02, 0x05, 0x68, 0x06, 0x14, 0x49, 0x76,
2489                             0x77, 0x5d, 0x0e, 0x26, 0x6c, 0x28, 0x78, 0x43 },
2490                 .klen   = 16,
2491                 .input  = { 0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x2e },
2492                 .ilen   = 8,
2493                 .result = { 0x82, 0x3e, 0xeb, 0x35, 0xdc, 0xdd, 0xd9, 0xc3 },
2494                 .rlen   = 8,
2495         }, {
2496                 .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2497                             0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2498                 .klen   = 16,
2499                 .input  = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2500                             0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2501                 .ilen   = 16,
2502                 .result = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea,
2503                             0x61, 0x35, 0xaa, 0xed, 0xb5, 0xcb, 0x71, 0x2c },
2504                 .rlen   = 16,
2505         }, {
2506                 .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2507                             0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2508                 .klen   = 16,
2509                 .input  = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2510                             0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2511                             0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2512                             0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2513                 .ilen   = 32,
2514                 .result = { 0x0b, 0x03, 0xcd, 0x8a, 0xbe, 0x95, 0xfd, 0xb1,
2515                             0xc1, 0x44, 0x91, 0x0b, 0xa5, 0xc9, 0x1b, 0xb4,
2516                             0xa9, 0xda, 0x1e, 0x9e, 0xb1, 0x3e, 0x2a, 0x8f,
2517                             0xea, 0xa5, 0x6a, 0x85, 0xd1, 0xf4, 0xa8, 0xa5 },
2518                 .rlen   = 32,
2519         }
2520 };
2521
2522 struct cipher_testvec xeta_dec_tv_template[] =
2523 {
2524         {
2525                 .key    = { [0 ... 15] = 0x00 },
2526                 .klen   = 16,
2527                 .input  = { 0xaa, 0x22, 0x96, 0xe5, 0x6c, 0x61, 0xf3, 0x45 },
2528                 .ilen   = 8,
2529                 .result = { [0 ... 8] = 0x00 },
2530                 .rlen   = 8,
2531         }, {
2532                 .key    = { 0x2b, 0x02, 0x05, 0x68, 0x06, 0x14, 0x49, 0x76,
2533                             0x77, 0x5d, 0x0e, 0x26, 0x6c, 0x28, 0x78, 0x43 },
2534                 .klen   = 16,
2535                 .input  = { 0x82, 0x3e, 0xeb, 0x35, 0xdc, 0xdd, 0xd9, 0xc3 },
2536                 .ilen   = 8,
2537                 .result = { 0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x65, 0x2e },
2538                 .rlen   = 8,
2539         }, {
2540                 .key    = { 0x09, 0x65, 0x43, 0x11, 0x66, 0x44, 0x39, 0x25,
2541                             0x51, 0x3a, 0x16, 0x10, 0x0a, 0x08, 0x12, 0x6e },
2542                 .klen   = 16,
2543                 .input  = { 0xe2, 0x04, 0xdb, 0xf2, 0x89, 0x85, 0x9e, 0xea,
2544                             0x61, 0x35, 0xaa, 0xed, 0xb5, 0xcb, 0x71, 0x2c },
2545                 .ilen   = 16,
2546                 .result = { 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x74,
2547                             0x65, 0x73, 0x74, 0x5f, 0x76, 0x65, 0x63, 0x74 },
2548                 .rlen   = 16,
2549         }, {
2550                 .key    = { 0x4d, 0x76, 0x32, 0x17, 0x05, 0x3f, 0x75, 0x2c,
2551                             0x5d, 0x04, 0x16, 0x36, 0x15, 0x72, 0x63, 0x2f },
2552                 .klen   = 16,
2553                 .input  = { 0x0b, 0x03, 0xcd, 0x8a, 0xbe, 0x95, 0xfd, 0xb1,
2554                             0xc1, 0x44, 0x91, 0x0b, 0xa5, 0xc9, 0x1b, 0xb4,
2555                             0xa9, 0xda, 0x1e, 0x9e, 0xb1, 0x3e, 0x2a, 0x8f,
2556                             0xea, 0xa5, 0x6a, 0x85, 0xd1, 0xf4, 0xa8, 0xa5 },
2557                 .ilen   = 32,
2558                 .result = { 0x54, 0x65, 0x61, 0x20, 0x69, 0x73, 0x20, 0x67,
2559                             0x6f, 0x6f, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
2560                             0x79, 0x6f, 0x75, 0x21, 0x21, 0x21, 0x20, 0x72,
2561                             0x65, 0x61, 0x6c, 0x6c, 0x79, 0x21, 0x21, 0x21 },
2562                 .rlen   = 32,
2563         }
2564 };
2565
2566 /*
2567  * Compression stuff.
2568  */
2569 #define COMP_BUF_SIZE           512
2570
2571 struct comp_testvec {
2572         int inlen, outlen;
2573         char input[COMP_BUF_SIZE];
2574         char output[COMP_BUF_SIZE];
2575 };
2576
2577 /*
2578  * Deflate test vectors (null-terminated strings).
2579  * Params: winbits=11, Z_DEFAULT_COMPRESSION, MAX_MEM_LEVEL.
2580  */
2581 #define DEFLATE_COMP_TEST_VECTORS 2
2582 #define DEFLATE_DECOMP_TEST_VECTORS 2
2583
2584 struct comp_testvec deflate_comp_tv_template[] = {
2585         {
2586                 .inlen  = 70,
2587                 .outlen = 38,
2588                 .input  = "Join us now and share the software "
2589                           "Join us now and share the software ",
2590                 .output = { 0xf3, 0xca, 0xcf, 0xcc, 0x53, 0x28, 0x2d, 0x56,
2591                             0xc8, 0xcb, 0x2f, 0x57, 0x48, 0xcc, 0x4b, 0x51,
2592                             0x28, 0xce, 0x48, 0x2c, 0x4a, 0x55, 0x28, 0xc9,
2593                             0x48, 0x55, 0x28, 0xce, 0x4f, 0x2b, 0x29, 0x07,
2594                             0x71, 0xbc, 0x08, 0x2b, 0x01, 0x00 },
2595         }, {
2596                 .inlen  = 191,
2597                 .outlen = 122,
2598                 .input  = "This document describes a compression method based on the DEFLATE"
2599                           "compression algorithm.  This document defines the application of "
2600                           "the DEFLATE algorithm to the IP Payload Compression Protocol.",
2601                 .output = { 0x5d, 0x8d, 0x31, 0x0e, 0xc2, 0x30, 0x10, 0x04,
2602                             0xbf, 0xb2, 0x2f, 0xc8, 0x1f, 0x10, 0x04, 0x09,
2603                             0x89, 0xc2, 0x85, 0x3f, 0x70, 0xb1, 0x2f, 0xf8,
2604                             0x24, 0xdb, 0x67, 0xd9, 0x47, 0xc1, 0xef, 0x49,
2605                             0x68, 0x12, 0x51, 0xae, 0x76, 0x67, 0xd6, 0x27,
2606                             0x19, 0x88, 0x1a, 0xde, 0x85, 0xab, 0x21, 0xf2,
2607                             0x08, 0x5d, 0x16, 0x1e, 0x20, 0x04, 0x2d, 0xad,
2608                             0xf3, 0x18, 0xa2, 0x15, 0x85, 0x2d, 0x69, 0xc4,
2609                             0x42, 0x83, 0x23, 0xb6, 0x6c, 0x89, 0x71, 0x9b,
2610                             0xef, 0xcf, 0x8b, 0x9f, 0xcf, 0x33, 0xca, 0x2f,
2611                             0xed, 0x62, 0xa9, 0x4c, 0x80, 0xff, 0x13, 0xaf,
2612                             0x52, 0x37, 0xed, 0x0e, 0x52, 0x6b, 0x59, 0x02,
2613                             0xd9, 0x4e, 0xe8, 0x7a, 0x76, 0x1d, 0x02, 0x98,
2614                             0xfe, 0x8a, 0x87, 0x83, 0xa3, 0x4f, 0x56, 0x8a,
2615                             0xb8, 0x9e, 0x8e, 0x5c, 0x57, 0xd3, 0xa0, 0x79,
2616                             0xfa, 0x02 },
2617         },
2618 };
2619
2620 struct comp_testvec deflate_decomp_tv_template[] = {
2621         {
2622                 .inlen  = 122,
2623                 .outlen = 191,
2624                 .input  = { 0x5d, 0x8d, 0x31, 0x0e, 0xc2, 0x30, 0x10, 0x04,
2625                             0xbf, 0xb2, 0x2f, 0xc8, 0x1f, 0x10, 0x04, 0x09,
2626                             0x89, 0xc2, 0x85, 0x3f, 0x70, 0xb1, 0x2f, 0xf8,
2627                             0x24, 0xdb, 0x67, 0xd9, 0x47, 0xc1, 0xef, 0x49,
2628                             0x68, 0x12, 0x51, 0xae, 0x76, 0x67, 0xd6, 0x27,
2629                             0x19, 0x88, 0x1a, 0xde, 0x85, 0xab, 0x21, 0xf2,
2630                             0x08, 0x5d, 0x16, 0x1e, 0x20, 0x04, 0x2d, 0xad,
2631                             0xf3, 0x18, 0xa2, 0x15, 0x85, 0x2d, 0x69, 0xc4,
2632                             0x42, 0x83, 0x23, 0xb6, 0x6c, 0x89, 0x71, 0x9b,
2633                             0xef, 0xcf, 0x8b, 0x9f, 0xcf, 0x33, 0xca, 0x2f,
2634                             0xed, 0x62, 0xa9, 0x4c, 0x80, 0xff, 0x13, 0xaf,
2635                             0x52, 0x37, 0xed, 0x0e, 0x52, 0x6b, 0x59, 0x02,
2636                             0xd9, 0x4e, 0xe8, 0x7a, 0x76, 0x1d, 0x02, 0x98,
2637                             0xfe, 0x8a, 0x87, 0x83, 0xa3, 0x4f, 0x56, 0x8a,
2638                             0xb8, 0x9e, 0x8e, 0x5c, 0x57, 0xd3, 0xa0, 0x79,
2639                             0xfa, 0x02 },
2640                 .output = "This document describes a compression method based on the DEFLATE"
2641                           "compression algorithm.  This document defines the application of "
2642                           "the DEFLATE algorithm to the IP Payload Compression Protocol.",
2643         }, {
2644                 .inlen  = 38,
2645                 .outlen = 70,
2646                 .input  = { 0xf3, 0xca, 0xcf, 0xcc, 0x53, 0x28, 0x2d, 0x56,
2647                             0xc8, 0xcb, 0x2f, 0x57, 0x48, 0xcc, 0x4b, 0x51,
2648                             0x28, 0xce, 0x48, 0x2c, 0x4a, 0x55, 0x28, 0xc9,
2649                             0x48, 0x55, 0x28, 0xce, 0x4f, 0x2b, 0x29, 0x07,
2650                             0x71, 0xbc, 0x08, 0x2b, 0x01, 0x00 },
2651                 .output = "Join us now and share the software "
2652                           "Join us now and share the software ",
2653         },
2654 };
2655
2656 /*
2657  * Michael MIC test vectors from IEEE 802.11i
2658  */
2659 #define MICHAEL_MIC_TEST_VECTORS 6
2660
2661 struct hash_testvec michael_mic_tv_template[] =
2662 {
2663         {
2664                 .key = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
2665                 .ksize = 8,
2666                 .plaintext = { },
2667                 .psize = 0,
2668                 .digest = { 0x82, 0x92, 0x5c, 0x1c, 0xa1, 0xd1, 0x30, 0xb8 }
2669         },
2670         {
2671                 .key = { 0x82, 0x92, 0x5c, 0x1c, 0xa1, 0xd1, 0x30, 0xb8 },
2672                 .ksize = 8,
2673                 .plaintext = { 'M' },
2674                 .psize = 1,
2675                 .digest = { 0x43, 0x47, 0x21, 0xca, 0x40, 0x63, 0x9b, 0x3f }
2676         },
2677         {
2678                 .key = { 0x43, 0x47, 0x21, 0xca, 0x40, 0x63, 0x9b, 0x3f },
2679                 .ksize = 8,
2680                 .plaintext = { 'M', 'i' },
2681                 .psize = 2,
2682                 .digest = { 0xe8, 0xf9, 0xbe, 0xca, 0xe9, 0x7e, 0x5d, 0x29 }
2683         },
2684         {
2685                 .key = { 0xe8, 0xf9, 0xbe, 0xca, 0xe9, 0x7e, 0x5d, 0x29 },
2686                 .ksize = 8,
2687                 .plaintext = { 'M', 'i', 'c' },
2688                 .psize = 3,
2689                 .digest = { 0x90, 0x03, 0x8f, 0xc6, 0xcf, 0x13, 0xc1, 0xdb }
2690         },
2691         {
2692                 .key = { 0x90, 0x03, 0x8f, 0xc6, 0xcf, 0x13, 0xc1, 0xdb },
2693                 .ksize = 8,
2694                 .plaintext = { 'M', 'i', 'c', 'h' },
2695                 .psize = 4,
2696                 .digest = { 0xd5, 0x5e, 0x10, 0x05, 0x10, 0x12, 0x89, 0x86 }
2697         },
2698         {
2699                 .key = { 0xd5, 0x5e, 0x10, 0x05, 0x10, 0x12, 0x89, 0x86 },
2700                 .ksize = 8,
2701                 .plaintext = { 'M', 'i', 'c', 'h', 'a', 'e', 'l' },
2702                 .psize = 7,
2703                 .digest = { 0x0a, 0x94, 0x2b, 0x12, 0x4e, 0xca, 0xa5, 0x46 },
2704         }
2705 };
2706
2707 #endif  /* _CRYPTO_TCRYPT_H */