ipsec-tools/racoon/eaytest.c

   1 /* $Id: eaytest.c,v 1.20.4.2 2005/06/28 22:38:02 manubsd Exp $ */
   2
   3 /*
   4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the project nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include "config.h"
  33
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <sys/socket.h>
  37
  38 #include <netinet/in.h>
  39
  40 #include <stdlib.h>
  41 #include <stdio.h>
  42 #include <string.h>
  43 #include <limits.h>
  44 #include <dirent.h>
  45 #include <fcntl.h>
  46 #include <unistd.h>
  47 #include <err.h>
  48
  49 #include <openssl/bio.h>
  50 #include <openssl/pem.h>
  51
  52 #include "var.h"
  53 #include "vmbuf.h"
  54 #include "misc.h"
  55 #include "debug.h"
  56 #include "str2val.h"
  57 #include "plog.h"
  58
  59 #include "oakley.h"
  60 #include "dhgroup.h"
  61 #include "crypto_openssl.h"
  62 #include "gnuc.h"
  63
  64 //#include "package_version.h"
  65
  66 #define PVDUMP(var) hexdump((var)->v, (var)->l)
  67
  68 /*#define CERTTEST_BROKEN */
  69
  70 /* prototype */
  71
  72 static vchar_t *pem_read_buf __P((char *));
  73 void Usage __P((void));
  74
  75 int rsatest __P((int, char **));
  76 int ciphertest __P((int, char **));
  77 int hmactest __P((int, char **));
  78 int sha1test __P((int, char **));
  79 int md5test __P((int, char **));
  80 int dhtest __P((int, char **));
  81 int bntest __P((int, char **));
  82 #ifndef CERTTEST_BROKEN
  83 static char **getcerts __P((char *));
  84 int certtest __P((int, char **));
  85 #endif
  86
  87 /* test */
  88
  89 static int
  90 rsa_verify_with_pubkey(src, sig, pubkey_txt)
  91         vchar_t *src, *sig;
  92         char *pubkey_txt;
  93 {
  94         BIO *bio;
  95         EVP_PKEY *evp;
  96         int error;
  97
  98         bio = BIO_new_mem_buf(pubkey_txt, strlen(pubkey_txt));
  99         evp = PEM_read_bio_PUBKEY(bio, NULL, NULL, NULL);
 100         if (! evp) {
 101                 printf ("PEM_read_PUBKEY(): %s\n", eay_strerror());
 102                 return -1;
 103         }
 104         error = eay_check_rsasign(src, sig, evp->pkey.rsa);
 105
 106         return error;
 107 }
 108
 109 int
 110 rsatest(ac, av)
 111         int ac;
 112         char **av;
 113 {
 114         char *text = "this is test.";
 115         vchar_t src;
 116         vchar_t *priv, *sig;
 117         int loglevel_saved;
 118
 119         char *pkcs1 =
 120 "-----BEGIN RSA PRIVATE KEY-----\n"
 121 "MIICXQIBAAKBgQChe5/Fzk9SA0vCKBOcu9jBcLb9oLv50PeuEfQojhakY+OH8A3Q\n"
 122 "M8A0qIDG6uhTNGPvzCWb/+mKeOB48n5HJpLxlDFyP3kyd2yXHIZ/MN8g1nh4FsB0\n"
 123 "iTkk8QUCJkkan6FCOBrIeLEsGA5AdodzuR+khnCMt8vO+NFHZYKAQeynyQIDAQAB\n"
 124 "AoGAOfDcnCHxjhDGrwyoNNWl6Yqi7hAtQm67YAbrH14UO7nnmxAENM9MyNgpFLaW\n"
 125 "07v5m8IZQIcradcDXAJOUwNBN8E06UflwEYCaScIwndvr5UpVlN3e2NC6Wyg2yC7\n"
 126 "GarxQput3zj35XNR5bK42UneU0H6zDxpHWqI1SwE+ToAHu0CQQDNl9gUJTpg0L09\n"
 127 "HkbE5jeb8bA5I20nKqBOBP0v5tnzpwu41umQwk9I7Ru0ucD7j+DW4k8otadW+FnI\n"
 128 "G1M1MpSjAkEAyRMt4bN8otfpOpsOQWzw4jQtouohOxRFCrQTntHhU20PrQnQLZWs\n"
 129 "pOVzqCjRytYtkPEUA1z8QK5gGcVPcOQsowJBALmt2rwPB1NrEo5Bat7noO+Zb3Ob\n"
 130 "WDiYWeE8xkHd95gDlSWiC53ur9aINo6ZeP556jGIgL+el/yHHecJLrQL84sCQH48\n"
 131 "zUxq/C/cb++8UzneJGlPqusiJNTLiAENR1gpmlZfHT1c8Nb9phMsfu0vG29GAfuC\n"
 132 "bzchVLljALCNQK+2gRMCQQCNIgN+R9mRWZhFAcC1sq++YnuSBlw4VwdL/fd1Yg9e\n"
 133 "Ul+U98yPl/NXt8Rs4TRBFcOZjkFI8xv0hQtevTgTmgz+\n"
 134 "-----END RSA PRIVATE KEY-----\n\n";
 135         char *pubkey =
 136 "-----BEGIN PUBLIC KEY-----\n"
 137 "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQChe5/Fzk9SA0vCKBOcu9jBcLb9\n"
 138 "oLv50PeuEfQojhakY+OH8A3QM8A0qIDG6uhTNGPvzCWb/+mKeOB48n5HJpLxlDFy\n"
 139 "P3kyd2yXHIZ/MN8g1nh4FsB0iTkk8QUCJkkan6FCOBrIeLEsGA5AdodzuR+khnCM\n"
 140 "t8vO+NFHZYKAQeynyQIDAQAB\n"
 141 "-----END PUBLIC KEY-----\n\n";
 142         char *pubkey_wrong =
 143 "-----BEGIN PUBLIC KEY-----\n"
 144 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwDncG2tSokRBhK8la1mO\n"
 145 "QnUpxg6KvpoFUjEyRiIE1GRap5V6jCCEOmA9ZAz4Oa/97oxewwMWtchIxSBZVCia\n"
 146 "H9oGasbOFzrtSR+MKl6Cb/Ow3Fu+PKbHTsnfTk/nOOWyaQh91PRD7fdwHe8L9P7w\n"
 147 "2kFPmDW6+RNKIR4OErhXf1O0eSShPe0TO3vx43O7dWqhmh3Kgr4Jq7zAGqHtwu0B\n"
 148 "RFZnmsocOnVZb2yAHndp51/Mk1H37ThHwN7qMx7RqrS3ru3XtchpJd9IQJPBIRfY\n"
 149 "VYQ68u5ix/Z80Y6VkRf0qnAvel8B6D3N3Zyq5u7G60PfvvtCybeMn7nVrSMxqMW/\n"
 150 "xwIDAQAB\n"
 151 "-----END PUBLIC KEY-----\n\n";
 152
 153         printf ("%s", pkcs1);
 154         printf ("%s", pubkey);
 155         priv = pem_read_buf(pkcs1);
 156
 157         src.v = text;
 158         src.l = strlen(text);
 159
 160         /* sign */
 161         sig = eay_get_x509sign(&src, priv);
 162         if (sig == NULL) {
 163                 printf("sign failed. %s\n", eay_strerror());
 164                 return -1;
 165         }
 166
 167         printf("RSA signed data.\n");
 168         PVDUMP(sig);
 169
 170         printf("Verification with correct pubkey: ");
 171         if (rsa_verify_with_pubkey (&src, sig, pubkey) != 0) {
 172                 printf ("Failed.\n");
 173                 return -1;
 174         }
 175         else
 176                 printf ("Verified. Good.\n");
 177
 178         loglevel_saved = loglevel;
 179         loglevel = 0;
 180         printf("Verification with wrong pubkey: ");
 181         if (rsa_verify_with_pubkey (&src, sig, pubkey_wrong) != 0)
 182                 printf ("Not verified. Good.\n");
 183         else {
 184                 printf ("Verified. This is bad...\n");
 185                 loglevel = loglevel_saved;
 186                 return -1;
 187         }
 188         loglevel = loglevel_saved;
 189
 190         return 0;
 191 }
 192
 193 static vchar_t *
 194 pem_read_buf(buf)
 195         char *buf;
 196 {
 197         BIO *bio;
 198         char *nm = NULL, *header = NULL;
 199         unsigned char *data = NULL;
 200         long len;
 201         vchar_t *ret;
 202         int error;
 203
 204         bio = BIO_new_mem_buf(buf, strlen(buf));
 205         error = PEM_read_bio(bio, &nm, &header, &data, &len);
 206         if (error == 0)
 207                 errx(1, "%s", eay_strerror());
 208         ret = vmalloc(len);
 209         if (ret == NULL)
 210                 err(1, "vmalloc");
 211         memcpy(ret->v, data, len);
 212
 213         return ret;
 214 }
 215
 216 #ifndef CERTTEST_BROKEN
 217 int
 218 certtest(ac, av)
 219         int ac;
 220         char **av;
 221 {
 222         char *certpath;
 223         char **certs;
 224         int type;
 225         int error;
 226
 227         printf("\n**Test for Certificate.**\n");
 228
 229     {
 230         vchar_t *asn1dn = NULL, asn1dn0;
 231 #ifdef ORIG_DN
 232         char dnstr[] = "C=JP, ST=Kanagawa, L=Fujisawa, O=WIDE Project, OU=KAME Project, CN=Shoichi Sakane/Email=sakane@kame.net";
 233         char *dnstr_w1 = 0;
 234         char *dnstr_w2 = 0;
 235         char dn0[] = {
 236                 0x30,0x81,0x9a,0x31,0x0b,0x30,0x09,0x06,
 237                 0x03,0x55,0x04,0x06,0x13,0x02,0x4a,0x50,
 238                 0x31,0x11,0x30,0x0f,0x06,0x03,0x55,0x04,
 239                 0x08,0x13,0x08,0x4b,0x61,0x6e,0x61,0x67,
 240                 0x61,0x77,0x61,0x31,0x11,0x30,0x0f,0x06,
 241                 0x03,0x55,0x04,0x07,0x13,0x08,0x46,0x75,
 242                 0x6a,0x69,0x73,0x61,0x77,0x61,0x31,0x15,
 243                 0x30,0x13,0x06,0x03,0x55,0x04,0x0a,0x13,
 244                 0x0c,0x57,0x49,0x44,0x45,0x20,0x50,0x72,
 245                 0x6f,0x6a,0x65,0x63,0x74,0x31,0x15,0x30,
 246                 0x13,0x06,0x03,0x55,0x04,0x0b,0x13,0x0c,
 247                 0x4b,0x41,0x4d,0x45,0x20,0x50,0x72,0x6f,
 248                 0x6a,0x65,0x63,0x74,0x31,0x17,0x30,0x15,
 249                 0x06,0x03,0x55,0x04,0x03,0x13,0x0e,0x53,
 250                 0x68,0x6f,0x69,0x63,0x68,0x69,0x20,0x53,
 251                 0x61,0x6b,0x61,0x6e,0x65,0x31,0x1e,0x30,
 252                 0x1c,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,
 253                 0x0d,0x01,0x09,0x01,
 254                 0x0c,   /* <== XXX */
 255                 0x0f,0x73,0x61,
 256                 0x6b,0x61,0x6e,0x65,0x40,0x6b,0x61,0x6d,
 257                 0x65,0x2e,0x6e,0x65,0x74,
 258         };
 259 #else /* not ORIG_DN */
 260         char dnstr[] = "C=JP, ST=Kanagawa, L=Fujisawa, O=WIDE Project, OU=KAME Project, CN=Shoichi Sakane";
 261         char dnstr_w1[] = "C=JP, ST=Kanagawa, L=Fujisawa, O=WIDE Project, OU=*, CN=Shoichi Sakane";
 262         char dnstr_w2[] = "C=JP, ST=Kanagawa, L=Fujisawa, O=WIDE Project, OU=KAME Project, CN=*";
 263         char dn0[] = {
 264                 0x30,0x7a,0x31,0x0b,0x30,0x09,0x06,0x03,
 265                 0x55,0x04,0x06,0x13,0x02,0x4a,0x50,0x31,
 266                 0x11,0x30,0x0f,0x06,0x03,0x55,0x04,0x08,
 267                 0x13,0x08,0x4b,0x61,0x6e,0x61,0x67,0x61,
 268                 0x77,0x61,0x31,0x11,0x30,0x0f,0x06,0x03,
 269                 0x55,0x04,0x07,0x13,0x08,0x46,0x75,0x6a,
 270                 0x69,0x73,0x61,0x77,0x61,0x31,0x15,0x30,
 271                 0x13,0x06,0x03,0x55,0x04,0x0a,0x13,0x0c,
 272                 0x57,0x49,0x44,0x45,0x20,0x50,0x72,0x6f,
 273                 0x6a,0x65,0x63,0x74,0x31,0x15,0x30,0x13,
 274                 0x06,0x03,0x55,0x04,0x0b,0x13,0x0c,0x4b,
 275                 0x41,0x4d,0x45,0x20,0x50,0x72,0x6f,0x6a,
 276                 0x65,0x63,0x74,0x31,0x17,0x30,0x15,0x06,
 277                 0x03,0x55,0x04,0x03,0x13,0x0e,0x53,0x68,
 278                 0x6f,0x69,0x63,0x68,0x69,0x20,0x53,0x61,
 279                 0x6b,0x61,0x6e,0x65,
 280         };
 281 #endif /* ORIG_DN */
 282
 283         printf("check to convert the string into subjectName.\n");
 284         printf("%s\n", dnstr);
 285
 286         asn1dn0.v = dn0;
 287         asn1dn0.l = sizeof(dn0);
 288
 289         asn1dn = eay_str2asn1dn(dnstr, strlen(dnstr));
 290         if (asn1dn == NULL || asn1dn->l != asn1dn0.l)
 291 #ifdef OUTPUT_VALID_ASN1DN
 292         {
 293                 unsigned char *cp; int  i;
 294                 printf("asn1dn length mismatched (%zu != %zu).\n", asn1dn ? asn1dn->l : -1, asn1dn0.l);
 295                 for (cp = asn1dn->v, i = 0; i < asn1dn->l; i++)
 296                     printf ("0x%02x,", *cp++);
 297                 exit (1);
 298         }
 299 #else
 300                 errx(1, "asn1dn length mismatched (%zu != %zu).\n", asn1dn ? asn1dn->l : -1, asn1dn0.l);
 301 #endif
 302
 303         /*
 304          * NOTE: The value pointed by "<==" above is different from the
 305          * return of eay_str2asn1dn().  but eay_cmp_asn1dn() can distinguish
 306          * both of the names are same name.
 307          */
 308         if (eay_cmp_asn1dn(&asn1dn0,  asn1dn))
 309                 errx(1, "asn1dn mismatched.\n");
 310         vfree(asn1dn);
 311
 312         printf("exact match: succeed.\n");
 313
 314         if (dnstr_w1) {
 315                 asn1dn = eay_str2asn1dn(dnstr_w1, strlen(dnstr_w1));
 316                 if (asn1dn == NULL || asn1dn->l == asn1dn0.l)
 317                         errx(1, "asn1dn length wrong for wildcard 1\n");
 318                 if (eay_cmp_asn1dn(&asn1dn0,  asn1dn))
 319                         errx(1, "asn1dn mismatched for wildcard 1.\n");
 320                 vfree(asn1dn);
 321                 printf("wildcard 1 match: succeed.\n");
 322         }
 323
 324         if (dnstr_w1) {
 325                 asn1dn = eay_str2asn1dn(dnstr_w2, strlen(dnstr_w2));
 326                 if (asn1dn == NULL || asn1dn->l == asn1dn0.l)
 327                         errx(1, "asn1dn length wrong for wildcard 2\n");
 328                 if (eay_cmp_asn1dn(&asn1dn0,  asn1dn))
 329                         errx(1, "asn1dn mismatched for wildcard 2.\n");
 330                 vfree(asn1dn);
 331                 printf("wildcard 2 match: succeed.\n");
 332         }
 333
 334     }
 335         eay_init();
 336
 337         /* get certs */
 338         if (ac > 1) {
 339                 certpath = *(av + 1);
 340                 certs = getcerts(certpath);
 341         } else {
 342 #ifdef ORIG_DN
 343                 printf("\nCAUTION: These certificates are probably invalid "
 344                         "on your environment because you don't have their "
 345                         "issuer's certs in your environment.\n\n");
 346
 347                 certpath = "/usr/local/openssl/certs";
 348                 certs = getcerts(NULL);
 349 #else
 350                 printf("\nWARNING: The main certificates are probably invalid "
 351                         "on your environment\nbecause you don't have their "
 352                         "issuer's certs in your environment\nso not doing "
 353                         "this test.\n\n");
 354                 return (0);
 355 #endif
 356         }
 357
 358         while (*certs != NULL) {
 359
 360                 vchar_t c;
 361                 char *str;
 362                 vchar_t *vstr;
 363
 364                 printf("===CERT===\n");
 365
 366                 c.v = *certs;
 367                 c.l = strlen(*certs);
 368
 369                 /* print text */
 370                 str = eay_get_x509text(&c);
 371                 printf("%s", str);
 372                 racoon_free(str);
 373
 374                 /* print ASN.1 of subject name */
 375                 vstr = eay_get_x509asn1subjectname(&c);
 376                 if (!vstr)
 377                         return 0;
 378                 PVDUMP(vstr);
 379                 printf("\n");
 380                 vfree(vstr);
 381
 382 #ifdef __APPLE__
 383                 /* print subject alt name */
 384             {
 385                 int pos;
 386                 int len;
 387                 for (pos = 1; ; pos++) {
 388                         error = eay_get_x509subjectaltname(&c, &str, &type, pos, &len);
 389                         if (error) {
 390                                 printf("no subjectaltname found.\n");
 391                                 break;
 392                         }
 393                         if (!str)
 394                                 break;
 395                         printf("SubjectAltName: %d: %s\n", type, str);
 396                         racoon_free(str);
 397                 }
 398             }
 399 #else
 400                 /* print subject alt name */
 401             {
 402                 int pos;
 403                 for (pos = 1; ; pos++) {
 404                         error = eay_get_x509subjectaltname(&c, &str, &type, pos);
 405                         if (error) {
 406                                 printf("no subjectaltname found.\n");
 407                                 break;
 408                         }
 409                         if (!str)
 410                                 break;
 411                         printf("SubjectAltName: %d: %s\n", type, str);
 412                         racoon_free(str);
 413                 }
 414             }
 415 #endif
 416
 417                 /* NULL => name of the certificate file */
 418                 error = eay_check_x509cert(&c, certpath, NULL, 1);
 419                 if (error)
 420                         printf("ERROR: cert is invalid.\n");
 421                 printf("\n");
 422
 423                 certs++;
 424         }
 425         return 0;
 426 }
 427
 428 static char **
 429 getcerts(path)
 430         char *path;
 431 {
 432         char **certs = NULL, **p;
 433         DIR *dirp;
 434         struct dirent *dp;
 435         struct stat sb;
 436         char buf[512];
 437         int len;
 438         int n;
 439         int fd;
 440
 441         static char *samplecerts[] = {
 442 /* self signed */
 443 "-----BEGIN CERTIFICATE-----\n"
 444 "MIICpTCCAg4CAQAwDQYJKoZIhvcNAQEEBQAwgZoxCzAJBgNVBAYTAkpQMREwDwYD\n"
 445 "VQQIEwhLYW5hZ2F3YTERMA8GA1UEBxMIRnVqaXNhd2ExFTATBgNVBAoTDFdJREUg\n"
 446 "UHJvamVjdDEVMBMGA1UECxMMS0FNRSBQcm9qZWN0MRcwFQYDVQQDEw5TaG9pY2hp\n"
 447 "IFNha2FuZTEeMBwGCSqGSIb3DQEJARYPc2FrYW5lQGthbWUubmV0MB4XDTAwMDgy\n"
 448 "NDAxMzc0NFoXDTAwMDkyMzAxMzc0NFowgZoxCzAJBgNVBAYTAkpQMREwDwYDVQQI\n"
 449 "EwhLYW5hZ2F3YTERMA8GA1UEBxMIRnVqaXNhd2ExFTATBgNVBAoTDFdJREUgUHJv\n"
 450 "amVjdDEVMBMGA1UECxMMS0FNRSBQcm9qZWN0MRcwFQYDVQQDEw5TaG9pY2hpIFNh\n"
 451 "a2FuZTEeMBwGCSqGSIb3DQEJARYPc2FrYW5lQGthbWUubmV0MIGfMA0GCSqGSIb3\n"
 452 "DQEBAQUAA4GNADCBiQKBgQCpIQG/H3zn4czAmPBcbkDrYxE1A9vcpghpib3Of0Op\n"
 453 "SsiWIBOyIMiVAzK/I/JotWp3Vdn5fzGp/7DGAbWXAALas2xHkNmTMPpu6qhmNQ57\n"
 454 "kJHZHal24mgc1hwbrI9fb5olvIexx9a1riNPnKMRVHzXYizsyMbf+lJJmZ8QFhWN\n"
 455 "twIDAQABMA0GCSqGSIb3DQEBBAUAA4GBACKs6X/BYycuHI3iop403R3XWMHHnNBN\n"
 456 "5XTHVWiWgR1cMWkq/dp51gn+nPftpdAaYGpqGkiHGhZcXLoBaX9uON3p+7av+sQN\n"
 457 "plXwnvUf2Zsgu+fojskS0gKcDlYiq1O8TOaBgJouFZgr1q6PiYjVEJGogAP28+HN\n"
 458 "M4o+GBFbFoqK\n"
 459 "-----END CERTIFICATE-----\n\n",
 460 /* signed by SSH testing CA + CA1 + CA2 */
 461 "-----BEGIN X509 CERTIFICATE-----\n"
 462 "MIICtTCCAj+gAwIBAgIEOaR8NjANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJG\n"
 463 "STEkMCIGA1UEChMbU1NIIENvbW11bmljYXRpb25zIFNlY3VyaXR5MREwDwYDVQQL\n"
 464 "EwhXZWIgdGVzdDEbMBkGA1UEAxMSVGVzdCBDQSAxIHN1YiBjYSAyMB4XDTAwMDgy\n"
 465 "NDAwMDAwMFoXDTAwMTAwMTAwMDAwMFowgZoxCzAJBgNVBAYTAkpQMREwDwYDVQQI\n"
 466 "EwhLYW5hZ2F3YTERMA8GA1UEBxMIRnVqaXNhd2ExFTATBgNVBAoTDFdJREUgUHJv\n"
 467 "amVjdDEVMBMGA1UECxMMS0FNRSBQcm9qZWN0MRcwFQYDVQQDEw5TaG9pY2hpIFNh\n"
 468 "a2FuZTEeMBwGCSqGSIb3DQEJAQwPc2FrYW5lQGthbWUubmV0MIGfMA0GCSqGSIb3\n"
 469 "DQEBAQUAA4GNADCBiQKBgQCpIQG/H3zn4czAmPBcbkDrYxE1A9vcpghpib3Of0Op\n"
 470 "SsiWIBOyIMiVAzK/I/JotWp3Vdn5fzGp/7DGAbWXAALas2xHkNmTMPpu6qhmNQ57\n"
 471 "kJHZHal24mgc1hwbrI9fb5olvIexx9a1riNPnKMRVHzXYizsyMbf+lJJmZ8QFhWN\n"
 472 "twIDAQABo18wXTALBgNVHQ8EBAMCBaAwGgYDVR0RBBMwEYEPc2FrYW5lQGthbWUu\n"
 473 "bmV0MDIGA1UdHwQrMCkwJ6AloCOGIWh0dHA6Ly9sZGFwLnNzaC5maS9jcmxzL2Nh\n"
 474 "MS0yLmNybDANBgkqhkiG9w0BAQUFAANhADtaqual41OWshF/rwCTuR6zySBJysGp\n"
 475 "+qjkp5efCiYKhAu1L4WXlMsV/SNdzspui5tHasPBvUw8gzFsU/VW/B2zuQZkimf1\n"
 476 "u6ZPjUb/vt8vLOPScP5MeH7xrTk9iigsqQ==\n"
 477 "-----END X509 CERTIFICATE-----\n\n",
 478 /* VP100 */
 479 "-----BEGIN CERTIFICATE-----\n"
 480 "MIICXzCCAcigAwIBAgIEOXGBIzANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJG\n"
 481 "STEkMCIGA1UEChMbU1NIIENvbW11bmljYXRpb25zIFNlY3VyaXR5MREwDwYDVQQL\n"
 482 "EwhXZWIgdGVzdDESMBAGA1UEAxMJVGVzdCBDQSAxMB4XDTAwMDcxNjAwMDAwMFoX\n"
 483 "DTAwMDkwMTAwMDAwMFowNTELMAkGA1UEBhMCanAxETAPBgNVBAoTCHRhaGl0ZXN0\n"
 484 "MRMwEQYDVQQDEwpmdXJ1a2F3YS0xMIGdMA0GCSqGSIb3DQEBAQUAA4GLADCBhwKB\n"
 485 "gQDUmI2RaAuoLvtRDbASwRhbkj/Oq0BBIKgAqbFknc/EanJSQwZQu82gD88nf7gG\n"
 486 "VEioWmKPLDuEjz5JCuM+k5f7HYHI1wWmz1KFr7UA+avZm4Kp6YKnhuH7soZp7kBL\n"
 487 "hTiZEpL0jdmCWLW3ZXoro55rmPrBsCd+bt8VU6tRZm5dUwIBKaNZMFcwCwYDVR0P\n"
 488 "BAQDAgWgMBYGA1UdEQQPMA2CBVZQMTAwhwQKFIaFMDAGA1UdHwQpMCcwJaAjoCGG\n"
 489 "H2h0dHA6Ly9sZGFwLnNzaC5maS9jcmxzL2NhMS5jcmwwDQYJKoZIhvcNAQEFBQAD\n"
 490 "gYEAKJ/2Co/KYW65mwpGG3CBvsoRL8xyUMHGt6gQpFLHiiHuAdix1ADTL6uoFuYi\n"
 491 "4sE5omQm1wKVv2ZhS03zDtUfKoVEv0HZ7IY3AU/FZT/M5gQvbt43Dki/ma3ock2I\n"
 492 "PPhbLsvXm+GCVh3jvkYGk1zr7VERVeTPtmT+hW63lcxfFp4=\n"
 493 "-----END CERTIFICATE-----\n\n",
 494 /* IKED */
 495 "-----BEGIN CERTIFICATE-----\n"
 496 "MIIEFTCCA7+gAwIBAgIKYU5X6AAAAAAACTANBgkqhkiG9w0BAQUFADCBljEpMCcG\n"
 497 "CSqGSIb3DQEJARYaeS13YXRhbmFAc2RsLmhpdGFjaGkuY28uanAxCzAJBgNVBAYT\n"
 498 "AkpQMREwDwYDVQQIEwhLQU5BR0FXQTERMA8GA1UEBxMIWW9rb2hhbWExEDAOBgNV\n"
 499 "BAoTB0hJVEFDSEkxDDAKBgNVBAsTA1NETDEWMBQGA1UEAxMNSVBzZWMgVGVzdCBD\n"
 500 "QTAeFw0wMDA3MTUwMjUxNDdaFw0wMTA3MTUwMzAxNDdaMEUxCzAJBgNVBAYTAkpQ\n"
 501 "MREwDwYDVQQIEwhLQU5BR0FXQTEQMA4GA1UEChMHSElUQUNISTERMA8GA1UEAxMI\n"
 502 "V0FUQU5BQkUwXDANBgkqhkiG9w0BAQEFAANLADBIAkEA6Wja5A7Ldzrtx+rMWHEB\n"
 503 "Cyt+/ZoG0qdFQbuuUiU1vOSq+1f+ZSCYAdTq13Lrr6Xfz3jDVFEZLPID9PSTFwq+\n"
 504 "yQIDAQABo4ICPTCCAjkwDgYDVR0PAQH/BAQDAgTwMBMGA1UdJQQMMAoGCCsGAQUF\n"
 505 "CAICMB0GA1UdDgQWBBTkv7/MH5Ra+S1zBAmnUIH5w8ZTUTCB0gYDVR0jBIHKMIHH\n"
 506 "gBQsF2qoaTl5F3GFLKrttaxPJ8j4faGBnKSBmTCBljEpMCcGCSqGSIb3DQEJARYa\n"
 507 "eS13YXRhbmFAc2RsLmhpdGFjaGkuY28uanAxCzAJBgNVBAYTAkpQMREwDwYDVQQI\n"
 508 "EwhLQU5BR0FXQTERMA8GA1UEBxMIWW9rb2hhbWExEDAOBgNVBAoTB0hJVEFDSEkx\n"
 509 "DDAKBgNVBAsTA1NETDEWMBQGA1UEAxMNSVBzZWMgVGVzdCBDQYIQeccIf4GYDIBA\n"
 510 "rS6HSUt8XjB7BgNVHR8EdDByMDagNKAyhjBodHRwOi8vZmxvcmEyMjAvQ2VydEVu\n"
 511 "cm9sbC9JUHNlYyUyMFRlc3QlMjBDQS5jcmwwOKA2oDSGMmZpbGU6Ly9cXGZsb3Jh\n"
 512 "MjIwXENlcnRFbnJvbGxcSVBzZWMlMjBUZXN0JTIwQ0EuY3JsMIGgBggrBgEFBQcB\n"
 513 "AQSBkzCBkDBFBggrBgEFBQcwAoY5aHR0cDovL2Zsb3JhMjIwL0NlcnRFbnJvbGwv\n"
 514 "ZmxvcmEyMjBfSVBzZWMlMjBUZXN0JTIwQ0EuY3J0MEcGCCsGAQUFBzAChjtmaWxl\n"
 515 "Oi8vXFxmbG9yYTIyMFxDZXJ0RW5yb2xsXGZsb3JhMjIwX0lQc2VjJTIwVGVzdCUy\n"
 516 "MENBLmNydDANBgkqhkiG9w0BAQUFAANBAG8yZAWHb6g3zba453Hw5loojVDZO6fD\n"
 517 "9lCsyaxeo9/+7x1JEEcdZ6qL7KKqe7ZBwza+hIN0ITkp2WEWo22gTz4=\n"
 518 "-----END CERTIFICATE-----\n\n",
 519 /* From Entrust */
 520 "-----BEGIN CERTIFICATE-----\n"
 521 "MIIDXTCCAsagAwIBAgIEOb6khTANBgkqhkiG9w0BAQUFADA4MQswCQYDVQQGEwJV\n"
 522 "UzEQMA4GA1UEChMHRW50cnVzdDEXMBUGA1UECxMOVlBOIEludGVyb3AgUk8wHhcN\n"
 523 "MDAwOTE4MjMwMDM3WhcNMDMwOTE4MjMzMDM3WjBTMQswCQYDVQQGEwJVUzEQMA4G\n"
 524 "A1UEChMHRW50cnVzdDEXMBUGA1UECxMOVlBOIEludGVyb3AgUk8xGTAXBgNVBAMT\n"
 525 "EFNob2ljaGkgU2FrYW5lIDIwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAKj3\n"
 526 "eXSt1qXxFXzpa265B/NQYk5BZN7pNJg0tlTKBTVV3UgpQ92Bx5DoNfZh11oIv0Sw\n"
 527 "6YnG5p9F9ma36U9HDoD3hVTjAvQKy4ssCsnU1y6v5XOU1QvYQo6UTzgsXUTaIau4\n"
 528 "Lrccl+nyoiNzy3lG51tLR8CxuA+3OOAK9xPjszClAgMBAAGjggFXMIIBUzBABgNV\n"
 529 "HREEOTA3gQ9zYWthbmVAa2FtZS5uZXSHBM6vIHWCHjIwNi0xNzUtMzItMTE3LnZw\n"
 530 "bndvcmtzaG9wLmNvbTATBgNVHSUEDDAKBggrBgEFBQgCAjALBgNVHQ8EBAMCAKAw\n"
 531 "KwYDVR0QBCQwIoAPMjAwMDA5MTgyMzAwMzdagQ8yMDAyMTAyNTExMzAzN1owWgYD\n"
 532 "VR0fBFMwUTBPoE2gS6RJMEcxCzAJBgNVBAYTAlVTMRAwDgYDVQQKEwdFbnRydXN0\n"
 533 "MRcwFQYDVQQLEw5WUE4gSW50ZXJvcCBSTzENMAsGA1UEAxMEQ1JMMTAfBgNVHSME\n"
 534 "GDAWgBTzVmhu0tBoWKwkZE5mXpooE9630DAdBgNVHQ4EFgQUEgBHPtXggJqei5Xz\n"
 535 "92CrWXTJxfAwCQYDVR0TBAIwADAZBgkqhkiG9n0HQQAEDDAKGwRWNS4wAwIEsDAN\n"
 536 "BgkqhkiG9w0BAQUFAAOBgQCIFriNGMUE8GH5LuDrTJfA8uGx8vLy2seljuo694TR\n"
 537 "et/ojp9QnfOJ1PF9iAdGaEaSLfkwhY4fZNZzxic5HBoHLeo9BXLP7i7FByXjvOZC\n"
 538 "Y8++0dC8NVvendIILcJBM5nbDq1TqIbb8K3SP80XhO5JLVJkoZiQftAMjo0peZPO\n"
 539 "EQ==\n"
 540 "-----END CERTIFICATE-----\n\n",
 541         NULL,
 542         };
 543
 544         if (path == NULL)
 545                 return (char **)&samplecerts;
 546
 547         stat(path, &sb);
 548         if (!(sb.st_mode & S_IFDIR)) {
 549                 printf("ERROR: %s is not directory.\n", path);
 550                 exit(0);
 551         }
 552
 553         dirp = opendir(path);
 554         if (dirp == NULL) {
 555                 printf("opendir failed.\n");
 556                 exit(0);
 557         }
 558
 559         n = 0;
 560         while ((dp = readdir(dirp)) != NULL) {
 561                 if (dp->d_type != DT_REG)
 562                         continue;
 563                 if (strcmp(dp->d_name + strlen(dp->d_name) - 4, "cert"))
 564                         continue;
 565                 snprintf(buf, sizeof(buf), "%s/%s", path, dp->d_name);
 566                 stat(buf, &sb);
 567
 568                 p = (char **)realloc(certs, (n + 1) * sizeof(certs));
 569                 if (p == NULL)
 570                         err(1, "realloc");
 571                 certs = p;
 572
 573                 certs[n] = malloc(sb.st_size + 1);
 574                 if (certs[n] == NULL)
 575                         err(1, "malloc");
 576
 577                 fd = open(buf, O_RDONLY);
 578                 if (fd == -1)
 579                         err(1, "open");
 580                 len = read(fd, certs[n], sb.st_size);
 581                 if (len == -1)
 582                         err(1, "read");
 583                 if (len != sb.st_size)
 584                         errx(1, "read: length mismatch");
 585                 certs[n][sb.st_size] = '\0';
 586                 close(fd);
 587
 588                 printf("%s: %d\n", dp->d_name, (int)sb.st_size);
 589
 590                 n++;
 591         }
 592
 593         p = (char **)realloc(certs, (n + 1) * sizeof(certs));
 594         if (p == NULL)
 595                 err(1, "realloc");
 596         certs = p;
 597         certs[n] = NULL;
 598
 599         return certs;
 600 }
 601 #endif /* CERTTEST_BROKEN */
 602
 603 typedef vchar_t* (eay_func) (vchar_t *, vchar_t *, vchar_t *);
 604
 605 static int
 606 ciphertest_1 (const char *name,
 607               vchar_t *data,
 608               size_t data_align,
 609               vchar_t *key,
 610               size_t min_keysize,
 611               vchar_t *iv0,
 612               size_t iv_length,
 613               eay_func encrypt,
 614               eay_func decrypt)
 615 {
 616         int padlen;
 617         vchar_t *buf, *iv, *res1, *res2;
 618         iv = vmalloc(iv_length);
 619
 620         printf("Test for cipher %s\n", name);
 621         printf("data:\n");
 622         PVDUMP(data);
 623
 624         if (data_align <= 1 || (data->l % data_align) == 0)
 625           padlen = 0;
 626         else
 627           padlen = data_align - data->l % data_align;
 628
 629         buf = vmalloc(data->l + padlen);
 630         memcpy(buf->v, data->v, data->l);
 631
 632         memcpy(iv->v, iv0->v, iv_length);
 633         res1 = (encrypt)(buf, key, iv);
 634         if (res1 == NULL) {
 635                 printf("%s encryption failed.\n", name);
 636                 return -1;
 637         }
 638         printf("encrypted:\n");
 639         PVDUMP(res1);
 640
 641         memcpy(iv->v, iv0->v, iv_length);
 642         res2 = (decrypt)(res1, key, iv);
 643         if (res2 == NULL) {
 644                 printf("%s decryption failed.\n", name);
 645                 return -1;
 646         }
 647         printf("decrypted:\n");
 648         PVDUMP(res2);
 649
 650         if (memcmp(data->v, res2->v, data->l)) {
 651                 printf("XXXX NG (%s) XXXX\n", name);
 652                 return -1;
 653         }
 654         else
 655                 printf("%s cipher verified.\n", name);
 656         vfree(res1);
 657         vfree(res2);
 658         vfree(buf);
 659         vfree(iv);
 660
 661         return 0;
 662 }
 663
 664 int
 665 ciphertest(ac, av)
 666         int ac;
 667         char **av;
 668 {
 669         vchar_t data;
 670         vchar_t key;
 671         vchar_t iv0;
 672
 673         printf("\n**Testing CIPHERS**\n");
 674
 675         data.v = str2val("\
 676 06000017 03000000 73616b61 6e65406b 616d652e 6e657409 0002c104 308202b8 \
 677 04f05a90 \
 678         ", 16, &data.l);
 679         key.v = str2val("f59bd70f 81b9b9cc 2a32c7fd 229a4b37", 16, &key.l);
 680         iv0.v = str2val("26b68c90 9467b4ab 7ec29fa0 0b696b55", 16, &iv0.l);
 681
 682         if (ciphertest_1 ("DES",
 683                           &data, 8,
 684                           &key, 8,
 685                           &iv0, 8,
 686                           eay_des_encrypt, eay_des_decrypt) < 0)
 687           return -1;
 688
 689         if (ciphertest_1 ("3DES",
 690                           &data, 8,
 691                           &key, 24,
 692                           &iv0, 8,
 693                           eay_3des_encrypt, eay_3des_decrypt) < 0)
 694           return -1;
 695
 696         if (ciphertest_1 ("AES",
 697                           &data, 16,
 698                           &key, key.l,
 699                           &iv0, 16,
 700                           eay_aes_encrypt, eay_aes_decrypt) < 0)
 701           return -1;
 702
 703         if (ciphertest_1 ("BLOWFISH",
 704                           &data, 8,
 705                           &key, key.l,
 706                           &iv0, 8,
 707                           eay_bf_encrypt, eay_bf_decrypt) < 0)
 708           return -1;
 709
 710         if (ciphertest_1 ("CAST",
 711                           &data, 8,
 712                           &key, key.l,
 713                           &iv0, 8,
 714                           eay_cast_encrypt, eay_cast_decrypt) < 0)
 715           return -1;
 716
 717 #ifdef HAVE_OPENSSL_IDEA_H
 718         if (ciphertest_1 ("IDEA",
 719                           &data, 8,
 720                           &key, key.l,
 721                           &iv0, 8,
 722                           eay_idea_encrypt, eay_idea_decrypt) < 0)
 723           return -1;
 724 #endif
 725
 726 #ifdef HAVE_OPENSSL_RC5_H
 727         if (ciphertest_1 ("RC5",
 728                           &data, 8,
 729                           &key, key.l,
 730                           &iv0, 8,
 731                           eay_rc5_encrypt, eay_rc5_decrypt) < 0)
 732           return -1;
 733 #endif
 734         return 0;
 735 }
 736
 737 int
 738 hmactest(ac, av)
 739         int ac;
 740         char **av;
 741 {
 742         char *keyword = "hehehe test secret!";
 743         char *object  = "d7e6a6c1876ef0488bb74958b9fee94e";
 744         char *object1 = "d7e6a6c1876ef048";
 745         char *object2 =                 "8bb74958b9fee94e";
 746         char *r_hmd5  = "5702d7d1 fd1bfc7e 210fc9fa cda7d02c";
 747         char *r_hsha1 = "309999aa 9779a43e ebdea839 1b4e7ee1 d8646874";
 748 #ifdef WITH_SHA2
 749         char *r_hsha2 = "d47262d8 a5b6f39d d8686939 411b3e79 ed2e27f9 2c4ea89f dd0a06ae 0c0aa396";
 750 #endif
 751         vchar_t *key, *data, *data1, *data2, *res;
 752         vchar_t mod;
 753         caddr_t ctx;
 754
 755 #ifdef WITH_SHA2
 756         printf("\n**Test for HMAC MD5, SHA1, and SHA256.**\n");
 757 #else
 758         printf("\n**Test for HMAC MD5 & SHA1.**\n");
 759 #endif
 760
 761         key = vmalloc(strlen(keyword));
 762         memcpy(key->v, keyword, key->l);
 763
 764         data = vmalloc(strlen(object));
 765         data1 = vmalloc(strlen(object1));
 766         data2 = vmalloc(strlen(object2));
 767         memcpy(data->v, object, data->l);
 768         memcpy(data1->v, object1, data1->l);
 769         memcpy(data2->v, object2, data2->l);
 770
 771         /* HMAC MD5 */
 772         printf("HMAC MD5 by eay_hmacmd5_one()\n");
 773         res = eay_hmacmd5_one(key, data);
 774         PVDUMP(res);
 775         mod.v = str2val(r_hmd5, 16, &mod.l);
 776         if (memcmp(res->v, mod.v, mod.l)) {
 777                 printf(" XXX NG XXX\n");
 778                 return -1;
 779         }
 780         free(mod.v);
 781         vfree(res);
 782
 783         /* HMAC MD5 */
 784         printf("HMAC MD5 by eay_hmacmd5_xxx()\n");
 785         ctx = eay_hmacmd5_init(key);
 786         eay_hmacmd5_update(ctx, data1);
 787         eay_hmacmd5_update(ctx, data2);
 788         res = eay_hmacmd5_final(ctx);
 789         PVDUMP(res);
 790         mod.v = str2val(r_hmd5, 16, &mod.l);
 791         if (memcmp(res->v, mod.v, mod.l)) {
 792                 printf(" XXX NG XXX\n");
 793                 return -1;
 794         }
 795         free(mod.v);
 796         vfree(res);
 797
 798         /* HMAC SHA1 */
 799         printf("HMAC SHA1 by eay_hmacsha1_one()\n");
 800         res = eay_hmacsha1_one(key, data);
 801         PVDUMP(res);
 802         mod.v = str2val(r_hsha1, 16, &mod.l);
 803         if (memcmp(res->v, mod.v, mod.l)) {
 804                 printf(" XXX NG XXX\n");
 805                 return -1;
 806         }
 807         free(mod.v);
 808         vfree(res);
 809
 810         /* HMAC SHA1 */
 811         printf("HMAC SHA1 by eay_hmacsha1_xxx()\n");
 812         ctx = eay_hmacsha1_init(key);
 813         eay_hmacsha1_update(ctx, data1);
 814         eay_hmacsha1_update(ctx, data2);
 815         res = eay_hmacsha1_final(ctx);
 816         PVDUMP(res);
 817         mod.v = str2val(r_hsha1, 16, &mod.l);
 818         if (memcmp(res->v, mod.v, mod.l)) {
 819                 printf(" XXX NG XXX\n");
 820                 return -1;
 821         }
 822         free(mod.v);
 823         vfree(res);
 824
 825 #ifdef WITH_SHA2
 826         /* HMAC SHA2 */
 827         printf("HMAC SHA2 by eay_hmacsha2_256_one()\n");
 828         res = eay_hmacsha2_256_one(key, data);
 829         PVDUMP(res);
 830         mod.v = str2val(r_hsha2, 16, &mod.l);
 831         if (memcmp(res->v, mod.v, mod.l)) {
 832                 printf(" XXX NG XXX\n");
 833                 return -1;
 834         }
 835         free(mod.v);
 836         vfree(res);
 837 #endif
 838
 839         vfree(data);
 840         vfree(data1);
 841         vfree(data2);
 842         vfree(key);
 843
 844         return 0;
 845 }
 846
 847 int
 848 sha1test(ac, av)
 849         int ac;
 850         char **av;
 851 {
 852         char *word1 = "1234567890", *word2 = "12345678901234567890";
 853         caddr_t ctx;
 854         vchar_t *buf, *res;
 855
 856         printf("\n**Test for SHA1.**\n");
 857
 858         ctx = eay_sha1_init();
 859         buf = vmalloc(strlen(word1));
 860         memcpy(buf->v, word1, buf->l);
 861         eay_sha1_update(ctx, buf);
 862         eay_sha1_update(ctx, buf);
 863         res = eay_sha1_final(ctx);
 864         PVDUMP(res);
 865         vfree(res);
 866         vfree(buf);
 867
 868         ctx = eay_sha1_init();
 869         buf = vmalloc(strlen(word2));
 870         memcpy(buf->v, word2, buf->l);
 871         eay_sha1_update(ctx, buf);
 872         res = eay_sha1_final(ctx);
 873         PVDUMP(res);
 874         vfree(res);
 875
 876         res = eay_sha1_one(buf);
 877         PVDUMP(res);
 878         vfree(res);
 879         vfree(buf);
 880
 881         return 0;
 882 }
 883
 884 int
 885 md5test(ac, av)
 886         int ac;
 887         char **av;
 888 {
 889         char *word1 = "1234567890", *word2 = "12345678901234567890";
 890         caddr_t ctx;
 891         vchar_t *buf, *res;
 892
 893         printf("\n**Test for MD5.**\n");
 894
 895         ctx = eay_md5_init();
 896         buf = vmalloc(strlen(word1));
 897         memcpy(buf->v, word1, buf->l);
 898         eay_md5_update(ctx, buf);
 899         eay_md5_update(ctx, buf);
 900         res = eay_md5_final(ctx);
 901         PVDUMP(res);
 902         vfree(res);
 903         vfree(buf);
 904
 905         ctx = eay_md5_init();
 906         buf = vmalloc(strlen(word2));
 907         memcpy(buf->v, word2, buf->l);
 908         eay_md5_update(ctx, buf);
 909         res = eay_md5_final(ctx);
 910         PVDUMP(res);
 911         vfree(res);
 912
 913         res = eay_md5_one(buf);
 914         PVDUMP(res);
 915         vfree(res);
 916         vfree(buf);
 917
 918         return 0;
 919 }
 920
 921 int
 922 dhtest(ac, av)
 923         int ac;
 924         char **av;
 925 {
 926         static struct {
 927                 char *name;
 928                 char *p;
 929         } px[] = {
 930                 { "modp768",    OAKLEY_PRIME_MODP768, },
 931                 { "modp1024",   OAKLEY_PRIME_MODP1024, },
 932                 { "modp1536",   OAKLEY_PRIME_MODP1536, },
 933                 { "modp2048",   OAKLEY_PRIME_MODP2048, },
 934                 { "modp3072",   OAKLEY_PRIME_MODP3072, },
 935                 { "modp4096",   OAKLEY_PRIME_MODP4096, },
 936                 { "modp6144",   OAKLEY_PRIME_MODP6144, },
 937                 { "modp8192",   OAKLEY_PRIME_MODP8192, },
 938         };
 939         vchar_t p1, *pub1, *priv1, *gxy1;
 940         vchar_t p2, *pub2, *priv2, *gxy2;
 941         int i;
 942
 943         printf("\n**Test for DH.**\n");
 944
 945         for (i = 0; i < sizeof(px)/sizeof(px[0]); i++) {
 946                 printf("\n**Test for DH %s.**\n", px[i].name);
 947
 948                 p1.v = str2val(px[i].p, 16, &p1.l);
 949                 p2.v = str2val(px[i].p, 16, &p2.l);
 950                 printf("prime number = \n"); PVDUMP(&p1);
 951
 952                 if (eay_dh_generate(&p1, 2, 96, &pub1, &priv1) < 0) {
 953                         printf("error\n");
 954                         return -1;
 955                 }
 956                 printf("private key for user 1 = \n"); PVDUMP(priv1);
 957                 printf("public key for user 1  = \n"); PVDUMP(pub1);
 958
 959                 if (eay_dh_generate(&p2, 2, 96, &pub2, &priv2) < 0) {
 960                         printf("error\n");
 961                         return -1;
 962                 }
 963                 printf("private key for user 2 = \n"); PVDUMP(priv2);
 964                 printf("public key for user 2  = \n"); PVDUMP(pub2);
 965
 966                 /* process to generate key for user 1 */
 967                 gxy1 = vmalloc(p1.l);
 968                 memset(gxy1->v, 0, gxy1->l);
 969                 eay_dh_compute(&p1, 2, pub1, priv1, pub2, &gxy1);
 970                 printf("sharing gxy1 of user 1 = \n"); PVDUMP(gxy1);
 971
 972                 /* process to generate key for user 2 */
 973                 gxy2 = vmalloc(p1.l);
 974                 memset(gxy2->v, 0, gxy2->l);
 975                 eay_dh_compute(&p2, 2, pub2, priv2, pub1, &gxy2);
 976                 printf("sharing gxy2 of user 2 = \n"); PVDUMP(gxy2);
 977
 978                 if (memcmp(gxy1->v, gxy2->v, gxy1->l)) {
 979                         printf("ERROR: sharing gxy mismatched.\n");
 980                         return -1;
 981                 }
 982
 983                 vfree(pub1);
 984                 vfree(pub2);
 985                 vfree(priv1);
 986                 vfree(priv2);
 987                 vfree(gxy1);
 988                 vfree(gxy2);
 989         }
 990
 991         return 0;
 992 }
 993
 994 int
 995 bntest(ac, av)
 996         int ac;
 997         char **av;
 998 {
 999         vchar_t *rn;
1000
1001         printf("\n**Test for generate a random number.**\n");
1002
1003         rn = eay_set_random((u_int32_t)96);
1004         PVDUMP(rn);
1005         vfree(rn);
1006
1007         return 0;
1008 }
1009
1010 struct {
1011         char *name;
1012         int (*func) __P((int, char **));
1013 } func[] = {
1014         { "random", bntest, },
1015         { "dh", dhtest, },
1016         { "md5", md5test, },
1017         { "sha1", sha1test, },
1018         { "hmac", hmactest, },
1019         { "cipher", ciphertest, },
1020 #ifndef CERTTEST_BROKEN
1021         { "cert", certtest, },
1022 #endif
1023         { "rsa", rsatest, },
1024 };
1025
1026 int
1027 main(ac, av)
1028         int ac;
1029         char **av;
1030 {
1031         int i;
1032         int len = sizeof(func)/sizeof(func[0]);
1033
1034         f_foreground = 1;
1035         ploginit();
1036
1037         //printf ("\nTestsuite of the %s\nlinked with %s\n\n", TOP_PACKAGE_STRING, eay_version());
1038
1039         if (strcmp(*av, "-h") == 0)
1040                 Usage();
1041
1042         ac--;
1043         av++;
1044
1045         for (i = 0; i < len; i++) {
1046                 if ((ac == 0) || (strcmp(*av, func[i].name) == 0)) {
1047                         if ((func[i].func)(ac, av) != 0) {
1048                                 printf ("\n!!!!! Test '%s' failed. !!!!!\n\n", func[i].name);
1049                                 exit(1);
1050                         }
1051                         if (ac)
1052                                 break;
1053                 }
1054         }
1055         if (ac && i == len)
1056                 Usage();
1057
1058         printf ("\n===== All tests passed =====\n\n");
1059         exit(0);
1060 }
1061
1062 void
1063 Usage()
1064 {
1065         int i;
1066         int len = sizeof(func)/sizeof(func[0]);
1067
1068         printf("Usage: eaytest [");
1069         for (i = 0; i < len; i++)
1070                 printf("%s%s", func[i].name, (i<len-1)?"|":"");
1071         printf("]\n");
1072 #ifndef CERTTEST_BROKEN
1073         printf("       eaytest cert [cert_directory]\n");
1074 #endif
1075         exit(1);
1076 }
1077