Line data Source code
1 : /* pkcs1v2.c - Test OAEP and PSS padding
2 : * Copyright (C) 2011 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, see <http://www.gnu.org/licenses/>.
18 : */
19 :
20 : #ifdef HAVE_CONFIG_H
21 : # include <config.h>
22 : #endif
23 : #include <stdio.h>
24 : #include <stdlib.h>
25 : #include <string.h>
26 : #include <stdarg.h>
27 :
28 : #ifdef _GCRYPT_IN_LIBGCRYPT
29 : # include "../src/gcrypt-int.h"
30 : #else
31 : # include <gcrypt.h>
32 : #endif
33 :
34 :
35 : #define PGM "pkcs1v2"
36 : #include "t-common.h"
37 :
38 :
39 : static void
40 0 : show_sexp (const char *prefix, gcry_sexp_t a)
41 : {
42 : char *buf;
43 : size_t size;
44 :
45 0 : if (prefix)
46 0 : fputs (prefix, stderr);
47 0 : size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
48 0 : buf = gcry_xmalloc (size);
49 :
50 0 : gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
51 0 : fprintf (stderr, "%.*s", (int)size, buf);
52 0 : gcry_free (buf);
53 0 : }
54 :
55 :
56 : /* Convert STRING consisting of hex characters into its binary
57 : representation and return it as an allocated buffer. The valid
58 : length of the buffer is returned at R_LENGTH. The string is
59 : delimited by end of string. The function returns NULL on
60 : error. */
61 : static void *
62 3510 : data_from_hex (const char *string, size_t *r_length)
63 : {
64 : const char *s;
65 : unsigned char *buffer;
66 : size_t length;
67 :
68 3510 : buffer = gcry_xmalloc (strlen(string)/2+1);
69 3510 : length = 0;
70 360019 : for (s=string; *s; s +=2 )
71 : {
72 356509 : if (!hexdigitp (s) || !hexdigitp (s+1))
73 0 : die ("error parsing hex string `%s'\n", string);
74 356509 : ((unsigned char*)buffer)[length++] = xtoi_2 (s);
75 : }
76 3510 : *r_length = length;
77 3510 : return buffer;
78 : }
79 :
80 :
81 : static int
82 1080 : extract_cmp_data (gcry_sexp_t sexp, const char *name, const char *expected,
83 : const char *description)
84 : {
85 : gcry_sexp_t l1;
86 : const void *a;
87 : size_t alen;
88 : void *b;
89 : size_t blen;
90 1080 : int rc = 0;
91 :
92 1080 : l1 = gcry_sexp_find_token (sexp, name, 0);
93 1080 : a = gcry_sexp_nth_data (l1, 1, &alen);
94 1080 : b = data_from_hex (expected, &blen);
95 1080 : if (!a)
96 : {
97 0 : info ("%s: parameter \"%s\" missing in key\n", description, name);
98 0 : rc = 1;
99 : }
100 1080 : else if ( alen != blen || memcmp (a, b, alen) )
101 : {
102 0 : info ("%s: parameter \"%s\" does not match expected value\n",
103 : description, name);
104 0 : rc = 1;
105 : }
106 1080 : gcry_free (b);
107 1080 : gcry_sexp_release (l1);
108 1080 : return rc;
109 : }
110 :
111 :
112 : /* Check against the OAEP test vectors from
113 : ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1d2-vec.zip . */
114 : static void
115 1 : check_oaep (void)
116 : {
117 : #include "pkcs1v2-oaep.h"
118 : gpg_error_t err;
119 : int tno, mno;
120 :
121 11 : for (tno = 0; tno < DIM (tbl); tno++)
122 : {
123 : void *rsa_n, *rsa_e, *rsa_d;
124 : size_t rsa_n_len, rsa_e_len, rsa_d_len;
125 : gcry_sexp_t sec_key, pub_key;
126 :
127 10 : if (verbose > 1)
128 0 : info ("(%s)\n", tbl[tno].desc);
129 :
130 10 : rsa_n = data_from_hex (tbl[tno].n, &rsa_n_len);
131 10 : rsa_e = data_from_hex (tbl[tno].e, &rsa_e_len);
132 10 : rsa_d = data_from_hex (tbl[tno].d, &rsa_d_len);
133 10 : err = gcry_sexp_build (&sec_key, NULL,
134 : "(private-key (rsa (n %b)(e %b)(d %b)))",
135 : (int)rsa_n_len, rsa_n,
136 : (int)rsa_e_len, rsa_e,
137 : (int)rsa_d_len, rsa_d);
138 10 : if (err)
139 0 : die ("constructing private key failed: %s\n", gpg_strerror (err));
140 10 : err = gcry_sexp_build (&pub_key, NULL,
141 : "(public-key (rsa (n %b)(e %b)))",
142 : (int)rsa_n_len, rsa_n,
143 : (int)rsa_e_len, rsa_e);
144 10 : if (err)
145 0 : die ("constructing public key failed: %s\n", gpg_strerror (err));
146 10 : gcry_free (rsa_n);
147 10 : gcry_free (rsa_e);
148 10 : gcry_free (rsa_d);
149 :
150 70 : for (mno = 0; mno < DIM (tbl[0].m); mno++)
151 : {
152 : void *mesg, *seed, *encr;
153 : size_t mesg_len, seed_len, encr_len;
154 : gcry_sexp_t plain, ciph;
155 :
156 60 : if (verbose)
157 0 : info ("running test: %s\n", tbl[tno].m[mno].desc);
158 :
159 60 : mesg = data_from_hex (tbl[tno].m[mno].mesg, &mesg_len);
160 60 : seed = data_from_hex (tbl[tno].m[mno].seed, &seed_len);
161 :
162 60 : err = gcry_sexp_build (&plain, NULL,
163 : "(data (flags oaep)(hash-algo sha1)"
164 : "(value %b)(random-override %b))",
165 : (int)mesg_len, mesg,
166 : (int)seed_len, seed);
167 60 : if (err)
168 0 : die ("constructing plain data failed: %s\n", gpg_strerror (err));
169 60 : gcry_free (mesg);
170 60 : gcry_free (seed);
171 :
172 60 : err = gcry_pk_encrypt (&ciph, plain, pub_key);
173 60 : if (err)
174 : {
175 0 : show_sexp ("plain:\n", ciph);
176 0 : fail ("gcry_pk_encrypt failed: %s\n", gpg_strerror (err));
177 : }
178 : else
179 : {
180 60 : if (extract_cmp_data (ciph, "a", tbl[tno].m[mno].encr,
181 : tbl[tno].m[mno].desc))
182 : {
183 0 : show_sexp ("encrypt result:\n", ciph);
184 0 : fail ("mismatch in gcry_pk_encrypt\n");
185 : }
186 60 : gcry_sexp_release (ciph);
187 60 : ciph = NULL;
188 : }
189 60 : gcry_sexp_release (plain);
190 60 : plain = NULL;
191 :
192 : /* Now test the decryption. */
193 60 : seed = data_from_hex (tbl[tno].m[mno].seed, &seed_len);
194 60 : encr = data_from_hex (tbl[tno].m[mno].encr, &encr_len);
195 :
196 60 : err = gcry_sexp_build (&ciph, NULL,
197 : "(enc-val (flags oaep)(hash-algo sha1)"
198 : "(random-override %b)"
199 : "(rsa (a %b)))",
200 : (int)seed_len, seed,
201 : (int)encr_len, encr);
202 60 : if (err)
203 0 : die ("constructing cipher data failed: %s\n", gpg_strerror (err));
204 60 : gcry_free (encr);
205 60 : gcry_free (seed);
206 :
207 60 : err = gcry_pk_decrypt (&plain, ciph, sec_key);
208 60 : if (err)
209 : {
210 0 : show_sexp ("ciph:\n", ciph);
211 0 : fail ("gcry_pk_decrypt failed: %s\n", gpg_strerror (err));
212 : }
213 : else
214 : {
215 60 : if (extract_cmp_data (plain, "value", tbl[tno].m[mno].mesg,
216 : tbl[tno].m[mno].desc))
217 : {
218 0 : show_sexp ("decrypt result:\n", plain);
219 0 : fail ("mismatch in gcry_pk_decrypt\n");
220 : }
221 60 : gcry_sexp_release (plain);
222 60 : plain = NULL;
223 : }
224 60 : gcry_sexp_release (ciph);
225 60 : ciph = NULL;
226 : }
227 :
228 10 : gcry_sexp_release (sec_key);
229 10 : gcry_sexp_release (pub_key);
230 : }
231 1 : }
232 :
233 :
234 : /* Check against the PSS test vectors from
235 : ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1d2-vec.zip . */
236 : static void
237 1 : check_pss (void)
238 : {
239 : #include "pkcs1v2-pss.h"
240 : gpg_error_t err;
241 : int tno, mno;
242 :
243 11 : for (tno = 0; tno < DIM (tbl); tno++)
244 : {
245 : void *rsa_n, *rsa_e, *rsa_d;
246 : size_t rsa_n_len, rsa_e_len, rsa_d_len;
247 : gcry_sexp_t sec_key, pub_key;
248 :
249 10 : if (verbose > 1)
250 0 : info ("(%s)\n", tbl[tno].desc);
251 :
252 10 : rsa_n = data_from_hex (tbl[tno].n, &rsa_n_len);
253 10 : rsa_e = data_from_hex (tbl[tno].e, &rsa_e_len);
254 10 : rsa_d = data_from_hex (tbl[tno].d, &rsa_d_len);
255 10 : err = gcry_sexp_build (&sec_key, NULL,
256 : "(private-key (rsa (n %b)(e %b)(d %b)))",
257 : (int)rsa_n_len, rsa_n,
258 : (int)rsa_e_len, rsa_e,
259 : (int)rsa_d_len, rsa_d);
260 10 : if (err)
261 0 : die ("constructing private key failed: %s\n", gpg_strerror (err));
262 10 : err = gcry_sexp_build (&pub_key, NULL,
263 : "(public-key (rsa (n %b)(e %b)))",
264 : (int)rsa_n_len, rsa_n,
265 : (int)rsa_e_len, rsa_e);
266 10 : if (err)
267 0 : die ("constructing public key failed: %s\n", gpg_strerror (err));
268 10 : gcry_free (rsa_n);
269 10 : gcry_free (rsa_e);
270 10 : gcry_free (rsa_d);
271 :
272 70 : for (mno = 0; mno < DIM (tbl[0].m); mno++)
273 : {
274 : void *mesg, *salt, *sign;
275 : size_t mesg_len, salt_len, sign_len;
276 : gcry_sexp_t sigtmpl, sig;
277 : char mhash[20];
278 :
279 60 : if (verbose)
280 0 : info ("running test: %s\n", tbl[tno].m[mno].desc);
281 :
282 60 : mesg = data_from_hex (tbl[tno].m[mno].mesg, &mesg_len);
283 60 : salt = data_from_hex (tbl[tno].m[mno].salt, &salt_len);
284 :
285 60 : gcry_md_hash_buffer (GCRY_MD_SHA1, mhash, mesg, mesg_len);
286 60 : err = gcry_sexp_build (&sigtmpl, NULL,
287 : "(data (flags pss)"
288 : "(hash sha1 %b)"
289 : "(random-override %b))",
290 : 20, mhash,
291 : (int)salt_len, salt);
292 60 : if (err)
293 0 : die ("constructing sig template failed: %s\n", gpg_strerror (err));
294 60 : gcry_free (mesg);
295 60 : gcry_free (salt);
296 :
297 60 : err = gcry_pk_sign (&sig, sigtmpl, sec_key);
298 60 : if (err)
299 : {
300 0 : show_sexp ("sigtmpl:\n", sigtmpl);
301 0 : fail ("gcry_pk_sign failed: %s\n", gpg_strerror (err));
302 : }
303 : else
304 : {
305 60 : if (extract_cmp_data (sig, "s", tbl[tno].m[mno].sign,
306 : tbl[tno].m[mno].desc))
307 : {
308 0 : show_sexp ("sign result:\n", sig);
309 0 : fail ("mismatch in gcry_pk_sign\n");
310 : }
311 60 : gcry_sexp_release (sig);
312 60 : sig = NULL;
313 : }
314 60 : gcry_sexp_release (sigtmpl);
315 60 : sigtmpl = NULL;
316 :
317 : /* Now test the verification. */
318 60 : salt = data_from_hex (tbl[tno].m[mno].salt, &salt_len);
319 60 : sign = data_from_hex (tbl[tno].m[mno].sign, &sign_len);
320 :
321 60 : err = gcry_sexp_build (&sig, NULL,
322 : "(sig-val(rsa(s %b)))",
323 : (int)sign_len, sign);
324 60 : if (err)
325 0 : die ("constructing verify data failed: %s\n", gpg_strerror (err));
326 60 : err = gcry_sexp_build (&sigtmpl, NULL,
327 : "(data (flags pss)"
328 : "(hash sha1 %b)"
329 : "(random-override %b))",
330 : 20, mhash,
331 : (int)salt_len, salt);
332 60 : if (err)
333 0 : die ("constructing verify tmpl failed: %s\n", gpg_strerror (err));
334 60 : gcry_free (sign);
335 60 : gcry_free (salt);
336 :
337 60 : err = gcry_pk_verify (sig, sigtmpl, pub_key);
338 60 : if (err)
339 : {
340 0 : show_sexp ("sig:\n", sig);
341 0 : show_sexp ("sigtmpl:\n", sigtmpl);
342 0 : fail ("gcry_pk_verify failed: %s\n", gpg_strerror (err));
343 : }
344 60 : gcry_sexp_release (sig);
345 60 : sig = NULL;
346 60 : gcry_sexp_release (sigtmpl);
347 60 : sigtmpl = NULL;
348 : }
349 :
350 10 : gcry_sexp_release (sec_key);
351 10 : gcry_sexp_release (pub_key);
352 : }
353 1 : }
354 :
355 :
356 : /* Check against PKCS#1 v1.5 encryption test vectors as found at
357 : ftp://ftp.rsa.com/pub/rsalabs/tmp/pkcs1v15crypt-vectors.txt . */
358 : static void
359 1 : check_v15crypt (void)
360 : {
361 : #include "pkcs1v2-v15c.h"
362 : gpg_error_t err;
363 : int tno, mno;
364 :
365 16 : for (tno = 0; tno < DIM (tbl); tno++)
366 : {
367 : void *rsa_n, *rsa_e, *rsa_d;
368 : size_t rsa_n_len, rsa_e_len, rsa_d_len;
369 : gcry_sexp_t sec_key, pub_key;
370 :
371 15 : if (verbose > 1)
372 0 : info ("(%s)\n", tbl[tno].desc);
373 :
374 15 : rsa_n = data_from_hex (tbl[tno].n, &rsa_n_len);
375 15 : rsa_e = data_from_hex (tbl[tno].e, &rsa_e_len);
376 15 : rsa_d = data_from_hex (tbl[tno].d, &rsa_d_len);
377 15 : err = gcry_sexp_build (&sec_key, NULL,
378 : "(private-key (rsa (n %b)(e %b)(d %b)))",
379 : (int)rsa_n_len, rsa_n,
380 : (int)rsa_e_len, rsa_e,
381 : (int)rsa_d_len, rsa_d);
382 15 : if (err)
383 0 : die ("constructing private key failed: %s\n", gpg_strerror (err));
384 15 : err = gcry_sexp_build (&pub_key, NULL,
385 : "(public-key (rsa (n %b)(e %b)))",
386 : (int)rsa_n_len, rsa_n,
387 : (int)rsa_e_len, rsa_e);
388 15 : if (err)
389 0 : die ("constructing public key failed: %s\n", gpg_strerror (err));
390 15 : gcry_free (rsa_n);
391 15 : gcry_free (rsa_e);
392 15 : gcry_free (rsa_d);
393 :
394 315 : for (mno = 0; mno < DIM (tbl[0].m); mno++)
395 : {
396 : void *mesg, *seed, *encr;
397 : size_t mesg_len, seed_len, encr_len;
398 : gcry_sexp_t plain, ciph;
399 :
400 300 : if (verbose)
401 0 : info ("running test: %s\n", tbl[tno].m[mno].desc);
402 :
403 300 : mesg = data_from_hex (tbl[tno].m[mno].mesg, &mesg_len);
404 300 : seed = data_from_hex (tbl[tno].m[mno].seed, &seed_len);
405 :
406 300 : err = gcry_sexp_build (&plain, NULL,
407 : "(data (flags pkcs1)(hash-algo sha1)"
408 : "(value %b)(random-override %b))",
409 : (int)mesg_len, mesg,
410 : (int)seed_len, seed);
411 300 : if (err)
412 0 : die ("constructing plain data failed: %s\n", gpg_strerror (err));
413 300 : gcry_free (mesg);
414 300 : gcry_free (seed);
415 :
416 300 : err = gcry_pk_encrypt (&ciph, plain, pub_key);
417 300 : if (err)
418 : {
419 0 : show_sexp ("plain:\n", ciph);
420 0 : fail ("gcry_pk_encrypt failed: %s\n", gpg_strerror (err));
421 : }
422 : else
423 : {
424 300 : if (extract_cmp_data (ciph, "a", tbl[tno].m[mno].encr,
425 : tbl[tno].m[mno].desc))
426 : {
427 0 : show_sexp ("encrypt result:\n", ciph);
428 0 : fail ("mismatch in gcry_pk_encrypt\n");
429 : }
430 300 : gcry_sexp_release (ciph);
431 300 : ciph = NULL;
432 : }
433 300 : gcry_sexp_release (plain);
434 300 : plain = NULL;
435 :
436 : /* Now test the decryption. */
437 300 : seed = data_from_hex (tbl[tno].m[mno].seed, &seed_len);
438 300 : encr = data_from_hex (tbl[tno].m[mno].encr, &encr_len);
439 :
440 300 : err = gcry_sexp_build (&ciph, NULL,
441 : "(enc-val (flags pkcs1)(hash-algo sha1)"
442 : "(random-override %b)"
443 : "(rsa (a %b)))",
444 : (int)seed_len, seed,
445 : (int)encr_len, encr);
446 300 : if (err)
447 0 : die ("constructing cipher data failed: %s\n", gpg_strerror (err));
448 300 : gcry_free (encr);
449 300 : gcry_free (seed);
450 :
451 300 : err = gcry_pk_decrypt (&plain, ciph, sec_key);
452 300 : if (err)
453 : {
454 0 : show_sexp ("ciph:\n", ciph);
455 0 : fail ("gcry_pk_decrypt failed: %s\n", gpg_strerror (err));
456 : }
457 : else
458 : {
459 300 : if (extract_cmp_data (plain, "value", tbl[tno].m[mno].mesg,
460 : tbl[tno].m[mno].desc))
461 : {
462 0 : show_sexp ("decrypt result:\n", plain);
463 0 : fail ("mismatch in gcry_pk_decrypt\n");
464 : }
465 300 : gcry_sexp_release (plain);
466 300 : plain = NULL;
467 : }
468 300 : gcry_sexp_release (ciph);
469 300 : ciph = NULL;
470 : }
471 :
472 15 : gcry_sexp_release (sec_key);
473 15 : gcry_sexp_release (pub_key);
474 : }
475 1 : }
476 :
477 :
478 : /* Check against PKCS#1 v1.5 signature test vectors as found at
479 : ftp://ftp.rsa.com/pub/rsalabs/tmp/pkcs1v15sign-vectors.txt . */
480 : static void
481 1 : check_v15sign (void)
482 : {
483 : #include "pkcs1v2-v15s.h"
484 : gpg_error_t err;
485 : int tno, mno;
486 :
487 16 : for (tno = 0; tno < DIM (tbl); tno++)
488 : {
489 : void *rsa_n, *rsa_e, *rsa_d;
490 : size_t rsa_n_len, rsa_e_len, rsa_d_len;
491 : gcry_sexp_t sec_key, pub_key;
492 :
493 15 : if (verbose > 1)
494 0 : info ("(%s)\n", tbl[tno].desc);
495 :
496 15 : rsa_n = data_from_hex (tbl[tno].n, &rsa_n_len);
497 15 : rsa_e = data_from_hex (tbl[tno].e, &rsa_e_len);
498 15 : rsa_d = data_from_hex (tbl[tno].d, &rsa_d_len);
499 15 : err = gcry_sexp_build (&sec_key, NULL,
500 : "(private-key (rsa (n %b)(e %b)(d %b)))",
501 : (int)rsa_n_len, rsa_n,
502 : (int)rsa_e_len, rsa_e,
503 : (int)rsa_d_len, rsa_d);
504 15 : if (err)
505 0 : die ("constructing private key failed: %s\n", gpg_strerror (err));
506 15 : err = gcry_sexp_build (&pub_key, NULL,
507 : "(public-key (rsa (n %b)(e %b)))",
508 : (int)rsa_n_len, rsa_n,
509 : (int)rsa_e_len, rsa_e);
510 15 : if (err)
511 0 : die ("constructing public key failed: %s\n", gpg_strerror (err));
512 15 : gcry_free (rsa_n);
513 15 : gcry_free (rsa_e);
514 15 : gcry_free (rsa_d);
515 :
516 315 : for (mno = 0; mno < DIM (tbl[0].m); mno++)
517 : {
518 : void *mesg, *sign;
519 : size_t mesg_len, sign_len;
520 : gcry_sexp_t sigtmpl, sig;
521 : char mhash[20];
522 :
523 300 : if (verbose)
524 0 : info ("running test: %s\n", tbl[tno].m[mno].desc);
525 :
526 300 : mesg = data_from_hex (tbl[tno].m[mno].mesg, &mesg_len);
527 :
528 300 : gcry_md_hash_buffer (GCRY_MD_SHA1, mhash, mesg, mesg_len);
529 300 : err = gcry_sexp_build (&sigtmpl, NULL,
530 : "(data (flags pkcs1)"
531 : "(hash sha1 %b))",
532 : 20, mhash);
533 300 : if (err)
534 0 : die ("constructing sig template failed: %s\n", gpg_strerror (err));
535 300 : gcry_free (mesg);
536 :
537 300 : err = gcry_pk_sign (&sig, sigtmpl, sec_key);
538 300 : if (err)
539 : {
540 0 : show_sexp ("sigtmpl:\n", sigtmpl);
541 0 : fail ("gcry_pk_sign failed: %s\n", gpg_strerror (err));
542 : }
543 : else
544 : {
545 300 : if (extract_cmp_data (sig, "s", tbl[tno].m[mno].sign,
546 : tbl[tno].m[mno].desc))
547 : {
548 0 : show_sexp ("sign result:\n", sig);
549 0 : fail ("mismatch in gcry_pk_sign\n");
550 : }
551 300 : gcry_sexp_release (sig);
552 300 : sig = NULL;
553 : }
554 300 : gcry_sexp_release (sigtmpl);
555 300 : sigtmpl = NULL;
556 :
557 : /* Now test the verification. */
558 300 : sign = data_from_hex (tbl[tno].m[mno].sign, &sign_len);
559 :
560 300 : err = gcry_sexp_build (&sig, NULL,
561 : "(sig-val(rsa(s %b)))",
562 : (int)sign_len, sign);
563 300 : if (err)
564 0 : die ("constructing verify data failed: %s\n", gpg_strerror (err));
565 300 : err = gcry_sexp_build (&sigtmpl, NULL,
566 : "(data (flags pkcs1)"
567 : "(hash sha1 %b))",
568 : 20, mhash);
569 300 : if (err)
570 0 : die ("constructing verify tmpl failed: %s\n", gpg_strerror (err));
571 300 : gcry_free (sign);
572 :
573 300 : err = gcry_pk_verify (sig, sigtmpl, pub_key);
574 300 : if (err)
575 : {
576 0 : show_sexp ("sig:\n", sig);
577 0 : show_sexp ("sigtmpl:\n", sigtmpl);
578 0 : fail ("gcry_pk_verify failed: %s\n", gpg_strerror (err));
579 : }
580 300 : gcry_sexp_release (sig);
581 300 : sig = NULL;
582 300 : gcry_sexp_release (sigtmpl);
583 300 : sigtmpl = NULL;
584 : }
585 :
586 15 : gcry_sexp_release (sec_key);
587 15 : gcry_sexp_release (pub_key);
588 : }
589 1 : }
590 :
591 :
592 : int
593 1 : main (int argc, char **argv)
594 : {
595 1 : int last_argc = -1;
596 1 : int run_oaep = 0;
597 1 : int run_pss = 0;
598 1 : int run_v15c = 0;
599 1 : int run_v15s = 0;
600 :
601 1 : if (argc)
602 1 : { argc--; argv++; }
603 :
604 2 : while (argc && last_argc != argc )
605 : {
606 0 : last_argc = argc;
607 0 : if (!strcmp (*argv, "--"))
608 : {
609 0 : argc--; argv++;
610 0 : break;
611 : }
612 0 : else if (!strcmp (*argv, "--verbose"))
613 : {
614 0 : verbose++;
615 0 : argc--; argv++;
616 : }
617 0 : else if (!strcmp (*argv, "--debug"))
618 : {
619 0 : verbose = 2;
620 0 : debug = 1;
621 0 : argc--; argv++;
622 : }
623 0 : else if (!strcmp (*argv, "--die"))
624 : {
625 0 : die_on_error = 1;
626 0 : argc--; argv++;
627 : }
628 0 : else if (!strcmp (*argv, "--oaep"))
629 : {
630 0 : run_oaep = 1;
631 0 : argc--; argv++;
632 : }
633 0 : else if (!strcmp (*argv, "--pss"))
634 : {
635 0 : run_pss = 1;
636 0 : argc--; argv++;
637 : }
638 0 : else if (!strcmp (*argv, "--v15c"))
639 : {
640 0 : run_v15c = 1;
641 0 : argc--; argv++;
642 : }
643 0 : else if (!strcmp (*argv, "--v15s"))
644 : {
645 0 : run_v15s = 1;
646 0 : argc--; argv++;
647 : }
648 : }
649 :
650 1 : if (!run_oaep && !run_pss && !run_v15c && !run_v15s)
651 1 : run_oaep = run_pss = run_v15c = run_v15s = 1;
652 :
653 1 : xgcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
654 1 : xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
655 1 : if (!gcry_check_version ("1.5.0"))
656 0 : die ("version mismatch\n");
657 1 : xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
658 1 : if (debug)
659 0 : xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
660 : /* No valuable keys are create, so we can speed up our RNG. */
661 1 : xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
662 :
663 1 : if (run_oaep)
664 1 : check_oaep ();
665 1 : if (run_pss)
666 1 : check_pss ();
667 1 : if (run_v15c)
668 1 : check_v15crypt ();
669 1 : if (run_v15s)
670 1 : check_v15sign ();
671 :
672 1 : if (verbose)
673 0 : fprintf (stderr, "\nAll tests completed. Errors: %i\n", error_count);
674 :
675 1 : return error_count ? 1 : 0;
676 : }
|
