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                 /* print subject alt name */
 383             {
 384                 int pos;
 385                 int len;
 386                 for (pos = 1; ; pos++) {
 387                         error = eay_get_x509subjectaltname(&c, &str, &type, pos, &len);
 388                         if (error) {
 389                                 printf("no subjectaltname found.\n");
 390                                 break;
 391                         }
 392                         if (!str)
 393                                 break;
 394                         printf("SubjectAltName: %d: %s\n", type, str);
 395                         racoon_free(str);
 396                 }
 397             }
 398
 399                 /* NULL => name of the certificate file */
 400                 error = eay_check_x509cert(&c, certpath, NULL, 1);
 401                 if (error)
 402                         printf("ERROR: cert is invalid.\n");
 403                 printf("\n");
 404
 405                 certs++;
 406         }
 407         return 0;
 408 }
 409
 410 static char **
 411 getcerts(path)
 412         char *path;
 413 {
 414         char **certs = NULL, **p;
 415         DIR *dirp;
 416         struct dirent *dp;
 417         struct stat sb;
 418         char buf[512];
 419         int len;
 420         int n;
 421         int fd;
 422
 423         static char *samplecerts[] = {
 424 /* self signed */
 425 "-----BEGIN CERTIFICATE-----\n"
 426 "MIICpTCCAg4CAQAwDQYJKoZIhvcNAQEEBQAwgZoxCzAJBgNVBAYTAkpQMREwDwYD\n"
 427 "VQQIEwhLYW5hZ2F3YTERMA8GA1UEBxMIRnVqaXNhd2ExFTATBgNVBAoTDFdJREUg\n"
 428 "UHJvamVjdDEVMBMGA1UECxMMS0FNRSBQcm9qZWN0MRcwFQYDVQQDEw5TaG9pY2hp\n"
 429 "IFNha2FuZTEeMBwGCSqGSIb3DQEJARYPc2FrYW5lQGthbWUubmV0MB4XDTAwMDgy\n"
 430 "NDAxMzc0NFoXDTAwMDkyMzAxMzc0NFowgZoxCzAJBgNVBAYTAkpQMREwDwYDVQQI\n"
 431 "EwhLYW5hZ2F3YTERMA8GA1UEBxMIRnVqaXNhd2ExFTATBgNVBAoTDFdJREUgUHJv\n"
 432 "amVjdDEVMBMGA1UECxMMS0FNRSBQcm9qZWN0MRcwFQYDVQQDEw5TaG9pY2hpIFNh\n"
 433 "a2FuZTEeMBwGCSqGSIb3DQEJARYPc2FrYW5lQGthbWUubmV0MIGfMA0GCSqGSIb3\n"
 434 "DQEBAQUAA4GNADCBiQKBgQCpIQG/H3zn4czAmPBcbkDrYxE1A9vcpghpib3Of0Op\n"
 435 "SsiWIBOyIMiVAzK/I/JotWp3Vdn5fzGp/7DGAbWXAALas2xHkNmTMPpu6qhmNQ57\n"
 436 "kJHZHal24mgc1hwbrI9fb5olvIexx9a1riNPnKMRVHzXYizsyMbf+lJJmZ8QFhWN\n"
 437 "twIDAQABMA0GCSqGSIb3DQEBBAUAA4GBACKs6X/BYycuHI3iop403R3XWMHHnNBN\n"
 438 "5XTHVWiWgR1cMWkq/dp51gn+nPftpdAaYGpqGkiHGhZcXLoBaX9uON3p+7av+sQN\n"
 439 "plXwnvUf2Zsgu+fojskS0gKcDlYiq1O8TOaBgJouFZgr1q6PiYjVEJGogAP28+HN\n"
 440 "M4o+GBFbFoqK\n"
 441 "-----END CERTIFICATE-----\n\n",
 442 /* signed by SSH testing CA + CA1 + CA2 */
 443 "-----BEGIN X509 CERTIFICATE-----\n"
 444 "MIICtTCCAj+gAwIBAgIEOaR8NjANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJG\n"
 445 "STEkMCIGA1UEChMbU1NIIENvbW11bmljYXRpb25zIFNlY3VyaXR5MREwDwYDVQQL\n"
 446 "EwhXZWIgdGVzdDEbMBkGA1UEAxMSVGVzdCBDQSAxIHN1YiBjYSAyMB4XDTAwMDgy\n"
 447 "NDAwMDAwMFoXDTAwMTAwMTAwMDAwMFowgZoxCzAJBgNVBAYTAkpQMREwDwYDVQQI\n"
 448 "EwhLYW5hZ2F3YTERMA8GA1UEBxMIRnVqaXNhd2ExFTATBgNVBAoTDFdJREUgUHJv\n"
 449 "amVjdDEVMBMGA1UECxMMS0FNRSBQcm9qZWN0MRcwFQYDVQQDEw5TaG9pY2hpIFNh\n"
 450 "a2FuZTEeMBwGCSqGSIb3DQEJAQwPc2FrYW5lQGthbWUubmV0MIGfMA0GCSqGSIb3\n"
 451 "DQEBAQUAA4GNADCBiQKBgQCpIQG/H3zn4czAmPBcbkDrYxE1A9vcpghpib3Of0Op\n"
 452 "SsiWIBOyIMiVAzK/I/JotWp3Vdn5fzGp/7DGAbWXAALas2xHkNmTMPpu6qhmNQ57\n"
 453 "kJHZHal24mgc1hwbrI9fb5olvIexx9a1riNPnKMRVHzXYizsyMbf+lJJmZ8QFhWN\n"
 454 "twIDAQABo18wXTALBgNVHQ8EBAMCBaAwGgYDVR0RBBMwEYEPc2FrYW5lQGthbWUu\n"
 455 "bmV0MDIGA1UdHwQrMCkwJ6AloCOGIWh0dHA6Ly9sZGFwLnNzaC5maS9jcmxzL2Nh\n"
 456 "MS0yLmNybDANBgkqhkiG9w0BAQUFAANhADtaqual41OWshF/rwCTuR6zySBJysGp\n"
 457 "+qjkp5efCiYKhAu1L4WXlMsV/SNdzspui5tHasPBvUw8gzFsU/VW/B2zuQZkimf1\n"
 458 "u6ZPjUb/vt8vLOPScP5MeH7xrTk9iigsqQ==\n"
 459 "-----END X509 CERTIFICATE-----\n\n",
 460 /* VP100 */
 461 "-----BEGIN CERTIFICATE-----\n"
 462 "MIICXzCCAcigAwIBAgIEOXGBIzANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJG\n"
 463 "STEkMCIGA1UEChMbU1NIIENvbW11bmljYXRpb25zIFNlY3VyaXR5MREwDwYDVQQL\n"
 464 "EwhXZWIgdGVzdDESMBAGA1UEAxMJVGVzdCBDQSAxMB4XDTAwMDcxNjAwMDAwMFoX\n"
 465 "DTAwMDkwMTAwMDAwMFowNTELMAkGA1UEBhMCanAxETAPBgNVBAoTCHRhaGl0ZXN0\n"
 466 "MRMwEQYDVQQDEwpmdXJ1a2F3YS0xMIGdMA0GCSqGSIb3DQEBAQUAA4GLADCBhwKB\n"
 467 "gQDUmI2RaAuoLvtRDbASwRhbkj/Oq0BBIKgAqbFknc/EanJSQwZQu82gD88nf7gG\n"
 468 "VEioWmKPLDuEjz5JCuM+k5f7HYHI1wWmz1KFr7UA+avZm4Kp6YKnhuH7soZp7kBL\n"
 469 "hTiZEpL0jdmCWLW3ZXoro55rmPrBsCd+bt8VU6tRZm5dUwIBKaNZMFcwCwYDVR0P\n"
 470 "BAQDAgWgMBYGA1UdEQQPMA2CBVZQMTAwhwQKFIaFMDAGA1UdHwQpMCcwJaAjoCGG\n"
 471 "H2h0dHA6Ly9sZGFwLnNzaC5maS9jcmxzL2NhMS5jcmwwDQYJKoZIhvcNAQEFBQAD\n"
 472 "gYEAKJ/2Co/KYW65mwpGG3CBvsoRL8xyUMHGt6gQpFLHiiHuAdix1ADTL6uoFuYi\n"
 473 "4sE5omQm1wKVv2ZhS03zDtUfKoVEv0HZ7IY3AU/FZT/M5gQvbt43Dki/ma3ock2I\n"
 474 "PPhbLsvXm+GCVh3jvkYGk1zr7VERVeTPtmT+hW63lcxfFp4=\n"
 475 "-----END CERTIFICATE-----\n\n",
 476 /* IKED */
 477 "-----BEGIN CERTIFICATE-----\n"
 478 "MIIEFTCCA7+gAwIBAgIKYU5X6AAAAAAACTANBgkqhkiG9w0BAQUFADCBljEpMCcG\n"
 479 "CSqGSIb3DQEJARYaeS13YXRhbmFAc2RsLmhpdGFjaGkuY28uanAxCzAJBgNVBAYT\n"
 480 "AkpQMREwDwYDVQQIEwhLQU5BR0FXQTERMA8GA1UEBxMIWW9rb2hhbWExEDAOBgNV\n"
 481 "BAoTB0hJVEFDSEkxDDAKBgNVBAsTA1NETDEWMBQGA1UEAxMNSVBzZWMgVGVzdCBD\n"
 482 "QTAeFw0wMDA3MTUwMjUxNDdaFw0wMTA3MTUwMzAxNDdaMEUxCzAJBgNVBAYTAkpQ\n"
 483 "MREwDwYDVQQIEwhLQU5BR0FXQTEQMA4GA1UEChMHSElUQUNISTERMA8GA1UEAxMI\n"
 484 "V0FUQU5BQkUwXDANBgkqhkiG9w0BAQEFAANLADBIAkEA6Wja5A7Ldzrtx+rMWHEB\n"
 485 "Cyt+/ZoG0qdFQbuuUiU1vOSq+1f+ZSCYAdTq13Lrr6Xfz3jDVFEZLPID9PSTFwq+\n"
 486 "yQIDAQABo4ICPTCCAjkwDgYDVR0PAQH/BAQDAgTwMBMGA1UdJQQMMAoGCCsGAQUF\n"
 487 "CAICMB0GA1UdDgQWBBTkv7/MH5Ra+S1zBAmnUIH5w8ZTUTCB0gYDVR0jBIHKMIHH\n"
 488 "gBQsF2qoaTl5F3GFLKrttaxPJ8j4faGBnKSBmTCBljEpMCcGCSqGSIb3DQEJARYa\n"
 489 "eS13YXRhbmFAc2RsLmhpdGFjaGkuY28uanAxCzAJBgNVBAYTAkpQMREwDwYDVQQI\n"
 490 "EwhLQU5BR0FXQTERMA8GA1UEBxMIWW9rb2hhbWExEDAOBgNVBAoTB0hJVEFDSEkx\n"
 491 "DDAKBgNVBAsTA1NETDEWMBQGA1UEAxMNSVBzZWMgVGVzdCBDQYIQeccIf4GYDIBA\n"
 492 "rS6HSUt8XjB7BgNVHR8EdDByMDagNKAyhjBodHRwOi8vZmxvcmEyMjAvQ2VydEVu\n"
 493 "cm9sbC9JUHNlYyUyMFRlc3QlMjBDQS5jcmwwOKA2oDSGMmZpbGU6Ly9cXGZsb3Jh\n"
 494 "MjIwXENlcnRFbnJvbGxcSVBzZWMlMjBUZXN0JTIwQ0EuY3JsMIGgBggrBgEFBQcB\n"
 495 "AQSBkzCBkDBFBggrBgEFBQcwAoY5aHR0cDovL2Zsb3JhMjIwL0NlcnRFbnJvbGwv\n"
 496 "ZmxvcmEyMjBfSVBzZWMlMjBUZXN0JTIwQ0EuY3J0MEcGCCsGAQUFBzAChjtmaWxl\n"
 497 "Oi8vXFxmbG9yYTIyMFxDZXJ0RW5yb2xsXGZsb3JhMjIwX0lQc2VjJTIwVGVzdCUy\n"
 498 "MENBLmNydDANBgkqhkiG9w0BAQUFAANBAG8yZAWHb6g3zba453Hw5loojVDZO6fD\n"
 499 "9lCsyaxeo9/+7x1JEEcdZ6qL7KKqe7ZBwza+hIN0ITkp2WEWo22gTz4=\n"
 500 "-----END CERTIFICATE-----\n\n",
 501 /* From Entrust */
 502 "-----BEGIN CERTIFICATE-----\n"
 503 "MIIDXTCCAsagAwIBAgIEOb6khTANBgkqhkiG9w0BAQUFADA4MQswCQYDVQQGEwJV\n"
 504 "UzEQMA4GA1UEChMHRW50cnVzdDEXMBUGA1UECxMOVlBOIEludGVyb3AgUk8wHhcN\n"
 505 "MDAwOTE4MjMwMDM3WhcNMDMwOTE4MjMzMDM3WjBTMQswCQYDVQQGEwJVUzEQMA4G\n"
 506 "A1UEChMHRW50cnVzdDEXMBUGA1UECxMOVlBOIEludGVyb3AgUk8xGTAXBgNVBAMT\n"
 507 "EFNob2ljaGkgU2FrYW5lIDIwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAKj3\n"
 508 "eXSt1qXxFXzpa265B/NQYk5BZN7pNJg0tlTKBTVV3UgpQ92Bx5DoNfZh11oIv0Sw\n"
 509 "6YnG5p9F9ma36U9HDoD3hVTjAvQKy4ssCsnU1y6v5XOU1QvYQo6UTzgsXUTaIau4\n"
 510 "Lrccl+nyoiNzy3lG51tLR8CxuA+3OOAK9xPjszClAgMBAAGjggFXMIIBUzBABgNV\n"
 511 "HREEOTA3gQ9zYWthbmVAa2FtZS5uZXSHBM6vIHWCHjIwNi0xNzUtMzItMTE3LnZw\n"
 512 "bndvcmtzaG9wLmNvbTATBgNVHSUEDDAKBggrBgEFBQgCAjALBgNVHQ8EBAMCAKAw\n"
 513 "KwYDVR0QBCQwIoAPMjAwMDA5MTgyMzAwMzdagQ8yMDAyMTAyNTExMzAzN1owWgYD\n"
 514 "VR0fBFMwUTBPoE2gS6RJMEcxCzAJBgNVBAYTAlVTMRAwDgYDVQQKEwdFbnRydXN0\n"
 515 "MRcwFQYDVQQLEw5WUE4gSW50ZXJvcCBSTzENMAsGA1UEAxMEQ1JMMTAfBgNVHSME\n"
 516 "GDAWgBTzVmhu0tBoWKwkZE5mXpooE9630DAdBgNVHQ4EFgQUEgBHPtXggJqei5Xz\n"
 517 "92CrWXTJxfAwCQYDVR0TBAIwADAZBgkqhkiG9n0HQQAEDDAKGwRWNS4wAwIEsDAN\n"
 518 "BgkqhkiG9w0BAQUFAAOBgQCIFriNGMUE8GH5LuDrTJfA8uGx8vLy2seljuo694TR\n"
 519 "et/ojp9QnfOJ1PF9iAdGaEaSLfkwhY4fZNZzxic5HBoHLeo9BXLP7i7FByXjvOZC\n"
 520 "Y8++0dC8NVvendIILcJBM5nbDq1TqIbb8K3SP80XhO5JLVJkoZiQftAMjo0peZPO\n"
 521 "EQ==\n"
 522 "-----END CERTIFICATE-----\n\n",
 523         NULL,
 524         };
 525
 526         if (path == NULL)
 527                 return (char **)&samplecerts;
 528
 529         stat(path, &sb);
 530         if (!(sb.st_mode & S_IFDIR)) {
 531                 printf("ERROR: %s is not directory.\n", path);
 532                 exit(0);
 533         }
 534
 535         dirp = opendir(path);
 536         if (dirp == NULL) {
 537                 printf("opendir failed.\n");
 538                 exit(0);
 539         }
 540
 541         n = 0;
 542         while ((dp = readdir(dirp)) != NULL) {
 543                 if (dp->d_type != DT_REG)
 544                         continue;
 545                 if (strcmp(dp->d_name + strlen(dp->d_name) - 4, "cert"))
 546                         continue;
 547                 snprintf(buf, sizeof(buf), "%s/%s", path, dp->d_name);
 548                 stat(buf, &sb);
 549
 550                 p = (char **)realloc(certs, (n + 1) * sizeof(certs));
 551                 if (p == NULL)
 552                         err(1, "realloc");
 553                 certs = p;
 554
 555                 certs[n] = malloc(sb.st_size + 1);
 556                 if (certs[n] == NULL)
 557                         err(1, "malloc");
 558
 559                 fd = open(buf, O_RDONLY);
 560                 if (fd == -1)
 561                         err(1, "open");
 562                 len = read(fd, certs[n], sb.st_size);
 563                 if (len == -1)
 564                         err(1, "read");
 565                 if (len != sb.st_size)
 566                         errx(1, "read: length mismatch");
 567                 certs[n][sb.st_size] = '\0';
 568                 close(fd);
 569
 570                 printf("%s: %d\n", dp->d_name, (int)sb.st_size);
 571
 572                 n++;
 573         }
 574
 575         p = (char **)realloc(certs, (n + 1) * sizeof(certs));
 576         if (p == NULL)
 577                 err(1, "realloc");
 578         certs = p;
 579         certs[n] = NULL;
 580
 581         return certs;
 582 }
 583 #endif /* CERTTEST_BROKEN */
 584
 585 typedef vchar_t* (eay_func) (vchar_t *, vchar_t *, vchar_t *);
 586
 587 static int
 588 ciphertest_1 (const char *name,
 589               vchar_t *data,
 590               size_t data_align,
 591               vchar_t *key,
 592               size_t min_keysize,
 593               vchar_t *iv0,
 594               size_t iv_length,
 595               eay_func encrypt,
 596               eay_func decrypt)
 597 {
 598         int padlen;
 599         vchar_t *buf, *iv, *res1, *res2;
 600         iv = vmalloc(iv_length);
 601
 602         printf("Test for cipher %s\n", name);
 603         printf("data:\n");
 604         PVDUMP(data);
 605
 606         if (data_align <= 1 || (data->l % data_align) == 0)
 607           padlen = 0;
 608         else
 609           padlen = data_align - data->l % data_align;
 610
 611         buf = vmalloc(data->l + padlen);
 612         memcpy(buf->v, data->v, data->l);
 613
 614         memcpy(iv->v, iv0->v, iv_length);
 615         res1 = (encrypt)(buf, key, iv);
 616         if (res1 == NULL) {
 617                 printf("%s encryption failed.\n", name);
 618                 return -1;
 619         }
 620         printf("encrypted:\n");
 621         PVDUMP(res1);
 622
 623         memcpy(iv->v, iv0->v, iv_length);
 624         res2 = (decrypt)(res1, key, iv);
 625         if (res2 == NULL) {
 626                 printf("%s decryption failed.\n", name);
 627                 return -1;
 628         }
 629         printf("decrypted:\n");
 630         PVDUMP(res2);
 631
 632         if (memcmp(data->v, res2->v, data->l)) {
 633                 printf("XXXX NG (%s) XXXX\n", name);
 634                 return -1;
 635         }
 636         else
 637                 printf("%s cipher verified.\n", name);
 638         vfree(res1);
 639         vfree(res2);
 640         vfree(buf);
 641         vfree(iv);
 642
 643         return 0;
 644 }
 645
 646 int
 647 ciphertest(ac, av)
 648         int ac;
 649         char **av;
 650 {
 651         vchar_t data;
 652         vchar_t key;
 653         vchar_t iv0;
 654
 655         printf("\n**Testing CIPHERS**\n");
 656
 657         data.v = str2val("\
 658 06000017 03000000 73616b61 6e65406b 616d652e 6e657409 0002c104 308202b8 \
 659 04f05a90 \
 660         ", 16, &data.l);
 661         key.v = str2val("f59bd70f 81b9b9cc 2a32c7fd 229a4b37", 16, &key.l);
 662         iv0.v = str2val("26b68c90 9467b4ab 7ec29fa0 0b696b55", 16, &iv0.l);
 663
 664         if (ciphertest_1 ("DES",
 665                           &data, 8,
 666                           &key, 8,
 667                           &iv0, 8,
 668                           eay_des_encrypt, eay_des_decrypt) < 0)
 669           return -1;
 670
 671         if (ciphertest_1 ("3DES",
 672                           &data, 8,
 673                           &key, 24,
 674                           &iv0, 8,
 675                           eay_3des_encrypt, eay_3des_decrypt) < 0)
 676           return -1;
 677
 678         if (ciphertest_1 ("AES",
 679                           &data, 16,
 680                           &key, key.l,
 681                           &iv0, 16,
 682                           eay_aes_encrypt, eay_aes_decrypt) < 0)
 683           return -1;
 684
 685         if (ciphertest_1 ("BLOWFISH",
 686                           &data, 8,
 687                           &key, key.l,
 688                           &iv0, 8,
 689                           eay_bf_encrypt, eay_bf_decrypt) < 0)
 690           return -1;
 691
 692         if (ciphertest_1 ("CAST",
 693                           &data, 8,
 694                           &key, key.l,
 695                           &iv0, 8,
 696                           eay_cast_encrypt, eay_cast_decrypt) < 0)
 697           return -1;
 698
 699 #ifdef HAVE_OPENSSL_IDEA_H
 700         if (ciphertest_1 ("IDEA",
 701                           &data, 8,
 702                           &key, key.l,
 703                           &iv0, 8,
 704                           eay_idea_encrypt, eay_idea_decrypt) < 0)
 705           return -1;
 706 #endif
 707
 708 #ifdef HAVE_OPENSSL_RC5_H
 709         if (ciphertest_1 ("RC5",
 710                           &data, 8,
 711                           &key, key.l,
 712                           &iv0, 8,
 713                           eay_rc5_encrypt, eay_rc5_decrypt) < 0)
 714           return -1;
 715 #endif
 716         return 0;
 717 }
 718
 719 int
 720 hmactest(ac, av)
 721         int ac;
 722         char **av;
 723 {
 724         char *keyword = "hehehe test secret!";
 725         char *object  = "d7e6a6c1876ef0488bb74958b9fee94e";
 726         char *object1 = "d7e6a6c1876ef048";
 727         char *object2 =                 "8bb74958b9fee94e";
 728         char *r_hmd5  = "5702d7d1 fd1bfc7e 210fc9fa cda7d02c";
 729         char *r_hsha1 = "309999aa 9779a43e ebdea839 1b4e7ee1 d8646874";
 730 #ifdef WITH_SHA2
 731         char *r_hsha2 = "d47262d8 a5b6f39d d8686939 411b3e79 ed2e27f9 2c4ea89f dd0a06ae 0c0aa396";
 732 #endif
 733         vchar_t *key, *data, *data1, *data2, *res;
 734         vchar_t mod;
 735         caddr_t ctx;
 736
 737 #ifdef WITH_SHA2
 738         printf("\n**Test for HMAC MD5, SHA1, and SHA256.**\n");
 739 #else
 740         printf("\n**Test for HMAC MD5 & SHA1.**\n");
 741 #endif
 742
 743         key = vmalloc(strlen(keyword));
 744         memcpy(key->v, keyword, key->l);
 745
 746         data = vmalloc(strlen(object));
 747         data1 = vmalloc(strlen(object1));
 748         data2 = vmalloc(strlen(object2));
 749         memcpy(data->v, object, data->l);
 750         memcpy(data1->v, object1, data1->l);
 751         memcpy(data2->v, object2, data2->l);
 752
 753         /* HMAC MD5 */
 754         printf("HMAC MD5 by eay_hmacmd5_one()\n");
 755         res = eay_hmacmd5_one(key, data);
 756         PVDUMP(res);
 757         mod.v = str2val(r_hmd5, 16, &mod.l);
 758         if (memcmp(res->v, mod.v, mod.l)) {
 759                 printf(" XXX NG XXX\n");
 760                 return -1;
 761         }
 762         free(mod.v);
 763         vfree(res);
 764
 765         /* HMAC MD5 */
 766         printf("HMAC MD5 by eay_hmacmd5_xxx()\n");
 767         ctx = eay_hmacmd5_init(key);
 768         eay_hmacmd5_update(ctx, data1);
 769         eay_hmacmd5_update(ctx, data2);
 770         res = eay_hmacmd5_final(ctx);
 771         PVDUMP(res);
 772         mod.v = str2val(r_hmd5, 16, &mod.l);
 773         if (memcmp(res->v, mod.v, mod.l)) {
 774                 printf(" XXX NG XXX\n");
 775                 return -1;
 776         }
 777         free(mod.v);
 778         vfree(res);
 779
 780         /* HMAC SHA1 */
 781         printf("HMAC SHA1 by eay_hmacsha1_one()\n");
 782         res = eay_hmacsha1_one(key, data);
 783         PVDUMP(res);
 784         mod.v = str2val(r_hsha1, 16, &mod.l);
 785         if (memcmp(res->v, mod.v, mod.l)) {
 786                 printf(" XXX NG XXX\n");
 787                 return -1;
 788         }
 789         free(mod.v);
 790         vfree(res);
 791
 792         /* HMAC SHA1 */
 793         printf("HMAC SHA1 by eay_hmacsha1_xxx()\n");
 794         ctx = eay_hmacsha1_init(key);
 795         eay_hmacsha1_update(ctx, data1);
 796         eay_hmacsha1_update(ctx, data2);
 797         res = eay_hmacsha1_final(ctx);
 798         PVDUMP(res);
 799         mod.v = str2val(r_hsha1, 16, &mod.l);
 800         if (memcmp(res->v, mod.v, mod.l)) {
 801                 printf(" XXX NG XXX\n");
 802                 return -1;
 803         }
 804         free(mod.v);
 805         vfree(res);
 806
 807 #ifdef WITH_SHA2
 808         /* HMAC SHA2 */
 809         printf("HMAC SHA2 by eay_hmacsha2_256_one()\n");
 810         res = eay_hmacsha2_256_one(key, data);
 811         PVDUMP(res);
 812         mod.v = str2val(r_hsha2, 16, &mod.l);
 813         if (memcmp(res->v, mod.v, mod.l)) {
 814                 printf(" XXX NG XXX\n");
 815                 return -1;
 816         }
 817         free(mod.v);
 818         vfree(res);
 819 #endif
 820
 821         vfree(data);
 822         vfree(data1);
 823         vfree(data2);
 824         vfree(key);
 825
 826         return 0;
 827 }
 828
 829 int
 830 sha1test(ac, av)
 831         int ac;
 832         char **av;
 833 {
 834         char *word1 = "1234567890", *word2 = "12345678901234567890";
 835         caddr_t ctx;
 836         vchar_t *buf, *res;
 837
 838         printf("\n**Test for SHA1.**\n");
 839
 840         ctx = eay_sha1_init();
 841         buf = vmalloc(strlen(word1));
 842         memcpy(buf->v, word1, buf->l);
 843         eay_sha1_update(ctx, buf);
 844         eay_sha1_update(ctx, buf);
 845         res = eay_sha1_final(ctx);
 846         PVDUMP(res);
 847         vfree(res);
 848         vfree(buf);
 849
 850         ctx = eay_sha1_init();
 851         buf = vmalloc(strlen(word2));
 852         memcpy(buf->v, word2, buf->l);
 853         eay_sha1_update(ctx, buf);
 854         res = eay_sha1_final(ctx);
 855         PVDUMP(res);
 856         vfree(res);
 857
 858         res = eay_sha1_one(buf);
 859         PVDUMP(res);
 860         vfree(res);
 861         vfree(buf);
 862
 863         return 0;
 864 }
 865
 866 int
 867 md5test(ac, av)
 868         int ac;
 869         char **av;
 870 {
 871         char *word1 = "1234567890", *word2 = "12345678901234567890";
 872         caddr_t ctx;
 873         vchar_t *buf, *res;
 874
 875         printf("\n**Test for MD5.**\n");
 876
 877         ctx = eay_md5_init();
 878         buf = vmalloc(strlen(word1));
 879         memcpy(buf->v, word1, buf->l);
 880         eay_md5_update(ctx, buf);
 881         eay_md5_update(ctx, buf);
 882         res = eay_md5_final(ctx);
 883         PVDUMP(res);
 884         vfree(res);
 885         vfree(buf);
 886
 887         ctx = eay_md5_init();
 888         buf = vmalloc(strlen(word2));
 889         memcpy(buf->v, word2, buf->l);
 890         eay_md5_update(ctx, buf);
 891         res = eay_md5_final(ctx);
 892         PVDUMP(res);
 893         vfree(res);
 894
 895         res = eay_md5_one(buf);
 896         PVDUMP(res);
 897         vfree(res);
 898         vfree(buf);
 899
 900         return 0;
 901 }
 902
 903 int
 904 dhtest(ac, av)
 905         int ac;
 906         char **av;
 907 {
 908         static struct {
 909                 char *name;
 910                 char *p;
 911         } px[] = {
 912                 { "modp768",    OAKLEY_PRIME_MODP768, },
 913                 { "modp1024",   OAKLEY_PRIME_MODP1024, },
 914                 { "modp1536",   OAKLEY_PRIME_MODP1536, },
 915                 { "modp2048",   OAKLEY_PRIME_MODP2048, },
 916                 { "modp3072",   OAKLEY_PRIME_MODP3072, },
 917                 { "modp4096",   OAKLEY_PRIME_MODP4096, },
 918                 { "modp6144",   OAKLEY_PRIME_MODP6144, },
 919                 { "modp8192",   OAKLEY_PRIME_MODP8192, },
 920         };
 921         vchar_t p1, *pub1, *priv1, *gxy1;
 922         vchar_t p2, *pub2, *priv2, *gxy2;
 923         int i;
 924
 925         printf("\n**Test for DH.**\n");
 926
 927         for (i = 0; i < sizeof(px)/sizeof(px[0]); i++) {
 928                 printf("\n**Test for DH %s.**\n", px[i].name);
 929
 930                 p1.v = str2val(px[i].p, 16, &p1.l);
 931                 p2.v = str2val(px[i].p, 16, &p2.l);
 932                 printf("prime number = \n"); PVDUMP(&p1);
 933
 934                 if (eay_dh_generate(&p1, 2, 96, &pub1, &priv1) < 0) {
 935                         printf("error\n");
 936                         return -1;
 937                 }
 938                 printf("private key for user 1 = \n"); PVDUMP(priv1);
 939                 printf("public key for user 1  = \n"); PVDUMP(pub1);
 940
 941                 if (eay_dh_generate(&p2, 2, 96, &pub2, &priv2) < 0) {
 942                         printf("error\n");
 943                         return -1;
 944                 }
 945                 printf("private key for user 2 = \n"); PVDUMP(priv2);
 946                 printf("public key for user 2  = \n"); PVDUMP(pub2);
 947
 948                 /* process to generate key for user 1 */
 949                 gxy1 = vmalloc(p1.l);
 950                 memset(gxy1->v, 0, gxy1->l);
 951                 eay_dh_compute(&p1, 2, pub1, priv1, pub2, &gxy1);
 952                 printf("sharing gxy1 of user 1 = \n"); PVDUMP(gxy1);
 953
 954                 /* process to generate key for user 2 */
 955                 gxy2 = vmalloc(p1.l);
 956                 memset(gxy2->v, 0, gxy2->l);
 957                 eay_dh_compute(&p2, 2, pub2, priv2, pub1, &gxy2);
 958                 printf("sharing gxy2 of user 2 = \n"); PVDUMP(gxy2);
 959
 960                 if (memcmp(gxy1->v, gxy2->v, gxy1->l)) {
 961                         printf("ERROR: sharing gxy mismatched.\n");
 962                         return -1;
 963                 }
 964
 965                 vfree(pub1);
 966                 vfree(pub2);
 967                 vfree(priv1);
 968                 vfree(priv2);
 969                 vfree(gxy1);
 970                 vfree(gxy2);
 971         }
 972
 973         return 0;
 974 }
 975
 976 int
 977 bntest(ac, av)
 978         int ac;
 979         char **av;
 980 {
 981         vchar_t *rn;
 982
 983         printf("\n**Test for generate a random number.**\n");
 984
 985         rn = eay_set_random((u_int32_t)96);
 986         PVDUMP(rn);
 987         vfree(rn);
 988
 989         return 0;
 990 }
 991
 992 struct {
 993         char *name;
 994         int (*func) __P((int, char **));
 995 } func[] = {
 996         { "random", bntest, },
 997         { "dh", dhtest, },
 998         { "md5", md5test, },
 999         { "sha1", sha1test, },
1000         { "hmac", hmactest, },
1001         { "cipher", ciphertest, },
1002 #ifndef CERTTEST_BROKEN
1003         { "cert", certtest, },
1004 #endif
1005         { "rsa", rsatest, },
1006 };
1007
1008 int
1009 main(ac, av)
1010         int ac;
1011         char **av;
1012 {
1013         int i;
1014         int len = sizeof(func)/sizeof(func[0]);
1015
1016         f_foreground = 1;
1017         ploginit();
1018
1019         //printf ("\nTestsuite of the %s\nlinked with %s\n\n", TOP_PACKAGE_STRING, eay_version());
1020
1021         if (strcmp(*av, "-h") == 0)
1022                 Usage();
1023
1024         ac--;
1025         av++;
1026
1027         for (i = 0; i < len; i++) {
1028                 if ((ac == 0) || (strcmp(*av, func[i].name) == 0)) {
1029                         if ((func[i].func)(ac, av) != 0) {
1030                                 printf ("\n!!!!! Test '%s' failed. !!!!!\n\n", func[i].name);
1031                                 exit(1);
1032                         }
1033                         if (ac)
1034                                 break;
1035                 }
1036         }
1037         if (ac && i == len)
1038                 Usage();
1039
1040         printf ("\n===== All tests passed =====\n\n");
1041         exit(0);
1042 }
1043
1044 void
1045 Usage()
1046 {
1047         int i;
1048         int len = sizeof(func)/sizeof(func[0]);
1049
1050         printf("Usage: eaytest [");
1051         for (i = 0; i < len; i++)
1052                 printf("%s%s", func[i].name, (i<len-1)?"|":"");
1053         printf("]\n");
1054 #ifndef CERTTEST_BROKEN
1055         printf("       eaytest cert [cert_directory]\n");
1056 #endif
1057         exit(1);
1058 }
1059