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