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