* basic.c (check_one_md): Kludge to check a one million "a".
[libgcrypt.git] / tests / basic.c
1 /* basic.c  -  basic regression tests
2  *      Copyright (C) 2001, 2002 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt 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
14  * GNU 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 this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <stdarg.h>
25 #include "../src/gcrypt.h"
26
27
28 static const char sample_private_key_1[] =
29 "(private-key\n"
30 " (rsa\n"
31 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
32       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
33       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
34       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
35 "  (e #010001#)\n"
36 "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
37       "7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
38       "C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
39       "C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781#)\n"
40 "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
41       "fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424f1#)\n"
42 "  (q #00f7a7ca5367c661f8e62df34f0d05c10c88e5492348dd7bddc942c9a8f369f9"
43       "35a07785d2db805215ed786e4285df1658eed3ce84f469b81b50d358407b4ad361#)\n"
44 "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
45       "ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b#)\n"
46 " )\n"
47 ")\n";
48 static const char sample_public_key_1[] =
49 "(public-key\n"
50 " (rsa\n"
51 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
52       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
53       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
54       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
55 "  (e #010001#)\n"
56 " )\n"
57 ")\n";
58 static const unsigned char sample_grip_key_1[] =
59 "\x32\x10\x0c\x27\x17\x3e\xf6\xe9\xc4\xe9"
60 "\xa2\x5d\x3d\x69\xf8\x6d\x37\xa4\xf9\x39";
61
62
63 static int verbose;
64 static int error_count;
65
66 static void
67 fail ( const char *format, ... )
68 {
69     va_list arg_ptr ;
70
71     va_start( arg_ptr, format ) ;
72     vfprintf (stderr, format, arg_ptr );
73     va_end(arg_ptr);
74     error_count++;
75 }
76
77 static void
78 die ( const char *format, ... )
79 {
80     va_list arg_ptr ;
81
82     va_start( arg_ptr, format ) ;
83     vfprintf (stderr, format, arg_ptr );
84     va_end(arg_ptr);
85     exit (1);
86 }
87
88 #define MAX_DATA_LEN 100
89
90 static void
91 check_aes128_cbc_cts_cipher ()
92 {
93   char key[128/8] = "chicken teriyaki";
94   char plaintext[] = "I would like the General Gau's Chicken, please, and wonton soup.";
95   struct tv {
96     char out[MAX_DATA_LEN];
97     int inlen;
98   } tv[] = {
99     {  "\xc6\x35\x35\x68\xf2\xbf\x8c\xb4\xd8\xa5\x80\x36\x2d\xa7\xff\x7f"
100       "\x97", 17 },
101     { "\xfc\x00\x78\x3e\x0e\xfd\xb2\xc1\xd4\x45\xd4\xc8\xef\xf7\xed\x22"
102       "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5", 31 },
103     { "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8"
104       "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84", 32 },
105     { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
106       "\xb3\xff\xfd\x94\x0c\x16\xa1\x8c\x1b\x55\x49\xd2\xf8\x38\x02\x9e"
107       "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5", 47 },
108     { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
109       "\x9d\xad\x8b\xbb\x96\xc4\xcd\xc0\x3b\xc1\x03\xe1\xa1\x94\xbb\xd8"
110       "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8", 48 },
111     { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
112       "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8"
113       "\x48\x07\xef\xe8\x36\xee\x89\xa5\x26\x73\x0d\xbc\x2f\x7b\xc8\x40"
114       "\x9d\xad\x8b\xbb\x96\xc4\xcd\xc0\x3b\xc1\x03\xe1\xa1\x94\xbb\xd8", 64 }
115   };
116   GCRY_CIPHER_HD hd;
117   char out[MAX_DATA_LEN];
118   int i;
119
120   hd = gcry_cipher_open (GCRY_CIPHER_AES, 
121                          GCRY_CIPHER_MODE_CBC, 
122                          GCRY_CIPHER_CBC_CTS);
123   if (!hd) {
124     fail ("aes-cbc-cts, grcy_open_cipher failed: %s\n", gcry_strerror (-1) );
125     return;
126   }
127
128   if (gcry_cipher_setkey (hd, key, 128/8)) { 
129     fail ("aes-cbc-cts, gcry_cipher_setkey failed: %s\n", gcry_strerror (-1) );
130     gcry_cipher_close (hd);
131     return;
132   }
133
134   for (i = 0; i < sizeof(tv) / sizeof(tv[0]); i++)
135     {
136       if (gcry_cipher_setiv (hd, NULL, 0)) { 
137         fail ("aes-cbc-cts, gcry_cipher_setiv failed: %s\n",
138               gcry_strerror (-1) );
139         gcry_cipher_close (hd);
140         return;
141       }
142
143       if ( gcry_cipher_encrypt (hd, out, MAX_DATA_LEN, 
144                                 plaintext, tv[i].inlen)) { 
145         fail ("aes-cbc-cts, gcry_cipher_encrypt failed: %s\n",
146               gcry_strerror (-1) );
147         gcry_cipher_close (hd);
148         return;
149       }
150
151       if ( memcmp (tv[i].out, out, tv[i].inlen) )
152         fail ("aes-cbc-cts, encrypt mismatch entry %d\n", i);
153
154       if (gcry_cipher_setiv (hd, NULL, 0)) { 
155         fail ("aes-cbc-cts, gcry_cipher_setiv failed: %s\n",
156               gcry_strerror (-1) );
157         gcry_cipher_close (hd);
158         return;
159       }
160       if ( gcry_cipher_decrypt (hd, out, tv[i].inlen, NULL, 0)) { 
161         fail ("aes-cbc-cts, gcry_cipher_decrypt failed: %s\n",
162               gcry_strerror (-1) );
163         gcry_cipher_close (hd);
164         return;
165       }
166
167       if ( memcmp (plaintext, out, tv[i].inlen) )
168         fail ("aes-cbc-cts, decrypt mismatch entry %d\n", i);
169     }
170
171   gcry_cipher_close (hd);
172 }
173
174 static void
175 check_one_cipher (int algo, int mode, int flags)
176 {
177     GCRY_CIPHER_HD hd;
178     char key[32], plain[16], in[16], out[16];
179     int keylen;
180
181     memcpy (key, "0123456789abcdef.,;/[]{}-=ABCDEF", 32);
182     memcpy (plain, "foobar42FOOBAR17", 16);
183
184     keylen = gcry_cipher_get_algo_keylen (algo);
185     if (keylen < 40/8 || keylen > 32 ) {
186         fail ("algo %d, mode %d, keylength problem (%d)\n",
187               algo, mode, keylen );
188         return;
189     }
190
191     hd = gcry_cipher_open (algo, mode, flags);
192     if (!hd) {
193         fail ("algo %d, mode %d, grcy_open_cipher failed: %s\n",
194               algo, mode, gcry_strerror (-1) );
195         return;
196     }
197
198     
199     if (gcry_cipher_setkey (hd, key, keylen)) { 
200         fail ("algo %d, mode %d, gcry_cipher_setkey failed: %s\n",
201               algo, mode, gcry_strerror (-1) );
202         gcry_cipher_close (hd);
203         return;
204     }
205     
206     if ( gcry_cipher_encrypt (hd, out, 16, plain, 16)) { 
207         fail ("algo %d, mode %d, gcry_cipher_encrypt failed: %s\n",
208               algo, mode, gcry_strerror (-1) );
209         gcry_cipher_close (hd);
210         return;
211     }
212
213     gcry_cipher_close (hd);
214     hd = gcry_cipher_open (algo, mode, flags);
215     if (!hd) {
216         fail ("algo %d, mode %d, grcy_open_cipher failed: %s\n",
217               algo, mode, gcry_strerror (-1) );
218         return;
219     }
220
221     if (gcry_cipher_setkey (hd, key, keylen)) { 
222         fail ("algo %d, mode %d, gcry_cipher_setkey[2] failed: %s\n",
223               algo, mode, gcry_strerror (-1) );
224         gcry_cipher_close (hd);
225         return;
226     }
227     
228     if ( gcry_cipher_decrypt (hd, in, 16, out, 16)) { 
229         fail ("algo %d, mode %d, gcry_cipher_decrypt failed: %s\n",
230               algo, mode, gcry_strerror (-1) );
231         gcry_cipher_close (hd);
232         return;
233     }
234
235     gcry_cipher_close (hd);
236
237     if ( memcmp (plain, in, 16) )
238         fail ("algo %d, mode %d, encrypt-decrypt mismatch\n", algo, mode);
239 }
240
241
242 static void
243 check_ciphers (void)
244 {
245   static int algos[] = {
246     GCRY_CIPHER_3DES,
247     GCRY_CIPHER_CAST5,
248     GCRY_CIPHER_BLOWFISH,
249     GCRY_CIPHER_AES,
250     GCRY_CIPHER_AES192,
251     GCRY_CIPHER_AES256,
252     GCRY_CIPHER_TWOFISH,
253     GCRY_CIPHER_DES,
254     0
255   };
256   static int algos2[] = {
257     GCRY_CIPHER_ARCFOUR,
258     0
259   };
260   int i;
261
262   for (i=0; algos[i]; i++ ) 
263     {
264       if (verbose)
265         fprintf (stderr, "checking `%s'\n", gcry_cipher_algo_name (algos[i]));
266                  
267       check_one_cipher (algos[i], GCRY_CIPHER_MODE_ECB, 0);
268       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CFB, 0);
269       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CBC, 0);
270       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_CTS);
271     }
272
273   for (i=0; algos2[i]; i++ ) 
274     {
275       if (verbose)
276         fprintf (stderr, "checking `%s'\n", gcry_cipher_algo_name (algos2[i]));
277                  
278       check_one_cipher (algos2[i], GCRY_CIPHER_MODE_STREAM, 0);
279     }
280   /* we have now run all cipher's selftests */
281
282   /* TODO: add some extra encryption to test the higher level functions */
283 }
284
285
286
287 static void
288 check_one_md (int algo, char *data, int len, char *expect)
289 {
290     GCRY_MD_HD hd;
291     char *p;
292     int mdlen;
293     int i;
294
295     hd = gcry_md_open (algo, 0);
296     if (!hd) {
297         fail ("algo %d, grcy_md_open failed: %s\n",
298               algo, gcry_strerror (-1) );
299         return;
300     }
301
302     mdlen = gcry_md_get_algo_dlen(algo);
303     if (mdlen < 1 || mdlen > 500) {
304         fail ("algo %d, grcy_md_get_algo_dlen failed: %d\n", algo, mdlen);
305         return;
306     }
307
308     if (*data == '!' && !data[1])
309       { /* hash one million times a "a" */
310         char aaa[1000];
311         
312         memset (aaa, 'a', 1000);
313         for (i=0; i < 1000; i++)
314           gcry_md_write (hd, aaa, 1000);
315       }
316     else
317       gcry_md_write (hd, data, len);
318
319     p = gcry_md_read (hd, algo);
320
321     if ( memcmp (p, expect, mdlen) )
322         fail ("algo %d, digest mismatch\n", algo);
323
324     gcry_md_close (hd);
325 }
326
327 static void
328 check_digests ()
329 {
330   static struct algos {
331     int md;
332     char *data;
333     char *expect;
334   } algos[] = {
335     { GCRY_MD_MD4, "",
336       "\x31\xD6\xCF\xE0\xD1\x6A\xE9\x31\xB7\x3C\x59\xD7\xE0\xC0\x89\xC0" },
337     { GCRY_MD_MD4, "a",
338       "\xbd\xe5\x2c\xb3\x1d\xe3\x3e\x46\x24\x5e\x05\xfb\xdb\xd6\xfb\x24" },
339     { GCRY_MD_MD4, "message digest",
340       "\xd9\x13\x0a\x81\x64\x54\x9f\xe8\x18\x87\x48\x06\xe1\xc7\x01\x4b" },
341     { GCRY_MD_MD5, "",
342       "\xD4\x1D\x8C\xD9\x8F\x00\xB2\x04\xE9\x80\x09\x98\xEC\xF8\x42\x7E" },
343     { GCRY_MD_MD5, "a", 
344       "\x0C\xC1\x75\xB9\xC0\xF1\xB6\xA8\x31\xC3\x99\xE2\x69\x77\x26\x61" },
345     { GCRY_MD_MD5, "abc",
346       "\x90\x01\x50\x98\x3C\xD2\x4F\xB0\xD6\x96\x3F\x7D\x28\xE1\x7F\x72" },
347     { GCRY_MD_MD5, "message digest", 
348       "\xF9\x6B\x69\x7D\x7C\xB7\x93\x8D\x52\x5A\x2F\x31\xAA\xF1\x61\xD0"},
349     { GCRY_MD_SHA1, "abc",
350       "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E"
351       "\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D"},
352     { GCRY_MD_SHA1, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
353       "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE"
354       "\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" },
355     { GCRY_MD_SHA1, "!" /* kludge for "a"*1000000 */,
356       "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E"
357       "\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" },
358     { GCRY_MD_SHA256, "abc",
359       "\xba\x78\x16\xbf\x8f\x01\xcf\xea\x41\x41\x40\xde\x5d\xae\x22\x23"
360       "\xb0\x03\x61\xa3\x96\x17\x7a\x9c\xb4\x10\xff\x61\xf2\x00\x15\xad" },
361     { GCRY_MD_SHA256, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
362       "\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
363       "\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1" },
364     { GCRY_MD_SHA256, "!",
365       "\xcd\xc7\x6e\x5c\x99\x14\xfb\x92\x81\xa1\xc7\xe2\x84\xd7\x3e\x67" 
366       "\xf1\x80\x9a\x48\xa4\x97\x20\x0e\x04\x6d\x39\xcc\xc7\x11\x2c\xd0" },
367     { GCRY_MD_RMD160, "",
368       "\x9c\x11\x85\xa5\xc5\xe9\xfc\x54\x61\x28"
369       "\x08\x97\x7e\xe8\xf5\x48\xb2\x25\x8d\x31" },
370     { GCRY_MD_RMD160, "a",
371       "\x0b\xdc\x9d\x2d\x25\x6b\x3e\xe9\xda\xae"
372       "\x34\x7b\xe6\xf4\xdc\x83\x5a\x46\x7f\xfe" },
373     { GCRY_MD_RMD160, "abc",
374       "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04"
375       "\x4a\x8e\x98\xc6\xb0\x87\xf1\x5a\x0b\xfc" },
376     { GCRY_MD_RMD160, "message digest",
377       "\x5d\x06\x89\xef\x49\xd2\xfa\xe5\x72\xb8"
378       "\x81\xb1\x23\xa8\x5f\xfa\x21\x59\x5f\x36" },
379 #if 0
380     { GCRY_MD_TIGER, "",
381       "\x24\xF0\x13\x0C\x63\xAC\x93\x32\x16\x16\x6E\x76"
382       "\xB1\xBB\x92\x5F\xF3\x73\xDE\x2D\x49\x58\x4E\x7A" },
383     { GCRY_MD_TIGER, "abc",
384       "\xF2\x58\xC1\xE8\x84\x14\xAB\x2A\x52\x7A\xB5\x41"
385       "\xFF\xC5\xB8\xBF\x93\x5F\x7B\x95\x1C\x13\x29\x51" },
386     { GCRY_MD_TIGER, "Tiger",
387       "\x9F\x00\xF5\x99\x07\x23\x00\xDD\x27\x6A\xBB\x38"
388       "\xC8\xEB\x6D\xEC\x37\x79\x0C\x11\x6F\x9D\x2B\xDF" },
389     { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg"
390       "hijklmnopqrstuvwxyz0123456789+-",
391       "\x87\xFB\x2A\x90\x83\x85\x1C\xF7\x47\x0D\x2C\xF8"
392       "\x10\xE6\xDF\x9E\xB5\x86\x44\x50\x34\xA5\xA3\x86" },
393     { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdef"
394       "ghijklmnopqrstuvwxyz+0123456789",
395       "467DB80863EBCE488DF1CD1261655DE957896565975F9197" },
396     { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
397       "by Ross Anderson and Eli Biham",
398       "0C410A042968868A1671DA5A3FD29A725EC1E457D3CDB303" },
399     { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
400       "by Ross Anderson and Eli Biham, proceedings of Fa"
401       "st Software Encryption 3, Cambridge.",
402       "EBF591D5AFA655CE7F22894FF87F54AC89C811B6B0DA3193" },
403     { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
404       "by Ross Anderson and Eli Biham, proceedings of Fa"
405       "st Software Encryption 3, Cambridge, 1996.",
406       "3D9AEB03D1BD1A6357B2774DFD6D5B24DD68151D503974FC" },
407     { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefgh"
408       "ijklmnopqrstuvwxyz0123456789+-ABCDEFGHIJKLMNOPQRS"
409       "TUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-",
410       "00B83EB4E53440C5 76AC6AAEE0A74858 25FD15E70A59FFE4" },
411 #endif
412     { 0 }
413   };
414   int i;
415
416   for (i=0; algos[i].md; i++ ) 
417     {
418       if (verbose)
419         fprintf (stderr, "checking `%s'\n", gcry_md_algo_name (algos[i].md));
420                  
421       check_one_md (algos[i].md, algos[i].data, strlen(algos[i].data), 
422                     algos[i].expect);
423     }
424
425   /* TODO: test HMAC mode */
426 }
427
428 /* Check that the signature SIG matches the hash HASH. PKEY is the
429    public key used for the verification. BADHASH is a hasvalue which
430    should; result in a bad signature status. */
431 static void
432 verify_one_signature (GcrySexp pkey, GcrySexp hash,
433                       GcrySexp badhash, GcrySexp sig)
434 {
435   int rc;
436
437   rc = gcry_pk_verify (sig, hash, pkey);
438   if (rc)
439     fail ("gcry_pk_verify failed: %s\n", gcry_strerror (rc));
440   rc = gcry_pk_verify (sig, badhash, pkey);
441   if (rc != GCRYERR_BAD_SIGNATURE)
442     fail ("gcry_pk_verify failed to detect a bad signature: %s\n",
443           gcry_strerror (rc));
444 }
445
446
447 /* Test the public key sign function using the private ket SKEY. PKEY
448    is used for verification. */
449 static void
450 check_pubkey_sign (GcrySexp skey, GcrySexp pkey)
451 {
452   int rc;
453   GcrySexp sig, badhash, hash;
454   int dataidx;
455   static const char baddata[] =
456     "(data\n (flags pkcs1)\n"
457     " (hash sha1 #11223344556677889900AABBCCDDEEFF10203041#))\n";
458   static struct { const char *data; int expected_rc; } datas[] = {
459     { "(data\n (flags pkcs1)\n"
460       " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
461       0 },
462     { "(data\n (flags )\n"
463       " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
464       GCRYERR_CONFLICT },
465
466     { "(data\n (flags pkcs1)\n"
467       " (hash foo #11223344556677889900AABBCCDDEEFF10203040#))\n",
468       GCRYERR_INV_MD_ALGO },
469
470     { "(data\n (flags )\n"
471       " (value #11223344556677889900AA#))\n",
472       0 },
473
474     { "(data\n (flags raw)\n"
475       " (value #11223344556677889900AA#))\n",
476       0 },
477
478     { "(data\n (flags pkcs1)\n"
479       " (value #11223344556677889900AA#))\n",
480       GCRYERR_CONFLICT },
481
482     { "(data\n (flags raw foo)\n"
483       " (value #11223344556677889900AA#))\n",
484       GCRYERR_INV_FLAG },
485     
486     { NULL }
487   };
488
489   rc = gcry_sexp_sscan (&badhash, NULL, baddata, strlen (baddata));
490   if (rc)
491       die ("converting data failed: %s\n", gcry_strerror (rc));
492       
493   for (dataidx=0; datas[dataidx].data; dataidx++)
494     {
495       if (verbose)
496         fprintf (stderr, "signature test %d\n", dataidx);
497
498       rc = gcry_sexp_sscan (&hash, NULL, datas[dataidx].data,
499                             strlen (datas[dataidx].data));
500       if (rc)
501         die ("converting data failed: %s\n", gcry_strerror (rc));
502   
503       rc = gcry_pk_sign (&sig, hash, skey);
504       if (rc != datas[dataidx].expected_rc)
505         fail ("gcry_pk_sign failed: %s\n", gcry_strerror (rc));
506       
507       if (!rc)
508         verify_one_signature (pkey, hash, badhash, sig);
509
510       gcry_sexp_release (sig); sig= NULL;
511       gcry_sexp_release (hash); hash= NULL;
512     }
513
514   gcry_sexp_release (badhash);
515 }
516
517 /* Run all tests for the public key fucntions. */
518 static void
519 check_pubkey (void)
520 {
521   int rc;
522   GcrySexp skey, pkey;
523   unsigned char grip1[20], grip2[20];
524   
525   rc = gcry_sexp_sscan (&skey, NULL, sample_private_key_1,
526                         strlen (sample_private_key_1));
527   if (!rc)
528     rc = gcry_sexp_sscan (&pkey, NULL, sample_public_key_1,
529                           strlen (sample_public_key_1));
530   if (rc)
531     die ("converting sample key failed: %s\n", gcry_strerror (rc));
532
533   if (!gcry_pk_get_keygrip (pkey, grip1))
534     die ("get keygrip for public RSA key failed\n");
535   if (!gcry_pk_get_keygrip (skey, grip2))
536     die ("get keygrip for private RSA key failed\n");
537   if (memcmp (grip1, grip2, 20))
538     fail ("keygrips for RSA key don't match\n");
539   if (memcmp (grip1, sample_grip_key_1, 20))
540     fail ("wrong keygrip for RSA key\n");
541
542   /* FIXME: we need DSA and ElGamal example keys. */
543
544 /*    for (rc=0; rc < 20; rc++) */
545 /*      printf ("\\x%02x", grip1[rc]); */
546 /*    putchar ('\n'); */
547
548   check_pubkey_sign (skey, pkey);
549
550   gcry_sexp_release (skey);
551   gcry_sexp_release (pkey);
552 }
553
554
555
556 int
557 main (int argc, char **argv)
558 {
559   int debug = 0;
560
561   if (argc > 1 && !strcmp (argv[1], "--verbose"))
562     verbose = 1;
563   else if (argc > 1 && !strcmp (argv[1], "--debug"))
564     verbose = debug = 1;
565
566   /*gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING,0);*/
567   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
568   if (!gcry_check_version (GCRYPT_VERSION))
569     die ("version mismatch\n");
570   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
571   if (debug)
572     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
573   check_ciphers ();
574   check_aes128_cbc_cts_cipher ();
575   check_digests ();
576   check_pubkey ();
577   
578   return error_count? 1:0;
579 }