tests/crypto.c

   1 /* crypto.c     Shishi crypto self tests.
   2  * Copyright (C) 2002, 2003  Simon Josefsson
   3  *
   4  * This file is part of Shishi.
   5  *
   6  * Shishi is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * Shishi is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with Shishi; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "utils.c"
  23 #include <shishi.h>
  24 #include <pkcs5.h>
  25
  26 struct drdk
  27 {
  28   int type;
  29   char *key;
  30   int nusage;
  31   char *usage;
  32   char *dr;
  33   char *dk;
  34 }
  35 drdk[] =
  36 {
  37   {
  38   SHISHI_DES3_CBC_HMAC_SHA1_KD,
  39       "\xd3\xf8\x29\x8c\xcb\x16\x64\x38\xdc\xb9\xb9\x3e"
  40       "\xe5\xa7\x62\x92\x86\xa4\x91\xf8\x38\xf8\x02\xfb",
  41       8,
  42       "kerberos",
  43       "\x22\x70\xdb\x56\x5d\x2a\x3d\x64\xcf\xbf"
  44       "\xdc\x53\x05\xd4\xf7\x78\xa6\xde\x42\xd9\xda",
  45       "\x23\x70\xda\x57\x5d\x2a\x3d\xa8\x64\xce\xbf\xdc"
  46       "\x52\x04\xd5\x6d\xf7\x79\xa7\xdf\x43\xd9\xda\x43",}
  47   ,
  48   {
  49   SHISHI_DES3_CBC_HMAC_SHA1_KD,
  50       "\xdc\xe0\x6b\x1f\x64\xc8\x57\xa1\x1c\x3d\xb5\x7c"
  51       "\x51\x89\x9b\x2c\xc1\x79\x10\x08\xce\x97\x3b\x92",
  52       5,
  53       "\x00\x00\x00\x01\x55",
  54       "\x93\x50\x79\xd1\x44\x90\xa7\x5c\x30\x93"
  55       "\xc4\xa6\xe8\xc3\xb0\x49\xc7\x1e\x6e\xe7\x05",
  56       "\x92\x51\x79\xd0\x45\x91\xa7\x9b\x5d\x31\x92\xc4"
  57       "\xa7\xe9\xc2\x89\xb0\x49\xc7\x1f\x6e\xe6\x04\xcd"}
  58   ,
  59   {
  60   SHISHI_DES3_CBC_HMAC_SHA1_KD,
  61       "\x5e\x13\xd3\x1c\x70\xef\x76\x57\x46\x57\x85\x31"
  62       "\xcb\x51\xc1\x5b\xf1\x1c\xa8\x2c\x97\xce\xe9\xf2",
  63       5,
  64       "\x00\x00\x00\x01\xaa",
  65       "\x9f\x58\xe5\xa0\x47\xd8\x94\x10\x1c\x46"
  66       "\x98\x45\xd6\x7a\xe3\xc5\x24\x9e\xd8\x12\xf2",
  67       "\x9e\x58\xe5\xa1\x46\xd9\x94\x2a\x10\x1c\x46\x98"
  68       "\x45\xd6\x7a\x20\xe3\xc4\x25\x9e\xd9\x13\xf2\x07",}
  69   ,
  70   {
  71   SHISHI_DES3_CBC_HMAC_SHA1_KD,
  72       "\x98\xe6\xfd\x8a\x04\xa4\xb6\x85\x9b\x75\xa1\x76"
  73       "\x54\x0b\x97\x52\xba\xd3\xec\xd6\x10\xa2\x52\xbc",
  74       5,
  75       "\x00\x00\x00\x01\x55",
  76       "\x12\xff\xf9\x0c\x77\x3f\x95\x6d\x13\xfc"
  77       "\x2c\xa0\xd0\x84\x03\x49\xdb\xd3\x99\x08\xeb",
  78       "\x13\xfe\xf8\x0d\x76\x3e\x94\xec\x6d\x13\xfd\x2c"
  79       "\xa1\xd0\x85\x07\x02\x49\xda\xd3\x98\x08\xea\xbf",}
  80   ,
  81   {
  82   SHISHI_DES3_CBC_HMAC_SHA1_KD,
  83       "\x62\x2a\xec\x25\xa2\xfe\x2c\xad\x70\x94\x68\x0b"
  84       "\x7c\x64\x94\x02\x80\x08\x4c\x1a\x7c\xec\x92\xb5",
  85       5,
  86       "\x00\x00\x00\x01\xaa",
  87       "\xf8\xde\xbf\x05\xb0\x97\xe7\xdc\x06\x03"
  88       "\x68\x6a\xca\x35\xd9\x1f\xd9\xa5\x51\x6a\x70",
  89       "\xf8\xdf\xbf\x04\xb0\x97\xe6\xd9\xdc\x07\x02\x68"
  90       "\x6b\xcb\x34\x89\xd9\x1f\xd9\xa4\x51\x6b\x70\x3e",}
  91   ,
  92   {
  93   SHISHI_DES3_CBC_HMAC_SHA1_KD,
  94       "\xc1\x08\x16\x49\xad\xa7\x43\x62\xe6\xa1\x45\x9d"
  95       "\x01\xdf\xd3\x0d\x67\xc2\x23\x4c\x94\x07\x04\xda",
  96       5,
  97       "\x00\x00\x00\x01\x55",
  98       "\x34\x80\x56\xec\x98\xfc\xc5\x17\x17\x1d"
  99       "\x2b\x4d\x7a\x94\x93\xaf\x48\x2d\x99\x91\x75",
 100       "\x34\x80\x57\xec\x98\xfd\xc4\x80\x16\x16\x1c\x2a"
 101       "\x4c\x7a\x94\x3e\x92\xae\x49\x2c\x98\x91\x75\xf7",}
 102   ,
 103   {
 104   SHISHI_DES3_CBC_HMAC_SHA1_KD,
 105       "\x5d\x15\x4a\xf2\x38\xf4\x67\x13\x15\x57\x19\xd5"
 106       "\x5e\x2f\x1f\x79\x0d\xd6\x61\xf2\x79\xa7\x91\x7c",
 107       5,
 108       "\x00\x00\x00\x01\xaa",
 109       "\xa8\x81\x8b\xc3\x67\xda\xda\xcb\xe9\xa6"
 110       "\xc8\x46\x27\xfb\x60\xc2\x94\xb0\x12\x15\xe5",
 111       "\xa8\x80\x8a\xc2\x67\xda\xda\x3d\xcb\xe9\xa7\xc8"
 112       "\x46\x26\xfb\xc7\x61\xc2\x94\xb0\x13\x15\xe5\xc1",}
 113   ,
 114   {
 115   SHISHI_DES3_CBC_HMAC_SHA1_KD,
 116       "\x79\x85\x62\xe0\x49\x85\x2f\x57\xdc\x8c\x34\x3b"
 117       "\xa1\x7f\x2c\xa1\xd9\x73\x94\xef\xc8\xad\xc4\x43",
 118       5,
 119       "\x00\x00\x00\x01\x55",
 120       "\xc8\x13\xf8\x8b\x3b\xe2\xb2\xf7\x54\x24"
 121       "\xce\x91\x75\xfb\xc8\x48\x3b\x88\xc8\x71\x3a",
 122       "\xc8\x13\xf8\x8a\x3b\xe3\xb3\x34\xf7\x54\x25\xce"
 123       "\x91\x75\xfb\xe3\xc8\x49\x3b\x89\xc8\x70\x3b\x49",}
 124   ,
 125   {
 126   SHISHI_DES3_CBC_HMAC_SHA1_KD,
 127       "\x26\xdc\xe3\x34\xb5\x45\x29\x2f\x2f\xea\xb9\xa8"
 128       "\x70\x1a\x89\xa4\xb9\x9e\xb9\x94\x2c\xec\xd0\x16",
 129       5,
 130       "\x00\x00\x00\x01\xaa",
 131       "\xf5\x8e\xfc\x6f\x83\xf9\x3e\x55\xe6\x95"
 132       "\xfd\x25\x2c\xf8\xfe\x59\xf7\xd5\xba\x37\xec",
 133       "\xf4\x8f\xfd\x6e\x83\xf8\x3e\x73\x54\xe6\x94\xfd"
 134       "\x25\x2c\xf8\x3b\xfe\x58\xf7\xd5\xba\x37\xec\x5d",}
 135 };
 136
 137 struct nfold
 138 {
 139   int n;
 140   char *in;
 141   char *out;
 142 }
 143 nfold[] =
 144 {
 145   {
 146   64, "012345", "\xBE\x07\x26\x31\x27\x6B\x19\x55"}
 147   ,
 148   {
 149   56, "password", "\x78\xA0\x7B\x6C\xAF\x85\xFA"}
 150   ,
 151   {
 152   64, "Rough Consensus, and Running Code",
 153       "\xBB\x6E\xD3\x08\x70\xB7\xF0\xE0"}
 154   ,
 155   {
 156   168, "password",
 157       "\x59\xE4\xA8\xCA\x7C\x03\x85\xC3\xC3\x7B"
 158       "\x3F\x6D\x20\x00\x24\x7C\xB6\xE6\xBD\x5B\x3E"}
 159   ,
 160   {
 161   192, "MASSACHVSETTS INSTITVTE OF TECHNOLOGY",
 162       "\xDB\x3B\x0D\x8F\x0B\x06\x1E\x60\x32\x82\xB3\x08"
 163       "\xA5\x08\x41\x22\x9A\xD7\x98\xFA\xB9\x54\x0C\x1B"}
 164   ,
 165   {
 166   64, "kerberos", "\x6b\x65\x72\x62\x65\x72\x6f\x73"}
 167   ,
 168   {
 169   128, "kerberos",
 170       "\x6b\x65\x72\x62\x65\x72\x6f\x73\x7b\x9b\x5b\x2b\x93\x13\x2b\x93"}
 171   ,
 172   {
 173   168, "kerberos",
 174       "\x83\x72\xc2\x36\x34\x4e\x5f\x15\x50\xcd"
 175       "\x07\x47\xe1\x5d\x62\xca\x7a\x5a\x3b\xce\xa4"}
 176   ,
 177   {
 178   256, "kerberos",
 179       "\x6b\x65\x72\x62\x65\x72\x6f\x73\x7b\x9b\x5b\x2b\x93\x13\x2b\x93"
 180       "\x5c\x9b\xdc\xda\xd9\x5c\x98\x99\xc4\xca\xe4\xde\xe6\xd6\xca\xe4"}
 181   ,
 182   {
 183   168, "Q",
 184       "\x51\x8a\x54\xa2\x15\xa8\x45\x2a\x51\x8a"
 185       "\x54\xa2\x15\xa8\x45\x2a\x51\x8a\x54\xa2\x15"}
 186   ,
 187   {
 188   192, "Q",
 189       "\x51\x8a\x54\xa2\x15\xa8\x45\x2a\x51\x8a\x54\xa2"
 190       "\x15\xa8\x45\x2a\x51\x8a\x54\xa2\x15\xa8\x45\x2a"}
 191   ,
 192   {
 193   168, "ab",
 194       "\xba\x24\xcf\x29\x7f\x49\xf5\x4b\xab\x62"
 195       "\x5d\x12\xe7\x94\x3f\xa4\xfb\x25\xd5\x31\xae"}
 196   ,
 197   {
 198   192, "ab",
 199       "\x61\x62\x0b\x13\x58\x98\xc4\xc2\x26\x16\x30\xb1"
 200       "\x85\x89\x2c\x4c\x62\x61\x13\x0b\x98\x58\xc2\xc4"}
 201 };
 202
 203 struct str2key
 204 {
 205   char *password;
 206   char *salt;
 207   char *key;
 208   int etype;
 209   char *parameters;
 210 }
 211 str2key[] =
 212 {
 213 #define ESZETT "\xC3\x9F"
 214 #define S_CARON "\xC5\xA1"
 215 #define C_ACUTE "\xC4\x87"
 216 #define G_CLEF "\xF0\x9D\x84\x9E"
 217   {
 218   "password",
 219       "ATHENA.MIT.EDUraeburn",
 220       "\xCB\xC2\x2F\xAE\x23\x52\x98\xE3", SHISHI_DES_CBC_MD5}
 221   ,
 222   {
 223   "potatoe",
 224       "WHITEHOUSE.GOVdanny",
 225       "\xDF\x3D\x32\xA7\x4F\xD9\x2A\x01", SHISHI_DES_CBC_MD5}
 226   ,
 227   {
 228   "\xF0\x9D\x84\x9E",
 229       "EXAMPLE.COMpianist",
 230       "\x4F\xFB\x26\xBA\xB0\xCD\x94\x13", SHISHI_DES_CBC_MD5}
 231   ,
 232   {
 233   ESZETT,
 234       "ATHENA.MIT.EDUJuri" S_CARON "i" C_ACUTE,
 235       "\x62\xC8\x1A\x52\x32\xB5\xE6\x9D", SHISHI_DES_CBC_MD5}
 236   ,
 237   {
 238   "11119999",
 239       "AAAAAAAA", "\x98\x40\x54\xD0\xF1\xA7\x3E\x31", SHISHI_DES_CBC_MD5}
 240   ,
 241   {
 242   "NNNN6666",
 243       "FFFFAAAA", "\xC4\xBF\x6B\x25\xAD\xF7\xA4\xF8", SHISHI_DES_CBC_MD5}
 244   ,
 245   {
 246   "password",
 247       "ATHENA.MIT.EDUraeburn",
 248       "\x85\x0b\xb5\x13\x58\x54\x8c\xd0\x5e\x86\x76\x8c"
 249       "\x31\x3e\x3b\xfe\xf7\x51\x19\x37\xdc\xf7\x2c\x3e",
 250       SHISHI_DES3_CBC_HMAC_SHA1_KD}
 251   ,
 252   {
 253   "potatoe",
 254       "WHITEHOUSE.GOVdanny",
 255       "\xdf\xcd\x23\x3d\xd0\xa4\x32\x04\xea\x6d\xc4\x37"
 256       "\xfb\x15\xe0\x61\xb0\x29\x79\xc1\xf7\x4f\x37\x7a",
 257       SHISHI_DES3_CBC_HMAC_SHA1_KD}
 258   ,
 259   {
 260   "penny",
 261       "EXAMPLE.COMbuckaroo",
 262       "\x6d\x2f\xcd\xf2\xd6\xfb\xbc\x3d\xdc\xad\xb5\xda"
 263       "\x57\x10\xa2\x34\x89\xb0\xd3\xb6\x9d\x5d\x9d\x4a",
 264       SHISHI_DES3_CBC_HMAC_SHA1_KD}
 265   ,
 266   {
 267   ESZETT,
 268       "ATHENA.MIT.EDUJuri" S_CARON "i" C_ACUTE,
 269       "\x16\xd5\xa4\x0e\x1c\xe3\xba\xcb\x61\xb9\xdc\xe0"
 270       "\x04\x70\x32\x4c\x83\x19\x73\xa7\xb9\x52\xfe\xb0",
 271       SHISHI_DES3_CBC_HMAC_SHA1_KD}
 272   ,
 273   {
 274   G_CLEF,
 275       "EXAMPLE.COMpianist",
 276       "\x85\x76\x37\x26\x58\x5d\xbc\x1c\xce\x6e\xc4\x3e"
 277       "\x1f\x75\x1f\x07\xf1\xc4\xcb\xb0\x98\xf4\x0b\x19",
 278       SHISHI_DES3_CBC_HMAC_SHA1_KD}
 279   ,
 280   {
 281   "password",
 282       "ATHENA.MIT.EDUraeburn",
 283       "\x42\x26\x3c\x6e\x89\xf4\xfc\x28\xb8\xdf\x68\xee\x09\x79\x9f\x15",
 284       SHISHI_AES128_CTS_HMAC_SHA1_96, "\x00\x00\x00\x01"}
 285   ,
 286   {
 287   "password",
 288       "ATHENA.MIT.EDUraeburn",
 289       "\xfe\x69\x7b\x52\xbc\x0d\x3c\xe1\x44\x32\xba\x03\x6a\x92\xe6\x5b"
 290       "\xbb\x52\x28\x09\x90\xa2\xfa\x27\x88\x39\x98\xd7\x2a\xf3\x01\x61",
 291       SHISHI_AES256_CTS_HMAC_SHA1_96, "\x00\x00\x00\x01"}
 292   ,
 293   {
 294   "password",
 295       "ATHENA.MIT.EDUraeburn",
 296       "\xc6\x51\xbf\x29\xe2\x30\x0a\xc2\x7f\xa4\x69\xd6\x93\xbd\xda\x13",
 297       SHISHI_AES128_CTS_HMAC_SHA1_96, "\x00\x00\x00\x02"}
 298   ,
 299   {
 300   "password",
 301       "ATHENA.MIT.EDUraeburn",
 302       "\xa2\xe1\x6d\x16\xb3\x60\x69\xc1\x35\xd5\xe9\xd2\xe2\x5f\x89\x61"
 303       "\x02\x68\x56\x18\xb9\x59\x14\xb4\x67\xc6\x76\x22\x22\x58\x24\xff",
 304       SHISHI_AES256_CTS_HMAC_SHA1_96, "\x00\x00\x00\x02"}
 305   ,
 306   {
 307   "password",
 308       "ATHENA.MIT.EDUraeburn",
 309       "\x4c\x01\xcd\x46\xd6\x32\xd0\x1e\x6d\xbe\x23\x0a\x01\xed\x64\x2a",
 310       SHISHI_AES128_CTS_HMAC_SHA1_96, "\x00\x00\x04\xB0"}
 311   ,
 312   {
 313   "password",
 314       "ATHENA.MIT.EDUraeburn",
 315       "\x55\xa6\xac\x74\x0a\xd1\x7b\x48\x46\x94\x10\x51\xe1\xe8\xb0\xa7"
 316       "\x54\x8d\x93\xb0\xab\x30\xa8\xbc\x3f\xf1\x62\x80\x38\x2b\x8c\x2a",
 317       SHISHI_AES256_CTS_HMAC_SHA1_96, "\x00\x00\x04\xB0"}
 318   ,
 319   {
 320   "password",
 321       "\x12\x34\x56\x78\x78\x56\x34\x12",
 322       "\xe9\xb2\x3d\x52\x27\x37\x47\xdd\x5c\x35\xcb\x55\xbe\x61\x9d\x8e",
 323       SHISHI_AES128_CTS_HMAC_SHA1_96, "\x00\x00\x00\x05"}
 324   ,
 325   {
 326   "password",
 327       "\x12\x34\x56\x78\x78\x56\x34\x12",
 328       "\x97\xa4\xe7\x86\xbe\x20\xd8\x1a\x38\x2d\x5e\xbc\x96\xd5\x90\x9c"
 329       "\xab\xcd\xad\xc8\x7c\xa4\x8f\x57\x45\x04\x15\x9f\x16\xc3\x6e\x31",
 330       SHISHI_AES256_CTS_HMAC_SHA1_96, "\x00\x00\x00\x05"}
 331   ,
 332   {
 333   "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 334       "pass phrase equals block size",
 335       "\x59\xd1\xbb\x78\x9a\x82\x8b\x1a\xa5\x4e\xf9\xc2\x88\x3f\x69\xed",
 336       SHISHI_AES128_CTS_HMAC_SHA1_96, "\x00\x00\x04\xB0"}
 337   ,
 338   {
 339   "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 340       "pass phrase equals block size",
 341       "\x89\xad\xee\x36\x08\xdb\x8b\xc7\x1f\x1b\xfb\xfe\x45\x94\x86\xb0"
 342       "\x56\x18\xb7\x0c\xba\xe2\x20\x92\x53\x4e\x56\xc5\x53\xba\x4b\x34",
 343       SHISHI_AES256_CTS_HMAC_SHA1_96, "\x00\x00\x04\xB0"}
 344   ,
 345   {
 346   "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 347       "pass phrase exceeds block size",
 348       "\xcb\x80\x05\xdc\x5f\x90\x17\x9a\x7f\x02\x10\x4c\x00\x18\x75\x1d",
 349       SHISHI_AES128_CTS_HMAC_SHA1_96, "\x00\x00\x04\xB0"}
 350   ,
 351   {
 352   "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 353       "pass phrase exceeds block size",
 354       "\xd7\x8c\x5c\x9c\xb8\x72\xa8\xc9\xda\xd4\x69\x7f\x0b\xb5\xb2\xd2"
 355       "\x14\x96\xc8\x2b\xeb\x2c\xae\xda\x21\x12\xfc\xee\xa0\x57\x40\x1b",
 356       SHISHI_AES256_CTS_HMAC_SHA1_96, "\x00\x00\x04\xB0"}
 357   ,
 358   {
 359   G_CLEF,
 360       "EXAMPLE.COMpianist",
 361       "\xf1\x49\xc1\xf2\xe1\x54\xa7\x34\x52\xd4\x3e\x7f\xe6\x2a\x56\xe5",
 362       SHISHI_AES128_CTS_HMAC_SHA1_96, "\x00\x00\x00\x32"}
 363   ,
 364   {
 365   G_CLEF,
 366       "EXAMPLE.COMpianist",
 367       "\x4b\x6d\x98\x39\xf8\x44\x06\xdf\x1f\x09\xcc\x16\x6d\xb4\xb8\x3c"
 368       "\x57\x18\x48\xb7\x84\xa3\xd6\xbd\xc3\x46\x58\x9a\x3e\x39\x3f\x9e",
 369       SHISHI_AES256_CTS_HMAC_SHA1_96, "\x00\x00\x00\x32"}
 370 ,};
 371
 372 struct pkcs5
 373 {
 374   int iterations;
 375   char *password;
 376   char *salt;
 377   int algo;
 378   int dklen;
 379   char *expected;
 380 }
 381 pkcs5[] =
 382 {
 383   {
 384   1, "password", "ATHENA.MIT.EDUraeburn", PKCS5_PRF_SHA1, 16,
 385       "\xCD\xED\xB5\x28\x1B\xB2\xF8\x01\x56\x5A\x11\x22\xB2\x56\x35\x15"}
 386   ,
 387   {
 388   2, "password", "ATHENA.MIT.EDUraeburn", PKCS5_PRF_SHA1, 16,
 389       "\x01\xdb\xee\x7f\x4a\x9e\x24\x3e\x98\x8b\x62\xc7\x3c\xda\x93\x5d"}
 390   ,
 391   {
 392   2, "password", "ATHENA.MIT.EDUraeburn", PKCS5_PRF_SHA1, 32,
 393       "\x01\xdb\xee\x7f\x4a\x9e\x24\x3e\x98\x8b\x62\xc7\x3c\xda\x93\x5d"
 394       "\xa0\x53\x78\xb9\x32\x44\xec\x8f\x48\xa9\x9e\x61\xad\x79\x9d\x86"}
 395   ,
 396   {
 397   1200, "password", "ATHENA.MIT.EDUraeburn", PKCS5_PRF_SHA1, 16,
 398       "\x5c\x08\xeb\x61\xfd\xf7\x1e\x4e\x4e\xc3\xcf\x6b\xa1\xf5\x51\x2b"}
 399   ,
 400   {
 401   1200, "password", "ATHENA.MIT.EDUraeburn", PKCS5_PRF_SHA1, 32,
 402       "\x5c\x08\xeb\x61\xfd\xf7\x1e\x4e\x4e\xc3\xcf\x6b\xa1\xf5\x51\x2b"
 403       "\xa7\xe5\x2d\xdb\xc5\xe5\x14\x2f\x70\x8a\x31\xe2\xe6\x2b\x1e\x13"}
 404   ,
 405   {
 406   5, "password", "\x12\x34\x56\x78\x78\x56\x34\x12\x00", PKCS5_PRF_SHA1, 16,
 407       "\xd1\xda\xa7\x86\x15\xf2\x87\xe6\xa1\xc8\xb1\x20\xd7\x06\x2a\x49"}
 408   ,
 409   {
 410   5, "password", "\x12\x34\x56\x78\x78\x56\x34\x12\x00", PKCS5_PRF_SHA1, 32,
 411       "\xd1\xda\xa7\x86\x15\xf2\x87\xe6\xa1\xc8\xb1\x20\xd7\x06\x2a\x49"
 412       "\x3f\x98\xd2\x03\xe6\xbe\x49\xa6\xad\xf4\xfa\x57\x4b\x6e\x64\xee"}
 413   ,
 414   {
 415   1200, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 416       "pass phrase equals block size", PKCS5_PRF_SHA1, 16,
 417       "\x13\x9c\x30\xc0\x96\x6b\xc3\x2b\xa5\x5f\xdb\xf2\x12\x53\x0a\xc9"}
 418   ,
 419   {
 420   1200, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 421       "pass phrase equals block size", PKCS5_PRF_SHA1, 32,
 422       "\x13\x9c\x30\xc0\x96\x6b\xc3\x2b\xa5\x5f\xdb\xf2\x12\x53\x0a\xc9"
 423       "\xc5\xec\x59\xf1\xa4\x52\xf5\xcc\x9a\xd9\x40\xfe\xa0\x59\x8e\xd1"}
 424   ,
 425   {
 426   1200, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 427       "pass phrase exceeds block size", PKCS5_PRF_SHA1, 16,
 428       "\x9c\xca\xd6\xd4\x68\x77\x0c\xd5\x1b\x10\xe6\xa6\x87\x21\xbe\x61"}
 429   ,
 430   {
 431   1200, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 432       "pass phrase exceeds block size", PKCS5_PRF_SHA1, 32,
 433       "\x9c\xca\xd6\xd4\x68\x77\x0c\xd5\x1b\x10\xe6\xa6\x87\x21\xbe\x61"
 434       "\x1a\x8b\x4d\x28\x26\x01\xdb\x3b\x36\xbe\x92\x46\x91\x5e\xc8\x2a"}
 435   ,
 436   {
 437   50, G_CLEF "\x00", "EXAMPLE.COMpianist", PKCS5_PRF_SHA1, 16,
 438       "\x6b\x9c\xf2\x6d\x45\x45\x5a\x43\xa5\xb8\xbb\x27\x6a\x40\x3b\x39"}
 439   ,
 440   {
 441   50, G_CLEF "\x00", "EXAMPLE.COMpianist", PKCS5_PRF_SHA1, 32,
 442       "\x6b\x9c\xf2\x6d\x45\x45\x5a\x43\xa5\xb8\xbb\x27\x6a\x40\x3b\x39"
 443       "\xe7\xfe\x37\xa0\xc4\x1e\x02\xc2\x81\xff\x30\x69\xe1\xe9\x4f\x52"}
 444   ,
 445   {
 446   500, "All n-entities must communicate with other n-entities via n-1 "
 447       "entiteeheehees", "\x12\x34\x56\x78\x78\x56\x34\x12\x00",
 448       PKCS5_PRF_SHA1, 16,
 449       "\x6A\x89\x70\xBF\x68\xC9\x2C\xAE\xA8\x4A\x8D\xF2\x85\x10\x85\x86"}
 450 };
 451
 452 int
 453 main (int argc, char *argv[])
 454 {
 455   Shishi *handle;
 456   Shishi_key *key, *key2;
 457   unsigned char out[BUFSIZ];
 458   size_t i;
 459   int res;
 460
 461   do
 462     if (strcmp (argv[argc - 1], "-v") == 0 ||
 463         strcmp (argv[argc - 1], "--verbose") == 0)
 464       verbose = 1;
 465     else if (strcmp (argv[argc - 1], "-d") == 0 ||
 466              strcmp (argv[argc - 1], "--debug") == 0)
 467       debug = 1;
 468     else if (strcmp (argv[argc - 1], "-b") == 0 ||
 469              strcmp (argv[argc - 1], "--break-on-error") == 0)
 470       break_on_error = 1;
 471     else if (strcmp (argv[argc - 1], "-h") == 0 ||
 472              strcmp (argv[argc - 1], "-?") == 0 ||
 473              strcmp (argv[argc - 1], "--help") == 0)
 474       {
 475         printf ("Usage: %s [-vdbh?] [--verbose] [--debug] "
 476                 "[--break-on-error] [--help]\n", argv[0]);
 477         return 1;
 478       }
 479   while (argc-- > 1);
 480
 481   handle = shishi ();
 482   if (handle == NULL)
 483     {
 484       fail ("Could not initialize shishi\n");
 485       return 1;
 486     }
 487
 488   if (debug)
 489     shishi_cfg (handle, strdup ("verbose,verbose-crypto"));
 490
 491   for (i = 0; i < sizeof (drdk) / sizeof (drdk[0]); i++)
 492     {
 493       if (verbose)
 494         printf ("DR entry %d\n", i);
 495
 496       res = shishi_key_from_value (handle, drdk[i].type, drdk[i].key, &key);
 497
 498       if (res == SHISHI_OK)
 499         res = shishi_dr (handle, key, drdk[i].usage, drdk[i].nusage,
 500                          out, strlen (drdk[i].dr));
 501
 502       shishi_key_done (&key);
 503
 504       if (res != SHISHI_OK)
 505         {
 506           fail ("shishi_dr() entry %d failed (%s)\n",
 507                 i, shishi_strerror_details (handle));
 508           continue;
 509         }
 510
 511       if (verbose)
 512         {
 513           printf ("DR(%s, key, usage)\n", shishi_cipher_name (drdk[i].type));
 514
 515           printf ("key:\n");
 516           escapeprint (drdk[i].key, strlen (drdk[i].key));
 517           hexprint (drdk[i].key, strlen (drdk[i].key));
 518           puts ("");
 519           binprint (drdk[i].key, strlen (drdk[i].key));
 520           puts ("");
 521
 522           printf ("usage:\n");
 523           escapeprint (drdk[i].usage, drdk[i].nusage);
 524           hexprint (drdk[i].usage, drdk[i].nusage);
 525           puts ("");
 526           binprint (drdk[i].usage, drdk[i].nusage);
 527           puts ("");
 528
 529           printf ("computed DR:\n");
 530           escapeprint (out, strlen (drdk[i].dr));
 531           hexprint (out, strlen (drdk[i].dr));
 532           puts ("");
 533           binprint (out, strlen (drdk[i].dr));
 534           puts ("");
 535
 536           printf ("expected DR:\n");
 537           escapeprint (drdk[i].dr, strlen (drdk[i].dr));
 538           hexprint (drdk[i].dr, strlen (drdk[i].dr));
 539           puts ("");
 540           binprint (drdk[i].dr, strlen (drdk[i].dr));
 541           puts ("");
 542         }
 543
 544       if (memcmp (drdk[i].dr, out, strlen (drdk[i].dr)) != 0)
 545         {
 546           fail ("shishi_dr() entry %d failed\n", i);
 547           if (verbose)
 548             printf ("ERROR\n");
 549         }
 550       else if (verbose)
 551         success ("OK\n");
 552
 553       res = shishi_key_from_value (handle, drdk[i].type, drdk[i].key, &key);
 554
 555       if (res == SHISHI_OK)
 556         res = shishi_key_from_value (handle, drdk[i].type, NULL, &key2);
 557
 558       if (res == SHISHI_OK)
 559         res = shishi_dk (handle, key, drdk[i].usage, drdk[i].nusage, key2);
 560
 561       shishi_key_done (&key);
 562
 563       if (res != SHISHI_OK)
 564         {
 565           fail ("shishi_dk() entry %d failed (%s)\n",
 566                 i, shishi_strerror_details (handle));
 567           continue;
 568         }
 569
 570       if (verbose)
 571         {
 572           printf ("DK(%s, key, usage)\n", shishi_cipher_name (drdk[i].type));
 573
 574           printf ("key:\n");
 575           escapeprint (drdk[i].key, strlen (drdk[i].key));
 576           hexprint (drdk[i].key, strlen (drdk[i].key));
 577           puts ("");
 578           binprint (drdk[i].key, strlen (drdk[i].key));
 579           puts ("");
 580
 581           printf ("usage:\n");
 582           escapeprint (drdk[i].usage, drdk[i].nusage);
 583           hexprint (drdk[i].usage, drdk[i].nusage);
 584           puts ("");
 585           binprint (drdk[i].usage, drdk[i].nusage);
 586           puts ("");
 587
 588           printf ("computed DK:\n");
 589           escapeprint (shishi_key_value (key2), shishi_key_length (key2));
 590           hexprint (shishi_key_value (key2), shishi_key_length (key2));
 591           puts ("");
 592           binprint (shishi_key_value (key2), shishi_key_length (key2));
 593           puts ("");
 594
 595           printf ("expected DK:\n");
 596           escapeprint (drdk[i].dk, strlen (drdk[i].dk));
 597           hexprint (drdk[i].dk, strlen (drdk[i].dk));
 598           puts ("");
 599           binprint (drdk[i].dk, strlen (drdk[i].dk));
 600           puts ("");
 601         }
 602
 603       if (!(shishi_key_length (key2) == strlen (drdk[i].dk) &&
 604             memcmp (drdk[i].dk, shishi_key_value (key2),
 605                     strlen (drdk[i].dk)) == 0))
 606         {
 607           fail ("shishi_dk() entry %d failed\n", i);
 608           if (verbose)
 609             printf ("ERROR\n");
 610         }
 611       else if (verbose)
 612         success ("OK\n");
 613     }
 614
 615   for (i = 0; i < sizeof (nfold) / sizeof (nfold[0]); i++)
 616     {
 617       if (verbose)
 618         printf ("N-FOLD entry %d\n", i);
 619
 620       res = shishi_n_fold (handle,
 621                            nfold[i].in, strlen (nfold[i].in),
 622                            out, nfold[i].n / 8);
 623       if (res != SHISHI_OK)
 624         {
 625           fail ("shishi_n_fold() entry %d failed (%s)\n",
 626                 i, shishi_strerror_details (handle));
 627           continue;
 628         }
 629
 630       if (verbose)
 631         {
 632           printf ("in:\n");
 633           escapeprint (nfold[i].in, strlen (nfold[i].in));
 634           hexprint (nfold[i].in, strlen (nfold[i].in));
 635           puts ("");
 636           binprint (nfold[i].in, strlen (nfold[i].in));
 637           puts ("");
 638
 639           printf ("out:\n");
 640           escapeprint (out, nfold[i].n / 8);
 641           hexprint (out, nfold[i].n / 8);
 642           puts ("");
 643           binprint (out, nfold[i].n / 8);
 644           puts ("");
 645
 646           printf ("expected out:\n");
 647           escapeprint (nfold[i].out, nfold[i].n / 8);
 648           hexprint (nfold[i].out, nfold[i].n / 8);
 649           puts ("");
 650           binprint (nfold[i].out, nfold[i].n / 8);
 651           puts ("");
 652         }
 653
 654       if (memcmp (nfold[i].out, out, nfold[i].n / 8) != 0)
 655         {
 656           fail ("shishi_n_fold() entry %d failed\n", i);
 657           if (verbose)
 658             printf ("ERROR\n");
 659         }
 660       else if (verbose)
 661         success ("OK\n");
 662     }
 663
 664   for (i = 0; i < sizeof (str2key) / sizeof (str2key[0]); i++)
 665     {
 666       int n_password = strlen (str2key[i].password);
 667       int saltlen = strlen (str2key[i].salt);
 668       int keylen = sizeof (key);
 669       const char *name = shishi_cipher_name (str2key[i].etype);
 670
 671       if (verbose)
 672         printf ("STRING-TO-KEY entry %d (key type %s)\n", i,
 673                 name ? name : "NO NAME");
 674
 675       res = shishi_key_from_string (handle, str2key[i].etype,
 676                                     str2key[i].password, n_password,
 677                                     str2key[i].salt, saltlen,
 678                                     str2key[i].parameters, &key);
 679       if (res != SHISHI_OK)
 680         {
 681           fail ("shishi_string_to_key() entry %d failed (%s)\n",
 682                 i, shishi_strerror_details (handle));
 683           continue;
 684         }
 685
 686       if (verbose)
 687         {
 688           printf ("password:\n");
 689           escapeprint (str2key[i].password, n_password);
 690           hexprint (str2key[i].password, n_password);
 691           puts ("");
 692           binprint (str2key[i].password, n_password);
 693           puts ("");
 694
 695           printf ("salt:\n");
 696           escapeprint (str2key[i].salt, saltlen);
 697           hexprint (str2key[i].salt, saltlen);
 698           puts ("");
 699           binprint (str2key[i].salt, saltlen);
 700           puts ("");
 701
 702           printf ("computed key:\n");
 703           escapeprint (shishi_key_value (key), shishi_key_length (key));
 704           hexprint (shishi_key_value (key), shishi_key_length (key));
 705           puts ("");
 706           binprint (shishi_key_value (key), shishi_key_length (key));
 707           puts ("");
 708
 709           printf ("expected key:\n");
 710           escapeprint (str2key[i].key, strlen (str2key[i].key));
 711           hexprint (str2key[i].key, strlen (str2key[i].key));
 712           puts ("");
 713           binprint (str2key[i].key, strlen (str2key[i].key));
 714           puts ("");
 715         }
 716
 717       if (memcmp (str2key[i].key, shishi_key_value (key), keylen) != 0)
 718         {
 719           fail ("shishi_string_to_key() entry %d failed\n", i);
 720
 721           if (verbose)
 722             printf ("ERROR\n");
 723         }
 724       else if (verbose)
 725         success ("OK\n");
 726     }
 727
 728   for (i = 0; i < sizeof (pkcs5) / sizeof (pkcs5[0]); i++)
 729     {
 730       if (verbose)
 731         printf ("PKCS5 entry %d\n", i);
 732
 733       res = PBKDF2 (pkcs5[i].algo,
 734                     pkcs5[i].password,
 735                     strlen (pkcs5[i].password),
 736                     pkcs5[i].salt,
 737                     strlen (pkcs5[i].salt),
 738                     pkcs5[i].iterations, pkcs5[i].dklen, out);
 739       if (res != PKCS5_OK)
 740         {
 741           fail ("PKCS5 entry %d failed fatally: %d\n", i, res);
 742           continue;
 743         }
 744
 745       if (verbose)
 746         {
 747           printf ("password:\n");
 748           escapeprint (pkcs5[i].password, strlen (pkcs5[i].password));
 749           hexprint (pkcs5[i].password, strlen (pkcs5[i].password));
 750           puts ("");
 751           binprint (pkcs5[i].password, strlen (pkcs5[i].password));
 752           puts ("");
 753
 754           printf ("salt:\n");
 755           escapeprint (pkcs5[i].salt, strlen (pkcs5[i].salt));
 756           hexprint (pkcs5[i].salt, strlen (pkcs5[i].salt));
 757           puts ("");
 758           binprint (pkcs5[i].salt, strlen (pkcs5[i].salt));
 759           puts ("");
 760
 761           printf ("computed key:\n");
 762           escapeprint (out, pkcs5[i].dklen);
 763           hexprint (out, pkcs5[i].dklen);
 764           puts ("");
 765           binprint (out, pkcs5[i].dklen);
 766           puts ("");
 767
 768           printf ("expected key:\n");
 769           escapeprint (pkcs5[i].expected, pkcs5[i].dklen);
 770           hexprint (pkcs5[i].expected, pkcs5[i].dklen);
 771           puts ("");
 772           binprint (pkcs5[i].expected, pkcs5[i].dklen);
 773           puts ("");
 774         }
 775
 776       if (memcmp (pkcs5[i].expected, out, pkcs5[i].dklen) != 0)
 777         {
 778           fail ("PKCS5 entry %d failed\n", i);
 779
 780           if (verbose)
 781             printf ("ERROR\n");
 782         }
 783       else if (verbose)
 784         success ("OK\n");
 785     }
 786
 787   if (verbose)
 788     printf ("Crypt self tests done with %d errors\n", error_count);
 789
 790   return error_count ? 1 : 0;
 791 }