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