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