tcrypt.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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  */
   16 #ifndef _CRYPTO_TCRYPT_H
   17 #define _CRYPTO_TCRYPT_H
   18 
   19 #define MD5_DIGEST_SIZE         16
   20 #define MD4_DIGEST_SIZE         16
   21 #define SHA1_DIGEST_SIZE        20
   22 #define SHA256_DIGEST_SIZE      32
   23 #define SHA384_DIGEST_SIZE      48
   24 #define SHA512_DIGEST_SIZE      64
   25 
   26 /*
   27  * MD4 test vectors from RFC1320
   28  */
   29 #define MD4_TEST_VECTORS        7
   30 
   31 struct md4_testvec {
   32         char plaintext[128];
   33         char digest[MD4_DIGEST_SIZE];
   34 } md4_tv_template[] = {
   35         { "",
   36                 { 0x31, 0xd6, 0xcf, 0xe0, 0xd1, 0x6a, 0xe9, 0x31,
   37                   0xb7, 0x3c, 0x59, 0xd7, 0xe0, 0xc0, 0x89, 0xc0 }
   38         },
   39         
   40         { "a",
   41                 { 0xbd, 0xe5, 0x2c, 0xb3, 0x1d, 0xe3, 0x3e, 0x46,
   42                   0x24, 0x5e, 0x05, 0xfb, 0xdb, 0xd6, 0xfb, 0x24 }
   43         },
   44 
   45         { "abc",
   46                 { 0xa4, 0x48, 0x01, 0x7a, 0xaf, 0x21, 0xd8, 0x52,
   47                   0x5f, 0xc1, 0x0a, 0xe8, 0x7a, 0xa6, 0x72, 0x9d }
   48         },
   49         
   50         { "message digest",
   51                 { 0xd9, 0x13, 0x0a, 0x81, 0x64, 0x54, 0x9f, 0xe8,
   52                   0x18, 0x87, 0x48, 0x06, 0xe1, 0xc7, 0x01, 0x4b }
   53         },
   54         
   55         { "abcdefghijklmnopqrstuvwxyz",
   56                 { 0xd7, 0x9e, 0x1c, 0x30, 0x8a, 0xa5, 0xbb, 0xcd,
   57                   0xee, 0xa8, 0xed, 0x63, 0xdf, 0x41, 0x2d, 0xa9 }
   58         },
   59                 
   60         { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
   61                 { 0x04, 0x3f, 0x85, 0x82, 0xf2, 0x41, 0xdb, 0x35,
   62                   0x1c, 0xe6, 0x27, 0xe1, 0x53, 0xe7, 0xf0, 0xe4 }
   63         },
   64         
   65         { "123456789012345678901234567890123456789012345678901234567890123"
   66           "45678901234567890",
   67                 { 0xe3, 0x3b, 0x4d, 0xdc, 0x9c, 0x38, 0xf2, 0x19,
   68                   0x9c, 0x3e, 0x7b, 0x16, 0x4f, 0xcc, 0x05, 0x36 }
   69         },
   70 };
   71 
   72 /*
   73  * MD5 test vectors from RFC1321
   74  */
   75 #define MD5_TEST_VECTORS        7
   76 
   77 struct md5_testvec {
   78         char plaintext[128];
   79         char digest[MD5_DIGEST_SIZE];
   80 } md5_tv_template[] = {
   81         { "",
   82                 { 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04,
   83                   0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e } },
   84                         
   85         { "a",
   86                 { 0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1, 0xb6, 0xa8,
   87                   0x31, 0xc3, 0x99, 0xe2, 0x69, 0x77, 0x26, 0x61 } },
   88                   
   89         { "abc",
   90                 { 0x90, 0x01, 0x50, 0x98, 0x3c, 0xd2, 0x4f, 0xb0,
   91                   0xd6, 0x96, 0x3f, 0x7d, 0x28, 0xe1, 0x7f, 0x72 } }, 
   92                   
   93         { "message digest",
   94                 { 0xf9, 0x6b, 0x69, 0x7d, 0x7c, 0xb7, 0x93, 0x8d,
   95                   0x52, 0x5a, 0x2f, 0x31, 0xaa, 0xf1, 0x61, 0xd0 } },
   96                   
   97         { "abcdefghijklmnopqrstuvwxyz",
   98                 { 0xc3, 0xfc, 0xd3, 0xd7, 0x61, 0x92, 0xe4, 0x00,
   99                   0x7d, 0xfb, 0x49, 0x6c, 0xca, 0x67, 0xe1, 0x3b } },
  100                   
  101         { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
  102                 { 0xd1, 0x74, 0xab, 0x98, 0xd2, 0x77, 0xd9, 0xf5,
  103                   0xa5, 0x61, 0x1c, 0x2c, 0x9f, 0x41, 0x9d, 0x9f } },
  104                   
  105         { "12345678901234567890123456789012345678901234567890123456789012"
  106           "345678901234567890",
  107                 { 0x57, 0xed, 0xf4, 0xa2, 0x2b, 0xe3, 0xc9, 0x55,
  108                   0xac, 0x49, 0xda, 0x2e, 0x21, 0x07, 0xb6, 0x7a } }
  109 };
  110 
  111 #ifdef CONFIG_CRYPTO_HMAC
  112 /*
  113  * HMAC-MD5 test vectors from RFC2202
  114  * (These need to be fixed to not use strlen).
  115  */
  116 #define HMAC_MD5_TEST_VECTORS   7
  117 
  118 struct hmac_md5_testvec {
  119         char key[128];
  120         char plaintext[128];
  121         char digest[MD5_DIGEST_SIZE];
  122 };
  123 
  124 struct hmac_md5_testvec hmac_md5_tv_template[] =
  125 {
  126         
  127         {
  128                 { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  129                   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x00},
  130                   
  131                 "Hi There",
  132                 
  133                 { 0x92, 0x94, 0x72, 0x7a, 0x36, 0x38, 0xbb, 0x1c,
  134                   0x13, 0xf4, 0x8e, 0xf8, 0x15, 0x8b, 0xfc, 0x9d }
  135         },
  136             
  137         {
  138                 { 'J', 'e', 'f', 'e', 0 },
  139                 
  140                 "what do ya want for nothing?",
  141                 
  142                 { 0x75, 0x0c, 0x78, 0x3e, 0x6a, 0xb0, 0xb5, 0x03,
  143                   0xea, 0xa8, 0x6e, 0x31, 0x0a, 0x5d, 0xb7, 0x38 }
  144         },
  145         
  146         {
  147                 { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  148                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x00 },
  149                   
  150                 { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  151                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  152                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  153                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  154                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  155                   0x00 },
  156                   
  157                 { 0x56, 0xbe, 0x34, 0x52, 0x1d, 0x14, 0x4c, 0x88,
  158                   0xdb, 0xb8, 0xc7, 0x33, 0xf0, 0xe8, 0xb3, 0xf6 }
  159         },
  160         
  161         {
  162                 { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
  163                   0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 
  164                   0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00 },
  165                   
  166                 { 
  167                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  168                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  169                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  170                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  171                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  172                   0x00 },
  173                   
  174                 { 0x69, 0x7e, 0xaf, 0x0a, 0xca, 0x3a, 0x3a, 0xea,
  175                   0x3a, 0x75, 0x16, 0x47, 0x46, 0xff, 0xaa, 0x79 }
  176         },
  177         
  178         {
  179                 { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
  180                   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x00 },
  181                   
  182                 "Test With Truncation",
  183                 
  184                 { 0x56, 0x46, 0x1e, 0xf2, 0x34, 0x2e, 0xdc, 0x00,
  185                   0xf9, 0xba, 0xb9, 0x95, 0x69, 0x0e, 0xfd, 0x4c }
  186         },
  187         
  188         {
  189                 { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  190                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  191                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  192                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  193                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  194                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  195                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  196                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  197                   0x00 },
  198                   
  199                 "Test Using Larger Than Block-Size Key - Hash Key First",
  200                 
  201                 { 0x6b, 0x1a, 0xb7, 0xfe, 0x4b, 0xd7, 0xbf, 0x8f,
  202                   0x0b, 0x62, 0xe6, 0xce, 0x61, 0xb9, 0xd0, 0xcd }
  203         },
  204         
  205         {
  206                 { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  207                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  208                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  209                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  210                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  211                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  212                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  213                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  214                   0x00 },
  215                 
  216                 "Test Using Larger Than Block-Size Key and Larger Than One "
  217                 "Block-Size Data",
  218                 
  219                 { 0x6f, 0x63, 0x0f, 0xad, 0x67, 0xcd, 0xa0, 0xee,
  220                   0x1f, 0xb1, 0xf5, 0x62, 0xdb, 0x3a, 0xa5, 0x3e }
  221         },
  222         
  223         /* cross page test, need to retain key */
  224         
  225         {
  226                 { 'J', 'e', 'f', 'e', 0 },
  227                 
  228                 "what do ya want for nothing?",
  229                 
  230                 { 0x75, 0x0c, 0x78, 0x3e, 0x6a, 0xb0, 0xb5, 0x03,
  231                   0xea, 0xa8, 0x6e, 0x31, 0x0a, 0x5d, 0xb7, 0x38 }
  232         },
  233         
  234 };
  235 
  236         
  237 /*
  238  * HMAC-SHA1 test vectors from RFC2202
  239  */
  240 
  241 #define HMAC_SHA1_TEST_VECTORS  7
  242 
  243 struct hmac_sha1_testvec {
  244         char key[128];
  245         char plaintext[128];
  246         char digest[SHA1_DIGEST_SIZE];
  247 } hmac_sha1_tv_template[] = {
  248         
  249         {
  250                 { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  251                   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  252                   0x00},
  253                   
  254                 "Hi There",
  255 
  256                 { 0xb6, 0x17, 0x31, 0x86, 0x55, 0x05, 0x72, 0x64,
  257                   0xe2, 0x8b, 0xc0, 0xb6, 0xfb ,0x37, 0x8c, 0x8e, 0xf1,
  258                   0x46, 0xbe, 0x00 }
  259         },
  260             
  261         {
  262                 { 'J', 'e', 'f', 'e', 0 },
  263                 
  264                 "what do ya want for nothing?",
  265 
  266                 { 0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, 0x2f, 0xa2, 0xd2, 0x74, 
  267                   0x16, 0xd5, 0xf1, 0x84, 0xdf, 0x9c, 0x25, 0x9a, 0x7c, 0x79 }
  268 
  269         },
  270         
  271         {
  272                 { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 
  273                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  274                   0x00},
  275 
  276                   
  277                 { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  278                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  279                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  280                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  281                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  282                   0x00 },
  283                   
  284                 { 0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, 0x11, 0xcd, 0x91, 0xa3, 
  285                   0x9a, 0xf4, 0x8a, 0xa1, 0x7b, 0x4f, 0x63, 0xf1, 0x75, 0xd3 }
  286 
  287         },
  288         
  289         {
  290                 { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
  291                   0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 
  292                   0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00 },
  293                   
  294                 { 
  295                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  296                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  297                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  298                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  299                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  300                   0x00 },
  301                   
  302                 { 0x4c, 0x90, 0x07, 0xf4, 0x02, 0x62, 0x50, 0xc6, 0xbc, 0x84, 
  303                   0x14, 0xf9, 0xbf, 0x50, 0xc8, 0x6c, 0x2d, 0x72, 0x35, 0xda }
  304 
  305         },
  306         
  307         {
  308                 { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
  309                   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
  310                   0x00 },
  311                   
  312                 "Test With Truncation",
  313                 
  314                 { 0x4c, 0x1a, 0x03, 0x42, 0x4b, 0x55, 0xe0, 0x7f, 0xe7, 0xf2, 
  315                   0x7b, 0xe1, 0xd5, 0x8b, 0xb9, 0x32, 0x4a, 0x9a, 0x5a, 0x04 }
  316 
  317         },
  318         
  319         {
  320                 { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  321                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  322                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  323                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  324                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  325                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  326                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  327                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  328                   0x00 },
  329                   
  330                 "Test Using Larger Than Block-Size Key - Hash Key First",
  331                 
  332                 { 0xaa, 0x4a, 0xe5, 0xe1, 0x52, 0x72, 0xd0, 0x0e, 0x95, 0x70, 
  333                   0x56, 0x37, 0xce, 0x8a, 0x3b, 0x55, 0xed, 0x40, 0x21, 0x12 }
  334 
  335         },
  336         
  337         {
  338                 { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  339                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  340                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  341                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  342                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  343                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  344                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  345                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  346                   0x00 },
  347                 
  348                 "Test Using Larger Than Block-Size Key and Larger Than One "
  349                 "Block-Size Data",
  350                 
  351                 { 0xe8, 0xe9, 0x9d, 0x0f, 0x45, 0x23, 0x7d, 0x78, 0x6d, 0x6b, 
  352                   0xba, 0xa7, 0x96, 0x5c, 0x78, 0x08, 0xbb, 0xff, 0x1a, 0x91 }
  353         },
  354         
  355         /* cross page test */
  356         {
  357                 { 'J', 'e', 'f', 'e', 0 },
  358                 
  359                 "what do ya want for nothing?",
  360 
  361                 { 0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, 0x2f, 0xa2, 0xd2, 0x74, 
  362                   0x16, 0xd5, 0xf1, 0x84, 0xdf, 0x9c, 0x25, 0x9a, 0x7c, 0x79 }
  363 
  364         },
  365 
  366 };
  367 
  368 /*
  369  * HMAC-SHA256 test vectors from
  370  * draft-ietf-ipsec-ciph-sha-256-01.txt
  371  */
  372 #define HMAC_SHA256_TEST_VECTORS        10
  373 
  374 struct hmac_sha256_testvec {
  375         char key[128];
  376         char plaintext[128];
  377         char digest[SHA256_DIGEST_SIZE];
  378 } hmac_sha256_tv_template[] = {
  379 
  380         {
  381                 { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
  382                   0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
  383                   0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
  384                   0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x00 },
  385                   
  386         
  387                 { "abc" },
  388                 
  389                 { 0xa2, 0x1b, 0x1f, 0x5d, 0x4c, 0xf4, 0xf7, 0x3a,
  390                   0x4d, 0xd9, 0x39, 0x75, 0x0f, 0x7a, 0x06, 0x6a,
  391                   0x7f, 0x98, 0xcc, 0x13, 0x1c, 0xb1, 0x6a, 0x66,
  392                   0x92, 0x75, 0x90, 0x21, 0xcf, 0xab, 0x81, 0x81 },
  393 
  394         },
  395         
  396         {
  397                 { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
  398                   0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
  399                   0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
  400                    0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x00 },
  401                 
  402                 { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
  403                 
  404                 { 0x10, 0x4f, 0xdc, 0x12, 0x57, 0x32, 0x8f, 0x08,
  405                   0x18, 0x4b, 0xa7, 0x31, 0x31, 0xc5, 0x3c, 0xae,
  406                   0xe6, 0x98, 0xe3, 0x61, 0x19, 0x42, 0x11, 0x49,
  407                   0xea, 0x8c, 0x71, 0x24, 0x56, 0x69, 0x7d, 0x30 }
  408         },
  409 
  410         {
  411                 { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
  412                   0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
  413                   0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
  414                   0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x00 },
  415                 
  416                 { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
  417                   "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
  418                 
  419                 { 0x47, 0x03, 0x05, 0xfc, 0x7e, 0x40, 0xfe, 0x34,
  420                   0xd3, 0xee, 0xb3, 0xe7, 0x73, 0xd9, 0x5a, 0xab,
  421                   0x73, 0xac, 0xf0, 0xfd, 0x06, 0x04, 0x47, 0xa5,
  422                   0xeb, 0x45, 0x95, 0xbf, 0x33, 0xa9, 0xd1, 0xa3 }
  423         },
  424 
  425         {
  426                 { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  427                   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  428                   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  429                   0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x00 },
  430                 
  431                 { "Hi There" },
  432                 
  433                 { 0x19, 0x8a, 0x60, 0x7e, 0xb4, 0x4b, 0xfb, 0xc6,
  434                   0x99, 0x03, 0xa0, 0xf1, 0xcf, 0x2b, 0xbd, 0xc5,
  435                   0xba, 0x0a, 0xa3, 0xf3, 0xd9, 0xae, 0x3c, 0x1c,
  436                   0x7a, 0x3b, 0x16, 0x96, 0xa0, 0xb6, 0x8c, 0xf7 }
  437         },
  438 
  439         {
  440                 { "Jefe" },
  441                 
  442                 { "what do ya want for nothing?" },
  443                 
  444                 { 0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e,
  445                   0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7,
  446                   0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83,
  447                   0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43 }
  448         },
  449 
  450         {
  451                 { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  452                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  453                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  454                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x00 },
  455                 
  456                 { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  457                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  458                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  459                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  460                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  461                   0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
  462                   0xdd, 0xdd, 0x00 },
  463                 
  464                 { 0xcd, 0xcb, 0x12, 0x20, 0xd1, 0xec, 0xcc, 0xea,
  465                   0x91, 0xe5, 0x3a, 0xba, 0x30, 0x92, 0xf9, 0x62,
  466                   0xe5, 0x49, 0xfe, 0x6c, 0xe9, 0xed, 0x7f, 0xdc,
  467                   0x43, 0x19, 0x1f, 0xbd, 0xe4, 0x5c, 0x30, 0xb0 }
  468         },
  469 
  470         {
  471                 { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
  472                   0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
  473                   0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
  474                   0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
  475                   0x21, 0x22, 0x23, 0x24, 0x25, 0x00 },
  476                 
  477                 { 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  478                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  479                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  480                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  481                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  482                   0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
  483                   0xcd, 0xcd, 0x00 },
  484                 
  485                 { 0xd4, 0x63, 0x3c, 0x17, 0xf6, 0xfb, 0x8d, 0x74,
  486                   0x4c, 0x66, 0xde, 0xe0, 0xf8, 0xf0, 0x74, 0x55,
  487                   0x6e, 0xc4, 0xaf, 0x55, 0xef, 0x07, 0x99, 0x85,
  488                   0x41, 0x46, 0x8e, 0xb4, 0x9b, 0xd2, 0xe9, 0x17 }
  489         },
  490 
  491         {
  492                 { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
  493                   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
  494                   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
  495                   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x00 },
  496                 
  497                 { "Test With Truncation" },
  498                 
  499                 { 0x75, 0x46, 0xaf, 0x01, 0x84, 0x1f, 0xc0, 0x9b,
  500                   0x1a, 0xb9, 0xc3, 0x74, 0x9a, 0x5f, 0x1c, 0x17,
  501                   0xd4, 0xf5, 0x89, 0x66, 0x8a, 0x58, 0x7b, 0x27,
  502                   0x00, 0xa9, 0xc9, 0x7c, 0x11, 0x93, 0xcf, 0x42 }
  503         },
  504         
  505         {
  506                 { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  507                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  508                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  509                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  510                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  511                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  512                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  513                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  514                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  515                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x00 },
  516                 
  517                 { "Test Using Larger Than Block-Size Key - Hash Key First" },
  518                 
  519                 { 0x69, 0x53, 0x02, 0x5e, 0xd9, 0x6f, 0x0c, 0x09,
  520                   0xf8, 0x0a, 0x96, 0xf7, 0x8e, 0x65, 0x38, 0xdb,
  521                   0xe2, 0xe7, 0xb8, 0x20, 0xe3, 0xdd, 0x97, 0x0e,
  522                   0x7d, 0xdd, 0x39, 0x09, 0x1b, 0x32, 0x35, 0x2f }
  523         },
  524 
  525         {
  526                 { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  527                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  528                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  529                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  530                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  531                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  532                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  533                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  534                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  535                   0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x00 },
  536                 
  537                 { "Test Using Larger Than Block-Size Key and Larger Than "
  538                   "One Block-Size Data" },
  539                 
  540                 { 0x63, 0x55, 0xac, 0x22, 0xe8, 0x90, 0xd0, 0xa3,
  541                   0xc8, 0x48, 0x1a, 0x5c, 0xa4, 0x82, 0x5b, 0xc8,
  542                   0x84, 0xd3, 0xe7, 0xa1, 0xff, 0x98, 0xa2, 0xfc,
  543                   0x2a, 0xc7, 0xd8, 0xe0, 0x64, 0xc3, 0xb2, 0xe6 }
  544         },
  545 };
  546 
  547 
  548 #endif  /* CONFIG_CRYPTO_HMAC */
  549 
  550 /*
  551  * SHA1 test vectors  from from FIPS PUB 180-1
  552  */
  553 #define SHA1_TEST_VECTORS       2
  554 
  555 struct sha1_testvec {
  556         char plaintext[128];
  557         char digest[SHA1_DIGEST_SIZE];
  558 } sha1_tv_template[] = {
  559         { "abc",
  560           { 0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E, 
  561             0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C ,0x9C, 0xD0, 0xD8, 0x9D }
  562         },
  563                         
  564         { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
  565 
  566           { 0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E ,0xBA, 0xAE,
  567             0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1 }
  568         }
  569 };
  570 
  571 /*
  572  * SHA256 test vectors from from NIST
  573  */
  574 #define SHA256_TEST_VECTORS     2
  575 
  576 struct sha256_testvec {
  577         char plaintext[128];
  578         char digest[SHA256_DIGEST_SIZE];
  579 } sha256_tv_template[] = {
  580         { "abc",
  581           { 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
  582             0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23,
  583             0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
  584             0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad }
  585         },
  586                         
  587         { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
  588           { 0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8,
  589             0xe5, 0xc0, 0x26, 0x93, 0x0c, 0x3e, 0x60, 0x39,
  590             0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67,
  591             0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1 }
  592         },
  593 };
  594 
  595 /*
  596  * SHA384 test vectors from from NIST and kerneli
  597  */
  598 #define SHA384_TEST_VECTORS     4
  599 
  600 struct sha384_testvec {
  601         char plaintext[128];
  602         char digest[SHA384_DIGEST_SIZE];
  603 } sha384_tv_template[] = {
  604 
  605         { "abc",
  606           { 0xcb, 0x00, 0x75, 0x3f, 0x45, 0xa3, 0x5e, 0x8b,
  607             0xb5, 0xa0, 0x3d, 0x69, 0x9a, 0xc6, 0x50, 0x07,
  608             0x27, 0x2c, 0x32, 0xab, 0x0e, 0xde, 0xd1, 0x63,
  609             0x1a, 0x8b, 0x60, 0x5a, 0x43, 0xff, 0x5b, 0xed,
  610             0x80, 0x86, 0x07, 0x2b, 0xa1, 0xe7, 0xcc, 0x23,
  611             0x58, 0xba, 0xec, 0xa1, 0x34, 0xc8, 0x25, 0xa7 }
  612         },
  613         
  614         { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
  615           { 0x33, 0x91, 0xfd, 0xdd, 0xfc, 0x8d, 0xc7, 0x39,
  616             0x37, 0x07, 0xa6, 0x5b, 0x1b, 0x47, 0x09, 0x39,
  617             0x7c, 0xf8, 0xb1, 0xd1, 0x62, 0xaf, 0x05, 0xab,
  618             0xfe, 0x8f, 0x45, 0x0d, 0xe5, 0xf3, 0x6b, 0xc6,
  619             0xb0, 0x45, 0x5a, 0x85, 0x20, 0xbc, 0x4e, 0x6f,
  620             0x5f, 0xe9, 0x5b, 0x1f, 0xe3, 0xc8, 0x45, 0x2b  }
  621         },
  622         
  623         { "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
  624           "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
  625           { 0x09, 0x33, 0x0c, 0x33, 0xf7, 0x11, 0x47, 0xe8,
  626             0x3d, 0x19, 0x2f, 0xc7, 0x82, 0xcd, 0x1b, 0x47,
  627             0x53, 0x11, 0x1b, 0x17, 0x3b, 0x3b, 0x05, 0xd2,
  628             0x2f, 0xa0, 0x80, 0x86, 0xe3, 0xb0, 0xf7, 0x12,
  629             0xfc, 0xc7, 0xc7, 0x1a, 0x55, 0x7e, 0x2d, 0xb9,
  630             0x66, 0xc3, 0xe9, 0xfa, 0x91, 0x74, 0x60, 0x39  }
  631         },
  632         
  633         { "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
  634           "efghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
  635           { 0x3d, 0x20, 0x89, 0x73, 0xab, 0x35, 0x08, 0xdb,
  636             0xbd, 0x7e, 0x2c, 0x28, 0x62, 0xba, 0x29, 0x0a,
  637             0xd3, 0x01, 0x0e, 0x49, 0x78, 0xc1, 0x98, 0xdc,
  638             0x4d, 0x8f, 0xd0, 0x14, 0xe5, 0x82, 0x82, 0x3a,
  639             0x89, 0xe1, 0x6f, 0x9b, 0x2a, 0x7b, 0xbc, 0x1a,
  640             0xc9, 0x38, 0xe2, 0xd1, 0x99, 0xe8, 0xbe, 0xa4 }
  641         },
  642 };
  643 
  644 /*
  645  * SHA512 test vectors from from NIST and kerneli
  646  */
  647 #define SHA512_TEST_VECTORS     4
  648 
  649 struct sha512_testvec {
  650         char plaintext[128];
  651         char digest[SHA512_DIGEST_SIZE];
  652 } sha512_tv_template[] = {
  653 
  654         { "abc",
  655           { 0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba,
  656             0xcc, 0x41, 0x73, 0x49, 0xae, 0x20, 0x41, 0x31,
  657             0x12, 0xe6, 0xfa, 0x4e, 0x89, 0xa9, 0x7e, 0xa2,
  658             0x0a, 0x9e, 0xee, 0xe6, 0x4b, 0x55, 0xd3, 0x9a,
  659             0x21, 0x92, 0x99, 0x2a, 0x27, 0x4f, 0xc1, 0xa8,
  660             0x36, 0xba, 0x3c, 0x23, 0xa3, 0xfe, 0xeb, 0xbd,
  661             0x45, 0x4d, 0x44, 0x23, 0x64, 0x3c, 0xe8, 0x0e,
  662             0x2a, 0x9a, 0xc9, 0x4f, 0xa5, 0x4c, 0xa4, 0x9f }
  663         },
  664         
  665         { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
  666           { 0x20, 0x4a, 0x8f, 0xc6, 0xdd, 0xa8, 0x2f, 0x0a,
  667             0x0c, 0xed, 0x7b, 0xeb, 0x8e, 0x08, 0xa4, 0x16,
  668             0x57, 0xc1, 0x6e, 0xf4, 0x68, 0xb2, 0x28, 0xa8,
  669             0x27, 0x9b, 0xe3, 0x31, 0xa7, 0x03, 0xc3, 0x35,
  670             0x96, 0xfd, 0x15, 0xc1, 0x3b, 0x1b, 0x07, 0xf9,
  671             0xaa, 0x1d, 0x3b, 0xea, 0x57, 0x78, 0x9c, 0xa0,
  672             0x31, 0xad, 0x85, 0xc7, 0xa7, 0x1d, 0xd7, 0x03,
  673             0x54, 0xec, 0x63, 0x12, 0x38, 0xca, 0x34, 0x45 }
  674         },
  675         
  676         { "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
  677           "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
  678           { 0x8e, 0x95, 0x9b, 0x75, 0xda, 0xe3, 0x13, 0xda,
  679             0x8c, 0xf4, 0xf7, 0x28, 0x14, 0xfc, 0x14, 0x3f,
  680             0x8f, 0x77, 0x79, 0xc6, 0xeb, 0x9f, 0x7f, 0xa1,
  681             0x72, 0x99, 0xae, 0xad, 0xb6, 0x88, 0x90, 0x18,
  682             0x50, 0x1d, 0x28, 0x9e, 0x49, 0x00, 0xf7, 0xe4,
  683             0x33, 0x1b, 0x99, 0xde, 0xc4, 0xb5, 0x43, 0x3a,
  684             0xc7, 0xd3, 0x29, 0xee, 0xb6, 0xdd, 0x26, 0x54,
  685             0x5e, 0x96, 0xe5, 0x5b, 0x87, 0x4b, 0xe9, 0x09 }
  686         },
  687         
  688         { "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
  689           "efghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
  690           { 0x93, 0x0d, 0x0c, 0xef, 0xcb, 0x30, 0xff, 0x11,
  691             0x33, 0xb6, 0x89, 0x81, 0x21, 0xf1, 0xcf, 0x3d,
  692             0x27, 0x57, 0x8a, 0xfc, 0xaf, 0xe8, 0x67, 0x7c,
  693             0x52, 0x57, 0xcf, 0x06, 0x99, 0x11, 0xf7, 0x5d,
  694             0x8f, 0x58, 0x31, 0xb5, 0x6e, 0xbf, 0xda, 0x67,
  695             0xb2, 0x78, 0xe6, 0x6d, 0xff, 0x8b, 0x84, 0xfe,
  696             0x2b, 0x28, 0x70, 0xf7, 0x42, 0xa5, 0x80, 0xd8,
  697             0xed, 0xb4, 0x19, 0x87, 0x23, 0x28, 0x50, 0xc9
  698           }
  699         },
  700 };
  701 
  702 /*
  703  * DES test vectors.
  704  */
  705 #define DES_ENC_TEST_VECTORS            5
  706 #define DES_DEC_TEST_VECTORS            2
  707 #define DES_CBC_ENC_TEST_VECTORS        4
  708 #define DES_CBC_DEC_TEST_VECTORS        3
  709 #define DES3_EDE_ENC_TEST_VECTORS       3
  710 #define DES3_EDE_DEC_TEST_VECTORS       3
  711 
  712 struct des_tv {
  713         unsigned int len;
  714         int fail;
  715         char key[24];
  716         char iv[8];
  717         char plaintext[128];
  718         char result[128];
  719 };
  720 
  721 struct des_tv des_enc_tv_template[] = {
  722 
  723         /* From Applied Cryptography */
  724         {
  725                 8, 0,
  726                 
  727                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  728                 { 0 },
  729                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
  730                 { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d }
  731         },
  732         
  733         /* Same key, different plaintext block */
  734         {
  735                 8, 0,
  736                 
  737                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  738                 { 0 },
  739                 { 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 },
  740                 { 0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b }
  741         },
  742         
  743         /* Sbox test from NBS */
  744         {
  745                 8, 0,
  746                 
  747                 { 0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57 },
  748                 { 0 },
  749                 { 0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42 },
  750                 { 0x69, 0x0F, 0x5B, 0x0D, 0x9A, 0x26, 0x93, 0x9B }
  751         },
  752         
  753         /* Three blocks */
  754         {
  755                 24, 0,
  756                 
  757                 
  758                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  759                 
  760                 { 0 },
  761                 
  762                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
  763                   0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99,
  764                   0xca, 0xfe, 0xba, 0xbe, 0xfe, 0xed, 0xbe, 0xef },
  765 
  766                 { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
  767                   0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b,
  768                   0xb4, 0x99, 0x26, 0xf7, 0x1f, 0xe1, 0xd4, 0x90 },               
  769         },
  770         
  771         /* Weak key */
  772         {
  773                 8, 1,
  774                 
  775                 { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
  776                 { 0 },
  777                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
  778                 { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d }
  779         },
  780         
  781         /* Two blocks -- for testing encryption across pages */
  782         {
  783                 16, 0,
  784                 
  785                 
  786                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  787                 
  788                 { 0 },
  789                 
  790                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
  791                   0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 },
  792 
  793                 { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
  794                   0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b }
  795         },
  796 
  797         /* Two blocks -- for testing decryption across pages */
  798         {
  799                 16, 0,
  800                 
  801                 
  802                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  803                 
  804                 { 0 },
  805                 
  806                 { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
  807                   0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
  808                   
  809                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
  810                   0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 },
  811         },
  812         
  813         /* Four blocks -- for testing encryption with chunking */
  814         {
  815                 24, 0,
  816                 
  817                 
  818                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  819                 
  820                 { 0 },
  821                 
  822                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
  823                   0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99,
  824                   0xca, 0xfe, 0xba, 0xbe, 0xfe, 0xed, 0xbe, 0xef,
  825                   0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 },
  826 
  827                 { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
  828                   0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b,
  829                   0xb4, 0x99, 0x26, 0xf7, 0x1f, 0xe1, 0xd4, 0x90,
  830                   0xf7, 0x9c, 0x89, 0x2a, 0x33, 0x8f, 0x4a, 0x8b },
  831         },
  832         
  833 };
  834 
  835 struct des_tv des_dec_tv_template[] = {
  836 
  837         /* From Applied Cryptography */
  838         {
  839                 8, 0,
  840                 
  841                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  842                 { 0 },
  843                 { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d },
  844                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7 },
  845         },
  846         
  847         /* Sbox test from NBS */
  848         {
  849                 8, 0,
  850 
  851                 { 0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57 },
  852                 { 0 },
  853                 { 0x69, 0x0F, 0x5B, 0x0D, 0x9A, 0x26, 0x93, 0x9B },
  854                 { 0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42 }
  855         },
  856         
  857         /* Two blocks, for chunking test */
  858         {
  859                 16, 0,
  860                 
  861                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  862                 { 0 },
  863                 
  864                 { 0xc9, 0x57, 0x44, 0x25, 0x6a, 0x5e, 0xd3, 0x1d,
  865                   0x69, 0x0F, 0x5B, 0x0D, 0x9A, 0x26, 0x93, 0x9B },
  866                   
  867                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
  868                   0xa3, 0x99, 0x7b, 0xca, 0xaf, 0x69, 0xa0, 0xf5 }
  869         },
  870 
  871 };
  872 
  873 struct des_tv des_cbc_enc_tv_template[] = {
  874         /* From OpenSSL */
  875         {
  876                 24, 0,
  877                 
  878                 {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
  879                 {0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
  880                 
  881                 { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20, 
  882                   0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74, 
  883                   0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 
  884                   0x66, 0x6F, 0x72, 0x20, 0x00, 0x31, 0x00, 0x00 },
  885                   
  886                 { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4, 
  887                   0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb, 
  888                   0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68, 
  889                   0x1d, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 }
  890         },
  891 
  892         /* FIPS Pub 81 */
  893         {
  894                 8, 0,
  895                 
  896                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  897                 { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef },
  898                 { 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74 },
  899                 { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
  900                 
  901         },
  902         
  903         {
  904                 8, 0,
  905                 
  906                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  907                 { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
  908                 { 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 },
  909                 { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
  910         },
  911         
  912         {       
  913                 8, 0,
  914                 
  915                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  916                 { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
  917                 { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
  918                 { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 },
  919         },
  920         
  921         /* Copy of openssl vector for chunk testing */
  922         
  923         /* From OpenSSL */
  924         {
  925                 24, 0,
  926                 
  927                 {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
  928                 {0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
  929                 
  930                 { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20, 
  931                   0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74, 
  932                   0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 
  933                   0x66, 0x6F, 0x72, 0x20, 0x00, 0x31, 0x00, 0x00 },
  934                   
  935                 { 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4, 
  936                   0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb, 
  937                   0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68, 
  938                   0x1d, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 }
  939         },
  940 
  941         
  942 };
  943 
  944 struct des_tv des_cbc_dec_tv_template[] = {
  945 
  946         /* FIPS Pub 81 */
  947         {
  948                 8, 0,
  949                 
  950                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  951                 { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef },
  952                 { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
  953                 { 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74 },
  954         },
  955         
  956         {
  957                 8, 0,
  958                 
  959                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  960                 { 0xe5, 0xc7, 0xcd, 0xde, 0x87, 0x2b, 0xf2, 0x7c },
  961                 { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
  962                 { 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20 }, 
  963         },
  964         
  965         {
  966                 8, 0,
  967                 
  968                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  969                 { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
  970                 { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 }, 
  971                 { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
  972         },
  973         
  974         /* Copy of above, for chunk testing */
  975         
  976         {
  977                 8, 0,
  978                 
  979                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
  980                 { 0x43, 0xe9, 0x34, 0x00, 0x8c, 0x38, 0x9c, 0x0f },
  981                 { 0x68, 0x37, 0x88, 0x49, 0x9a, 0x7c, 0x05, 0xf6 }, 
  982                 { 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 },
  983         },
  984 };
  985 
  986 /*
  987  * We really need some more test vectors, especially for DES3 CBC.
  988  */
  989 struct des_tv des3_ede_enc_tv_template[] = {
  990 
  991         /* These are from openssl */
  992         {
  993                 8, 0,
  994                 
  995                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
  996                   0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
  997                   0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
  998                   
  999                 { 0 },
 1000                 
 1001                 { 0x73, 0x6F, 0x6D, 0x65, 0x64, 0x61, 0x74, 0x61  },
 1002                 
 1003                 { 0x18, 0xd7, 0x48, 0xe5, 0x63, 0x62, 0x05, 0x72 },
 1004         },
 1005         
 1006         {
 1007                 8, 0,
 1008                 
 1009                 { 0x03,0x52,0x02,0x07,0x67,0x20,0x82,0x17,
 1010                   0x86,0x02,0x87,0x66,0x59,0x08,0x21,0x98,
 1011                   0x64,0x05,0x6A,0xBD,0xFE,0xA9,0x34,0x57  },
 1012                  
 1013                 { 0 },
 1014                 
 1015                 { 0x73,0x71,0x75,0x69,0x67,0x67,0x6C,0x65  },
 1016                 
 1017                 { 0xc0,0x7d,0x2a,0x0f,0xa5,0x66,0xfa,0x30  }
 1018         },
 1019         
 1020 
 1021         {
 1022                 8, 0,
 1023                 
 1024                 { 0x10,0x46,0x10,0x34,0x89,0x98,0x80,0x20,
 1025                   0x91,0x07,0xD0,0x15,0x89,0x19,0x01,0x01,
 1026                   0x19,0x07,0x92,0x10,0x98,0x1A,0x01,0x01  },
 1027                   
 1028                 { 0 },
 1029                           
 1030                 { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  },
 1031                 
 1032                 { 0xe1,0xef,0x62,0xc3,0x32,0xfe,0x82,0x5b  }    
 1033         },
 1034 };
 1035 
 1036 struct des_tv des3_ede_dec_tv_template[] = {
 1037 
 1038         /* These are from openssl */
 1039         {
 1040                 8, 0,
 1041                 
 1042                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
 1043                   0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
 1044                   0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
 1045                   
 1046                 { 0 },
 1047                 
 1048                 
 1049                 { 0x18, 0xd7, 0x48, 0xe5, 0x63, 0x62, 0x05, 0x72 },
 1050                 
 1051                 { 0x73, 0x6F, 0x6D, 0x65, 0x64, 0x61, 0x74, 0x61  },
 1052         },
 1053         
 1054         {
 1055                 8, 0,
 1056                 
 1057                 { 0x03,0x52,0x02,0x07,0x67,0x20,0x82,0x17,
 1058                   0x86,0x02,0x87,0x66,0x59,0x08,0x21,0x98,
 1059                   0x64,0x05,0x6A,0xBD,0xFE,0xA9,0x34,0x57  },
 1060                  
 1061                 { 0 },
 1062                 
 1063                 { 0xc0,0x7d,0x2a,0x0f,0xa5,0x66,0xfa,0x30  },
 1064                 
 1065                 { 0x73,0x71,0x75,0x69,0x67,0x67,0x6C,0x65  },
 1066                 
 1067         },
 1068         
 1069 
 1070         {
 1071                 8, 0,
 1072                 
 1073                 { 0x10,0x46,0x10,0x34,0x89,0x98,0x80,0x20,
 1074                   0x91,0x07,0xD0,0x15,0x89,0x19,0x01,0x01,
 1075                   0x19,0x07,0x92,0x10,0x98,0x1A,0x01,0x01  },
 1076                   
 1077                 { 0 },
 1078                           
 1079                 { 0xe1,0xef,0x62,0xc3,0x32,0xfe,0x82,0x5b  },
 1080                 
 1081                 { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  },
 1082         },
 1083 };
 1084 
 1085 /*
 1086  * Blowfish test vectors.
 1087  */
 1088 #define BF_ENC_TEST_VECTORS     6
 1089 #define BF_DEC_TEST_VECTORS     6
 1090 #define BF_CBC_ENC_TEST_VECTORS 1
 1091 #define BF_CBC_DEC_TEST_VECTORS 1
 1092 
 1093 struct bf_tv {
 1094         unsigned int keylen;
 1095         unsigned int plen;
 1096         unsigned int rlen;
 1097         int fail;
 1098         char key[56];
 1099         char iv[8];
 1100         char plaintext[32];
 1101         char result[32];
 1102 };
 1103 
 1104 struct bf_tv bf_enc_tv_template[] = {
 1105 
 1106         /* DES test vectors from OpenSSL */
 1107         {
 1108                 8, 8, 8, 0,
 1109                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
 1110                 { 0 },
 1111                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1112                 { 0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78 },
 1113         },
 1114         
 1115         {
 1116                 8, 8, 8, 0,
 1117                 { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E,  },
 1118                 { 0 },
 1119                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
 1120                 { 0xA7, 0x90, 0x79, 0x51, 0x08, 0xEA, 0x3C, 0xAE },
 1121         },
 1122         
 1123         {
 1124                 8, 8, 8, 0,
 1125                 { 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87, },
 1126                 { 0 },
 1127                 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 },
 1128                 { 0xE8, 0x7A, 0x24, 0x4E, 0x2C, 0xC8, 0x5E, 0x82 }
 1129         },
 1130         
 1131         /* Vary the keylength... */
 1132         
 1133         {
 1134                 16, 8, 8, 0,
 1135                 { 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87,
 1136                   0x78, 0x69, 0x5A, 0x4B, 0x3C, 0x2D, 0x1E, 0x0F },
 1137                 { 0 },
 1138                 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 },
 1139                 { 0x93, 0x14, 0x28, 0x87, 0xEE, 0x3B, 0xE1, 0x5C }
 1140         },
 1141         
 1142         {
 1143                 21, 8, 8, 0,
 1144                 { 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87,
 1145                   0x78, 0x69, 0x5A, 0x4B, 0x3C, 0x2D, 0x1E, 0x0F,
 1146                   0x00, 0x11, 0x22, 0x33, 0x44 },
 1147                 { 0 },
 1148                 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 },
 1149                 { 0xE6, 0xF5, 0x1E, 0xD7, 0x9B, 0x9D, 0xB2, 0x1F }
 1150         },
 1151         
 1152         /* Generated with bf488 */
 1153         {
 1154                 56, 8, 8, 0,
 1155                 { 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87,
 1156                   0x78, 0x69, 0x5A, 0x4B, 0x3C, 0x2D, 0x1E, 0x0F,
 1157                   0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
 1158                   0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F, 
 1159                   0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76, 
 1160                   0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E, 
 1161                   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
 1162                   { 0 },
 1163                   { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 },
 1164                   { 0xc0, 0x45, 0x04, 0x01, 0x2e, 0x4e, 0x1f, 0x53 }
 1165         }
 1166         
 1167 };
 1168 
 1169 struct bf_tv bf_dec_tv_template[] = {
 1170 
 1171         /* DES test vectors from OpenSSL */
 1172         {
 1173                 8, 8, 8, 0,
 1174                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
 1175                 { 0 },
 1176                 { 0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78 },
 1177                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
 1178         },
 1179         
 1180         {
 1181                 8, 8, 8, 0,
 1182                 { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E,  },
 1183                 { 0 },
 1184                 { 0xA7, 0x90, 0x79, 0x51, 0x08, 0xEA, 0x3C, 0xAE },
 1185                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }
 1186         },
 1187         
 1188         {
 1189                 8, 8, 8, 0,
 1190                 { 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87, },
 1191                 { 0 },
 1192                 { 0xE8, 0x7A, 0x24, 0x4E, 0x2C, 0xC8, 0x5E, 0x82 },
 1193                 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }
 1194         },
 1195         
 1196         /* Vary the keylength... */
 1197         
 1198         {
 1199                 16, 8, 8, 0,
 1200                 { 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87,
 1201                   0x78, 0x69, 0x5A, 0x4B, 0x3C, 0x2D, 0x1E, 0x0F },
 1202                 { 0 },
 1203                 { 0x93, 0x14, 0x28, 0x87, 0xEE, 0x3B, 0xE1, 0x5C },
 1204                 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }
 1205         },
 1206         
 1207         {
 1208                 21, 8, 8, 0,
 1209                 { 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87,
 1210                   0x78, 0x69, 0x5A, 0x4B, 0x3C, 0x2D, 0x1E, 0x0F,
 1211                   0x00, 0x11, 0x22, 0x33, 0x44 },
 1212                 { 0 },
 1213                 { 0xE6, 0xF5, 0x1E, 0xD7, 0x9B, 0x9D, 0xB2, 0x1F },
 1214                 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }
 1215         },
 1216         
 1217         /* Generated with bf488, using OpenSSL, Libgcrypt and Nettle */
 1218         {
 1219                 56, 8, 8, 0,
 1220                 { 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87,
 1221                   0x78, 0x69, 0x5A, 0x4B, 0x3C, 0x2D, 0x1E, 0x0F,
 1222                   0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
 1223                   0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F, 
 1224                   0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76, 
 1225                   0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E, 
 1226                   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
 1227                 { 0 },
 1228                 { 0xc0, 0x45, 0x04, 0x01, 0x2e, 0x4e, 0x1f, 0x53 },
 1229                 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }
 1230         }
 1231 };
 1232 
 1233 struct bf_tv bf_cbc_enc_tv_template[] = {
 1234 
 1235         /* From OpenSSL */
 1236         {
 1237                 16, 32, 32, 0,
 1238                 
 1239                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
 1240                   0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87 },
 1241                   
 1242                 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 },
 1243                 
 1244                 { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
 1245                   0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
 1246                   0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20,
 1247                   0x66, 0x6F, 0x72, 0x20, 0x00, 0x00, 0x00, 0x00 },
 1248                   
 1249                 { 0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6,
 1250                   0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93,
 1251                   0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9,
 1252                   0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC }
 1253         },
 1254 };
 1255 
 1256 struct bf_tv bf_cbc_dec_tv_template[] = {
 1257 
 1258         /* From OpenSSL */
 1259         {
 1260                 16, 32, 32, 0,
 1261                 
 1262                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
 1263                   0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87 },
 1264                   
 1265                 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 },
 1266                 
 1267                 { 0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6,
 1268                   0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93,
 1269                   0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9,
 1270                   0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC },
 1271                   
 1272                 { 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
 1273                   0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
 1274                   0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20,
 1275                   0x66, 0x6F, 0x72, 0x20, 0x00, 0x00, 0x00, 0x00 }
 1276         },
 1277 };
 1278 
 1279 /*
 1280  * Twofish test vectors.
 1281  */
 1282 #define TF_ENC_TEST_VECTORS             3
 1283 #define TF_DEC_TEST_VECTORS             3
 1284 #define TF_CBC_ENC_TEST_VECTORS         4
 1285 #define TF_CBC_DEC_TEST_VECTORS         4
 1286 
 1287 struct tf_tv {
 1288         unsigned int keylen;
 1289         unsigned int plen;
 1290         unsigned int rlen;
 1291         int fail;
 1292         char key[32];
 1293         char iv[16];
 1294         char plaintext[48];
 1295         char result[48];
 1296 };
 1297 
 1298 struct tf_tv tf_enc_tv_template[] = {
 1299         {
 1300                 16, 16, 16, 0,
 1301                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1302                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1303                 { 0 },
 1304                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1305                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1306                 { 0x9F, 0x58, 0x9F, 0x5C, 0xF6, 0x12, 0x2C, 0x32,
 1307                   0xB6, 0xBF, 0xEC, 0x2F, 0x2A, 0xE8, 0xC3, 0x5A }
 1308         },
 1309         {
 1310                 24, 16, 16, 0,
 1311                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
 1312                   0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
 1313                   0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 },
 1314                 { 0 },
 1315                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1316                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1317                 { 0xCF, 0xD1, 0xD2, 0xE5, 0xA9, 0xBE, 0x9C, 0xDF,
 1318                   0x50, 0x1F, 0x13, 0xB8, 0x92, 0xBD, 0x22, 0x48 }
 1319         },
 1320         {       
 1321                 32, 16, 16, 0,
 1322                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
 1323                   0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
 1324                   0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
 1325                   0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF },
 1326                 { 0 },
 1327                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1328                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1329                 { 0x37, 0x52, 0x7B, 0xE0, 0x05, 0x23, 0x34, 0xB8,
 1330                   0x9F, 0x0C, 0xFC, 0xCA, 0xE8, 0x7C, 0xFA, 0x20 }
 1331         },
 1332 };
 1333 
 1334 struct tf_tv tf_dec_tv_template[] = {
 1335         {
 1336                 16, 16, 16, 0,
 1337                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1338                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1339                 { 0 },
 1340                 { 0x9F, 0x58, 0x9F, 0x5C, 0xF6, 0x12, 0x2C, 0x32,
 1341                   0xB6, 0xBF, 0xEC, 0x2F, 0x2A, 0xE8, 0xC3, 0x5A },
 1342                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1343                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },  
 1344         },
 1345         {
 1346                 24, 16, 16, 0,
 1347                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
 1348                   0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
 1349                   0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 },
 1350                 { 0 },
 1351                 { 0xCF, 0xD1, 0xD2, 0xE5, 0xA9, 0xBE, 0x9C, 0xDF,
 1352                   0x50, 0x1F, 0x13, 0xB8, 0x92, 0xBD, 0x22, 0x48 },
 1353                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1354                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1355         },
 1356         {       
 1357                 32, 16, 16, 0,
 1358                 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
 1359                   0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
 1360                   0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
 1361                   0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF },
 1362                 { 0 },
 1363                 { 0x37, 0x52, 0x7B, 0xE0, 0x05, 0x23, 0x34, 0xB8,
 1364                   0x9F, 0x0C, 0xFC, 0xCA, 0xE8, 0x7C, 0xFA, 0x20 },
 1365                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1366                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1367         },
 1368 };
 1369 
 1370 struct tf_tv tf_cbc_enc_tv_template[] = {
 1371         /* Generated with Nettle */
 1372         {
 1373                 16, 16, 16, 0,
 1374                 
 1375                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1376                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1377                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1378                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1379                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1380                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1381                 { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
 1382                   0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
 1383         },
 1384         
 1385         {
 1386                 16, 16, 16, 0,
 1387                 
 1388                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1389                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1390                 { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
 1391                   0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
 1392                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1393                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1394                 { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
 1395                   0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19 },
 1396         },
 1397         
 1398         {
 1399                 16, 16, 16, 0,
 1400                 
 1401                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1402                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1403                 { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
 1404                   0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19 },
 1405                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1406                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1407                 { 0x05, 0xef, 0x8c, 0x61, 0xa8, 0x11, 0x58, 0x26,
 1408                   0x34, 0xba, 0x5c, 0xb7, 0x10, 0x6a, 0xa6, 0x41 },
 1409         },
 1410         
 1411         {
 1412                 16, 48, 48, 0,
 1413                 
 1414                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1415                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1416                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1417                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1418                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1419                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1420                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1421                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1422                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1423                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1424                 { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
 1425                   0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a,
 1426                   0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
 1427                   0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19,
 1428                   0x05, 0xef, 0x8c, 0x61, 0xa8, 0x11, 0x58, 0x26,
 1429                   0x34, 0xba, 0x5c, 0xb7, 0x10, 0x6a, 0xa6, 0x41 },
 1430         },
 1431 };
 1432 
 1433 struct tf_tv tf_cbc_dec_tv_template[] = {
 1434         /* Reverse of the first four above */
 1435         {
 1436                 16, 16, 16, 0,
 1437                 
 1438                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1439                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1440                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1441                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1442                 { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
 1443                   0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },               
 1444                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1445                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1446         },
 1447         
 1448         {
 1449                 16, 16, 16, 0,
 1450                 
 1451                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1452                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1453                 { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
 1454                   0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a },
 1455                 { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
 1456                   0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19 },
 1457                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1458                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },  
 1459         },
 1460         
 1461         {
 1462                 16, 16, 16, 0,
 1463                 
 1464                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1465                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1466                 { 0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
 1467                   0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19 },
 1468                 { 0x05, 0xef, 0x8c, 0x61, 0xa8, 0x11, 0x58, 0x26,
 1469                   0x34, 0xba, 0x5c, 0xb7, 0x10, 0x6a, 0xa6, 0x41 },
 1470                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1471                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },  
 1472         },
 1473         
 1474         {
 1475                 16, 48, 48, 0,
 1476                 
 1477                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1478                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1479                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1480                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1481                 { 0x9f, 0x58, 0x9f, 0x5c, 0xf6, 0x12, 0x2c, 0x32,
 1482                   0xb6, 0xbf, 0xec, 0x2f, 0x2a, 0xe8, 0xc3, 0x5a,
 1483                   0xd4, 0x91, 0xdb, 0x16, 0xe7, 0xb1, 0xc3, 0x9e,
 1484                   0x86, 0xcb, 0x08, 0x6b, 0x78, 0x9f, 0x54, 0x19,
 1485                   0x05, 0xef, 0x8c, 0x61, 0xa8, 0x11, 0x58, 0x26,
 1486                   0x34, 0xba, 0x5c, 0xb7, 0x10, 0x6a, 0xa6, 0x41 },
 1487                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1488                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1489                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1490                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1491                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1492                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1493         },
 1494 };
 1495 
 1496 /*
 1497  * Serpent test vectors.  These are backwards because Serpent writes
 1498  * octect sequences in right-to-left mode.
 1499  */
 1500 #define SERPENT_ENC_TEST_VECTORS        4
 1501 #define SERPENT_DEC_TEST_VECTORS        4
 1502 
 1503 struct serpent_tv {
 1504         unsigned int keylen, fail;
 1505         u8 key[32], plaintext[16], result[16];
 1506 };
 1507 
 1508 struct serpent_tv serpent_enc_tv_template[] = 
 1509 {
 1510         {
 1511                 0, 0,
 1512                 { 0 },
 1513                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1514                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 1515                 { 0x12, 0x07, 0xfc, 0xce, 0x9b, 0xd0, 0xd6, 0x47,
 1516                   0x6a, 0xe9, 0x8f, 0xbe, 0xd1, 0x43, 0xa0, 0xe2 }
 1517         },
 1518         {
 1519                 16, 0,
 1520                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1521                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 1522                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1523                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 1524                 { 0x4c, 0x7d, 0x8a, 0x32, 0x80, 0x72, 0xa2, 0x2c,
 1525                   0x82, 0x3e, 0x4a, 0x1f, 0x3a, 0xcd, 0xa1, 0x6d }
 1526         },
 1527         {
 1528                 32, 0,
 1529                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1530                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 1531                   0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 1532                   0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
 1533                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1534                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 1535                 { 0xde, 0x26, 0x9f, 0xf8, 0x33, 0xe4, 0x32, 0xb8,
 1536                   0x5b, 0x2e, 0x88, 0xd2, 0x70, 0x1c, 0xe7, 0x5c }
 1537         },
 1538         {
 1539                 16, 0,
 1540                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1541                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 },
 1542                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1543                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 1544                 { 0xdd, 0xd2, 0x6b, 0x98, 0xa5, 0xff, 0xd8, 0x2c,
 1545                   0x05, 0x34, 0x5a, 0x9d, 0xad, 0xbf, 0xaf, 0x49}
 1546         }
 1547 };
 1548 
 1549 struct serpent_tv serpent_dec_tv_template[] = 
 1550 {
 1551         {
 1552                 0, 0,
 1553                 { 0 },
 1554                 { 0x12, 0x07, 0xfc, 0xce, 0x9b, 0xd0, 0xd6, 0x47,
 1555                   0x6a, 0xe9, 0x8f, 0xbe, 0xd1, 0x43, 0xa0, 0xe2 },
 1556                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1557                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 1558 
 1559         },
 1560         {
 1561                 16, 0,
 1562                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1563                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 1564                 { 0x4c, 0x7d, 0x8a, 0x32, 0x80, 0x72, 0xa2, 0x2c,
 1565                   0x82, 0x3e, 0x4a, 0x1f, 0x3a, 0xcd, 0xa1, 0x6d },
 1566                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1567                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 1568         },
 1569         {
 1570                 32, 0,
 1571                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1572                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 1573                   0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 1574                   0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
 1575 
 1576                 { 0xde, 0x26, 0x9f, 0xf8, 0x33, 0xe4, 0x32, 0xb8,
 1577                   0x5b, 0x2e, 0x88, 0xd2, 0x70, 0x1c, 0xe7, 0x5c },
 1578                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1579                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 1580         },
 1581         {
 1582                 16, 0,
 1583                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1584                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 },
 1585                 { 0xdd, 0xd2, 0x6b, 0x98, 0xa5, 0xff, 0xd8, 0x2c,
 1586                   0x05, 0x34, 0x5a, 0x9d, 0xad, 0xbf, 0xaf, 0x49},
 1587                 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 1588                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },  
 1589         }
 1590 };
 1591 
 1592 /*
 1593  * AES test vectors.
 1594  */
 1595 #define AES_ENC_TEST_VECTORS 3
 1596 #define AES_DEC_TEST_VECTORS 3
 1597 
 1598 struct aes_tv {
 1599         unsigned int keylen;
 1600         unsigned int plen;
 1601         unsigned int rlen;
 1602         int fail;
 1603         char key[32];
 1604         char iv[8];
 1605         char plaintext[16];
 1606         char result[16];
 1607 };
 1608 
 1609 struct aes_tv aes_enc_tv_template[] = { 
 1610         /* From FIPS-197 */
 1611         {
 1612                 16, 16, 16, 0,
 1613                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
 1614                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 1615                 { 0 },
 1616                 { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
 1617                   0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
 1618                 { 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30,
 1619                   0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a },
 1620         },
 1621         {
 1622                 24, 16, 16, 0,
 1623                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1624                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 1625                   0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 },
 1626                 { 0 },
 1627                 { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 
 1628                   0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
 1629                 { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0,
 1630                   0x6e, 0xaf, 0x70, 0xa0, 0xec, 0x0d, 0x71, 0x91 },
 1631         },
 1632         {
 1633                 32, 16, 16, 0,
 1634                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1635                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 1636                   0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 1637                   0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
 1638                 { 0 },
 1639                 { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 
 1640                   0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
 1641                 { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf,
 1642                   0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89 },
 1643         },
 1644 };
 1645 
 1646 struct aes_tv aes_dec_tv_template[] = { 
 1647         /* From FIPS-197 */
 1648         {
 1649                 16, 16, 16, 0,
 1650                 
 1651                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
 1652                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 1653                 { 0 },
 1654                 { 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30,
 1655                   0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a },
 1656                 { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
 1657                   0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
 1658         },
 1659         
 1660         {
 1661                 24, 16, 16, 0,
 1662                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1663                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 1664                   0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 },
 1665                 { 0 },
 1666                 { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0,
 1667                   0x6e, 0xaf, 0x70, 0xa0, 0xec, 0x0d, 0x71, 0x91 },
 1668                 { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 
 1669                   0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },  
 1670         },
 1671         {
 1672                 32, 16, 16, 0,
 1673                 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 1674                   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 1675                   0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 1676                   0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
 1677                 { 0 },
 1678                 { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf,
 1679                   0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89 },
 1680                 { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 
 1681                   0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff },
 1682         },
 1683 };
 1684 
 1685 /*
 1686  * Compression stuff.
 1687  */
 1688 #define COMP_BUF_SIZE           512
 1689 
 1690 struct comp_testvec {
 1691         int inlen, outlen;
 1692         char input[COMP_BUF_SIZE];
 1693         char output[COMP_BUF_SIZE];
 1694 };
 1695 
 1696 /*
 1697  * Deflate test vectors (null-terminated strings).
 1698  * Params: winbits=11, Z_DEFAULT_COMPRESSION, MAX_MEM_LEVEL.
 1699  */
 1700 #define DEFLATE_COMP_TEST_VECTORS 2
 1701 #define DEFLATE_DECOMP_TEST_VECTORS 2
 1702 
 1703 struct comp_testvec deflate_comp_tv_template[] = {
 1704         {
 1705           70, 38,
 1706           
 1707           "Join us now and share the software "
 1708           "Join us now and share the software ",
 1709 
 1710           { 0xf3, 0xca, 0xcf, 0xcc, 0x53, 0x28, 0x2d, 0x56,
 1711             0xc8, 0xcb, 0x2f, 0x57, 0x48, 0xcc, 0x4b, 0x51,
 1712             0x28, 0xce, 0x48, 0x2c, 0x4a, 0x55, 0x28, 0xc9,
 1713             0x48, 0x55, 0x28, 0xce, 0x4f, 0x2b, 0x29, 0x07,
 1714             0x71, 0xbc, 0x08, 0x2b, 0x01, 0x00 
 1715           },
 1716         },
 1717           
 1718         {
 1719           191, 122,
 1720           
 1721           "This document describes a compression method based on the DEFLATE"
 1722           "compression algorithm.  This document defines the application of "
 1723           "the DEFLATE algorithm to the IP Payload Compression Protocol.",
 1724           
 1725           { 0x5d, 0x8d, 0x31, 0x0e, 0xc2, 0x30, 0x10, 0x04,
 1726             0xbf, 0xb2, 0x2f, 0xc8, 0x1f, 0x10, 0x04, 0x09,
 1727             0x89, 0xc2, 0x85, 0x3f, 0x70, 0xb1, 0x2f, 0xf8,
 1728             0x24, 0xdb, 0x67, 0xd9, 0x47, 0xc1, 0xef, 0x49,
 1729             0x68, 0x12, 0x51, 0xae, 0x76, 0x67, 0xd6, 0x27,
 1730             0x19, 0x88, 0x1a, 0xde, 0x85, 0xab, 0x21, 0xf2,
 1731             0x08, 0x5d, 0x16, 0x1e, 0x20, 0x04, 0x2d, 0xad,
 1732             0xf3, 0x18, 0xa2, 0x15, 0x85, 0x2d, 0x69, 0xc4,
 1733             0x42, 0x83, 0x23, 0xb6, 0x6c, 0x89, 0x71, 0x9b,
 1734             0xef, 0xcf, 0x8b, 0x9f, 0xcf, 0x33, 0xca, 0x2f,
 1735             0xed, 0x62, 0xa9, 0x4c, 0x80, 0xff, 0x13, 0xaf,
 1736             0x52, 0x37, 0xed, 0x0e, 0x52, 0x6b, 0x59, 0x02,
 1737             0xd9, 0x4e, 0xe8, 0x7a, 0x76, 0x1d, 0x02, 0x98,
 1738             0xfe, 0x8a, 0x87, 0x83, 0xa3, 0x4f, 0x56, 0x8a,
 1739             0xb8, 0x9e, 0x8e, 0x5c, 0x57, 0xd3, 0xa0, 0x79,
 1740             0xfa, 0x02 },
 1741         },
 1742 };
 1743 
 1744 struct comp_testvec deflate_decomp_tv_template[] = {
 1745         {
 1746           122, 191,
 1747           
 1748           { 0x5d, 0x8d, 0x31, 0x0e, 0xc2, 0x30, 0x10, 0x04,
 1749             0xbf, 0xb2, 0x2f, 0xc8, 0x1f, 0x10, 0x04, 0x09,
 1750             0x89, 0xc2, 0x85, 0x3f, 0x70, 0xb1, 0x2f, 0xf8,
 1751             0x24, 0xdb, 0x67, 0xd9, 0x47, 0xc1, 0xef, 0x49,
 1752             0x68, 0x12, 0x51, 0xae, 0x76, 0x67, 0xd6, 0x27,
 1753             0x19, 0x88, 0x1a, 0xde, 0x85, 0xab, 0x21, 0xf2,
 1754             0x08, 0x5d, 0x16, 0x1e, 0x20, 0x04, 0x2d, 0xad,
 1755             0xf3, 0x18, 0xa2, 0x15, 0x85, 0x2d, 0x69, 0xc4,
 1756             0x42, 0x83, 0x23, 0xb6, 0x6c, 0x89, 0x71, 0x9b,
 1757             0xef, 0xcf, 0x8b, 0x9f, 0xcf, 0x33, 0xca, 0x2f,
 1758             0xed, 0x62, 0xa9, 0x4c, 0x80, 0xff, 0x13, 0xaf,
 1759             0x52, 0x37, 0xed, 0x0e, 0x52, 0x6b, 0x59, 0x02,
 1760             0xd9, 0x4e, 0xe8, 0x7a, 0x76, 0x1d, 0x02, 0x98,
 1761             0xfe, 0x8a, 0x87, 0x83, 0xa3, 0x4f, 0x56, 0x8a,
 1762             0xb8, 0x9e, 0x8e, 0x5c, 0x57, 0xd3, 0xa0, 0x79,
 1763             0xfa, 0x02 },
 1764             
 1765             "This document describes a compression method based on the DEFLATE"
 1766             "compression algorithm.  This document defines the application of "
 1767             "the DEFLATE algorithm to the IP Payload Compression Protocol.",
 1768         },
 1769         
 1770         {
 1771           38, 70,
 1772           
 1773           { 0xf3, 0xca, 0xcf, 0xcc, 0x53, 0x28, 0x2d, 0x56,
 1774             0xc8, 0xcb, 0x2f, 0x57, 0x48, 0xcc, 0x4b, 0x51,
 1775             0x28, 0xce, 0x48, 0x2c, 0x4a, 0x55, 0x28, 0xc9,
 1776             0x48, 0x55, 0x28, 0xce, 0x4f, 0x2b, 0x29, 0x07,
 1777             0x71, 0xbc, 0x08, 0x2b, 0x01, 0x00
 1778           },
 1779           
 1780           "Join us now and share the software "
 1781           "Join us now and share the software ",
 1782         },
 1783 };
 1784 
 1785 #endif  /* _CRYPTO_TCRYPT_H */
Cache object: 332ea8df236a84fb546943b6b9cb6b6e
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/crypto/tcrypt.h

FreeBSD/Linux Kernel Cross Reference
sys/crypto/tcrypt.h
