source: rtems-libbsd/ipsec-tools/src/racoon/eaytest.c @ ff36f5e

5-freebsd-12
Last change on this file since ff36f5e was ff36f5e, checked in by Christian Mauderer <christian.mauderer@…>, on May 30, 2018 at 12:27:35 PM

Import ipsec-tools 0.8.2.

Import unchanged ipsec-tools sources in the release version 0.8.2. The
homepage of ipsec-tools is http://ipsec-tools.sourceforge.net/. The
sources can be obtained from there.

  • Property mode set to 100644
File size: 28.3 KB
Line 
1/*      $NetBSD: eaytest.c,v 1.10 2010/01/17 23:02:48 wiz 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) racoon_hexdump((var)->v, (var)->l)
69
70/*#define CERTTEST_BROKEN */
71
72/* prototype */
73
74static vchar_t *pem_read_buf __P((char *));
75void Usage __P((void));
76
77int rsatest __P((int, char **));
78int ciphertest __P((int, char **));
79int hmactest __P((int, char **));
80int sha1test __P((int, char **));
81int md5test __P((int, char **));
82int dhtest __P((int, char **));
83int bntest __P((int, char **));
84#ifndef CERTTEST_BROKEN
85static char **getcerts __P((char *));
86int certtest __P((int, char **));
87#endif
88
89/* test */
90
91static int
92rsa_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
111int
112rsatest(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
195static vchar_t *
196pem_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
219int
220certtest(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 = NULL;
236        char *dnstr_w2 = NULL;
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 != NULL) {
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 != NULL) {
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
411static char **
412getcerts(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        closedir(dirp);
576
577        p = (char **)realloc(certs, (n + 1) * sizeof(certs));
578        if (p == NULL)
579                err(1, "realloc");
580        certs = p;
581        certs[n] = NULL;
582
583        return certs;
584}
585#endif /* CERTTEST_BROKEN */
586
587typedef vchar_t* (eay_func) (vchar_t *, vchar_t *, vchar_t *);
588
589static int 
590ciphertest_1 (const char *name,
591              vchar_t *data,
592              size_t data_align,
593              vchar_t *key,
594              size_t min_keysize,
595              vchar_t *iv0,
596              size_t iv_length,
597              eay_func encrypt,
598              eay_func decrypt)
599{
600        int padlen;
601        vchar_t *buf, *iv, *res1, *res2;
602        iv = vmalloc(iv_length);
603       
604        printf("Test for cipher %s\n", name);
605        printf("data:\n");
606        PVDUMP(data);
607
608        if (data_align <= 1 || (data->l % data_align) == 0)
609          padlen = 0;
610        else
611          padlen = data_align - data->l % data_align;
612
613        buf = vmalloc(data->l + padlen);
614        memcpy(buf->v, data->v, data->l);
615
616        memcpy(iv->v, iv0->v, iv_length);
617        res1 = (encrypt)(buf, key, iv);
618        if (res1 == NULL) {
619                printf("%s encryption failed.\n", name);
620                return -1;
621        }
622        printf("encrypted:\n");
623        PVDUMP(res1);
624
625        memcpy(iv->v, iv0->v, iv_length);
626        res2 = (decrypt)(res1, key, iv);
627        if (res2 == NULL) {
628                printf("%s decryption failed.\n", name);
629                return -1;
630        }
631        printf("decrypted:\n");
632        PVDUMP(res2);
633
634        if (memcmp(data->v, res2->v, data->l)) {
635                printf("XXXX NG (%s) XXXX\n", name);
636                return -1;
637        }
638        else
639                printf("%s cipher verified.\n", name);
640        vfree(res1);
641        vfree(res2);
642        vfree(buf);
643        vfree(iv);
644
645        return 0;
646}
647
648int
649ciphertest(ac, av)
650        int ac;
651        char **av;
652{
653        vchar_t data;
654        vchar_t key;
655        vchar_t iv0;
656
657        printf("\n**Testing CIPHERS**\n");
658
659        data.v = str2val("\
66006000017 03000000 73616b61 6e65406b 616d652e 6e657409 0002c104 308202b8 \
66104f05a90 \
662        ", 16, &data.l);
663        key.v = str2val("f59bd70f 81b9b9cc 2a32c7fd 229a4b37", 16, &key.l);
664        iv0.v = str2val("26b68c90 9467b4ab 7ec29fa0 0b696b55", 16, &iv0.l);
665
666        if (ciphertest_1 ("DES", 
667                          &data, 8, 
668                          &key, 8, 
669                          &iv0, 8, 
670                          eay_des_encrypt, eay_des_decrypt) < 0)
671          return -1;
672       
673        if (ciphertest_1 ("3DES",
674                          &data, 8,
675                          &key, 24,
676                          &iv0, 8,
677                          eay_3des_encrypt, eay_3des_decrypt) < 0)
678          return -1;
679       
680        if (ciphertest_1 ("AES",
681                          &data, 16,
682                          &key, key.l,
683                          &iv0, 16,
684                          eay_aes_encrypt, eay_aes_decrypt) < 0)
685          return -1;
686
687        if (ciphertest_1 ("BLOWFISH",
688                          &data, 8,
689                          &key, key.l,
690                          &iv0, 8,
691                          eay_bf_encrypt, eay_bf_decrypt) < 0)
692          return -1;
693
694        if (ciphertest_1 ("CAST",
695                          &data, 8,
696                          &key, key.l,
697                          &iv0, 8,
698                          eay_cast_encrypt, eay_cast_decrypt) < 0)
699          return -1;
700       
701#ifdef HAVE_OPENSSL_IDEA_H
702        if (ciphertest_1 ("IDEA",
703                          &data, 8,
704                          &key, key.l,
705                          &iv0, 8,
706                          eay_idea_encrypt, eay_idea_decrypt) < 0)
707          return -1;
708#endif
709
710#ifdef HAVE_OPENSSL_RC5_H
711        if (ciphertest_1 ("RC5",
712                          &data, 8,
713                          &key, key.l,
714                          &iv0, 8,
715                          eay_rc5_encrypt, eay_rc5_decrypt) < 0)
716          return -1;
717#endif
718#if defined(HAVE_OPENSSL_CAMELLIA_H)
719        if (ciphertest_1 ("CAMELLIA",
720                          &data, 16,
721                          &key, key.l,
722                          &iv0, 16,
723                          eay_camellia_encrypt, eay_camellia_decrypt) < 0)
724          return -1;
725#endif
726        return 0;
727}
728
729int
730hmactest(ac, av)
731        int ac;
732        char **av;
733{
734        char *keyword = "hehehe test secret!";
735        char *object  = "d7e6a6c1876ef0488bb74958b9fee94e";
736        char *object1 = "d7e6a6c1876ef048";
737        char *object2 =                 "8bb74958b9fee94e";
738        char *r_hmd5  = "5702d7d1 fd1bfc7e 210fc9fa cda7d02c";
739        char *r_hsha1 = "309999aa 9779a43e ebdea839 1b4e7ee1 d8646874";
740#ifdef WITH_SHA2
741        char *r_hsha2 = "d47262d8 a5b6f39d d8686939 411b3e79 ed2e27f9 2c4ea89f dd0a06ae 0c0aa396";
742#endif
743        vchar_t *key, *data, *data1, *data2, *res;
744        vchar_t mod;
745        caddr_t ctx;
746
747#ifdef WITH_SHA2
748        printf("\n**Test for HMAC MD5, SHA1, and SHA256.**\n");
749#else
750        printf("\n**Test for HMAC MD5 & SHA1.**\n");
751#endif
752
753        key = vmalloc(strlen(keyword));
754        memcpy(key->v, keyword, key->l);
755
756        data = vmalloc(strlen(object));
757        data1 = vmalloc(strlen(object1));
758        data2 = vmalloc(strlen(object2));
759        memcpy(data->v, object, data->l);
760        memcpy(data1->v, object1, data1->l);
761        memcpy(data2->v, object2, data2->l);
762
763        /* HMAC MD5 */
764        printf("HMAC MD5 by eay_hmacmd5_one()\n");
765        res = eay_hmacmd5_one(key, data);
766        PVDUMP(res);
767        mod.v = str2val(r_hmd5, 16, &mod.l);
768        if (memcmp(res->v, mod.v, mod.l)) {
769                printf(" XXX NG XXX\n");
770                return -1;
771        }
772        free(mod.v);
773        vfree(res);
774
775        /* HMAC MD5 */
776        printf("HMAC MD5 by eay_hmacmd5_xxx()\n");
777        ctx = eay_hmacmd5_init(key);
778        eay_hmacmd5_update(ctx, data1);
779        eay_hmacmd5_update(ctx, data2);
780        res = eay_hmacmd5_final(ctx);
781        PVDUMP(res);
782        mod.v = str2val(r_hmd5, 16, &mod.l);
783        if (memcmp(res->v, mod.v, mod.l)) {
784                printf(" XXX NG XXX\n");
785                return -1;
786        }
787        free(mod.v);
788        vfree(res);
789
790        /* HMAC SHA1 */
791        printf("HMAC SHA1 by eay_hmacsha1_one()\n");
792        res = eay_hmacsha1_one(key, data);
793        PVDUMP(res);
794        mod.v = str2val(r_hsha1, 16, &mod.l);
795        if (memcmp(res->v, mod.v, mod.l)) {
796                printf(" XXX NG XXX\n");
797                return -1;
798        }
799        free(mod.v);
800        vfree(res);
801
802        /* HMAC SHA1 */
803        printf("HMAC SHA1 by eay_hmacsha1_xxx()\n");
804        ctx = eay_hmacsha1_init(key);
805        eay_hmacsha1_update(ctx, data1);
806        eay_hmacsha1_update(ctx, data2);
807        res = eay_hmacsha1_final(ctx);
808        PVDUMP(res);
809        mod.v = str2val(r_hsha1, 16, &mod.l);
810        if (memcmp(res->v, mod.v, mod.l)) {
811                printf(" XXX NG XXX\n");
812                return -1;
813        }
814        free(mod.v);
815        vfree(res);
816
817#ifdef WITH_SHA2
818        /* HMAC SHA2 */
819        printf("HMAC SHA2 by eay_hmacsha2_256_one()\n");
820        res = eay_hmacsha2_256_one(key, data);
821        PVDUMP(res);
822        mod.v = str2val(r_hsha2, 16, &mod.l);
823        if (memcmp(res->v, mod.v, mod.l)) {
824                printf(" XXX NG XXX\n");
825                return -1;
826        }
827        free(mod.v);
828        vfree(res);
829#endif
830
831        vfree(data);
832        vfree(data1);
833        vfree(data2);
834        vfree(key);
835
836        return 0;
837}
838
839int
840sha1test(ac, av)
841        int ac;
842        char **av;
843{
844        char *word1 = "1234567890", *word2 = "12345678901234567890";
845        caddr_t ctx;
846        vchar_t *buf, *res;
847
848        printf("\n**Test for SHA1.**\n");
849
850        ctx = eay_sha1_init();
851        buf = vmalloc(strlen(word1));
852        memcpy(buf->v, word1, buf->l);
853        eay_sha1_update(ctx, buf);
854        eay_sha1_update(ctx, buf);
855        res = eay_sha1_final(ctx);
856        PVDUMP(res);
857        vfree(res);
858        vfree(buf);
859
860        ctx = eay_sha1_init();
861        buf = vmalloc(strlen(word2));
862        memcpy(buf->v, word2, buf->l);
863        eay_sha1_update(ctx, buf);
864        res = eay_sha1_final(ctx);
865        PVDUMP(res);
866        vfree(res);
867
868        res = eay_sha1_one(buf);
869        PVDUMP(res);
870        vfree(res);
871        vfree(buf);
872
873        return 0;
874}
875
876int
877md5test(ac, av)
878        int ac;
879        char **av;
880{
881        char *word1 = "1234567890", *word2 = "12345678901234567890";
882        caddr_t ctx;
883        vchar_t *buf, *res;
884
885        printf("\n**Test for MD5.**\n");
886
887        ctx = eay_md5_init();
888        buf = vmalloc(strlen(word1));
889        memcpy(buf->v, word1, buf->l);
890        eay_md5_update(ctx, buf);
891        eay_md5_update(ctx, buf);
892        res = eay_md5_final(ctx);
893        PVDUMP(res);
894        vfree(res);
895        vfree(buf);
896
897        ctx = eay_md5_init();
898        buf = vmalloc(strlen(word2));
899        memcpy(buf->v, word2, buf->l);
900        eay_md5_update(ctx, buf);
901        res = eay_md5_final(ctx);
902        PVDUMP(res);
903        vfree(res);
904
905        res = eay_md5_one(buf);
906        PVDUMP(res);
907        vfree(res);
908        vfree(buf);
909
910        return 0;
911}
912
913int
914dhtest(ac, av)
915        int ac;
916        char **av;
917{
918        static struct {
919                char *name;
920                char *p;
921        } px[] = {
922                { "modp768",    OAKLEY_PRIME_MODP768, },
923                { "modp1024",   OAKLEY_PRIME_MODP1024, },
924                { "modp1536",   OAKLEY_PRIME_MODP1536, },
925                { "modp2048",   OAKLEY_PRIME_MODP2048, },
926                { "modp3072",   OAKLEY_PRIME_MODP3072, },
927                { "modp4096",   OAKLEY_PRIME_MODP4096, },
928                { "modp6144",   OAKLEY_PRIME_MODP6144, },
929                { "modp8192",   OAKLEY_PRIME_MODP8192, },
930        };
931        vchar_t p1, *pub1, *priv1, *gxy1;
932        vchar_t p2, *pub2, *priv2, *gxy2;
933        int i;
934
935        printf("\n**Test for DH.**\n");
936
937        for (i = 0; i < sizeof(px)/sizeof(px[0]); i++) {
938                printf("\n**Test for DH %s.**\n", px[i].name);
939
940                p1.v = str2val(px[i].p, 16, &p1.l);
941                p2.v = str2val(px[i].p, 16, &p2.l);
942                printf("prime number = \n"); PVDUMP(&p1);
943
944                if (eay_dh_generate(&p1, 2, 96, &pub1, &priv1) < 0) {
945                        printf("error\n");
946                        return -1;
947                }
948                printf("private key for user 1 = \n"); PVDUMP(priv1);
949                printf("public key for user 1  = \n"); PVDUMP(pub1);
950
951                if (eay_dh_generate(&p2, 2, 96, &pub2, &priv2) < 0) {
952                        printf("error\n");
953                        return -1;
954                }
955                printf("private key for user 2 = \n"); PVDUMP(priv2);
956                printf("public key for user 2  = \n"); PVDUMP(pub2);
957
958                /* process to generate key for user 1 */
959                gxy1 = vmalloc(p1.l);
960                memset(gxy1->v, 0, gxy1->l);
961                eay_dh_compute(&p1, 2, pub1, priv1, pub2, &gxy1);
962                printf("sharing gxy1 of user 1 = \n"); PVDUMP(gxy1);
963
964                /* process to generate key for user 2 */
965                gxy2 = vmalloc(p1.l);
966                memset(gxy2->v, 0, gxy2->l);
967                eay_dh_compute(&p2, 2, pub2, priv2, pub1, &gxy2);
968                printf("sharing gxy2 of user 2 = \n"); PVDUMP(gxy2);
969
970                if (memcmp(gxy1->v, gxy2->v, gxy1->l)) {
971                        printf("ERROR: sharing gxy mismatched.\n");
972                        return -1;
973                }
974
975                vfree(pub1);
976                vfree(pub2);
977                vfree(priv1);
978                vfree(priv2);
979                vfree(gxy1);
980                vfree(gxy2);
981        }
982
983        return 0;
984}
985
986int
987bntest(ac, av)
988        int ac;
989        char **av;
990{
991        vchar_t *rn;
992
993        printf("\n**Test for generate a random number.**\n");
994
995        rn = eay_set_random((u_int32_t)96);
996        PVDUMP(rn);
997        vfree(rn);
998
999        return 0;
1000}
1001
1002struct {
1003        char *name;
1004        int (*func) __P((int, char **));
1005} func[] = {
1006        { "random", bntest, },
1007        { "dh", dhtest, },
1008        { "md5", md5test, },
1009        { "sha1", sha1test, },
1010        { "hmac", hmactest, },
1011        { "cipher", ciphertest, },
1012#ifndef CERTTEST_BROKEN
1013        { "cert", certtest, },
1014#endif
1015        { "rsa", rsatest, },
1016};
1017
1018int
1019main(ac, av)
1020        int ac;
1021        char **av;
1022{
1023        int i;
1024        int len = sizeof(func)/sizeof(func[0]);
1025
1026        f_foreground = 1;
1027        ploginit();
1028
1029        printf ("\nTestsuite of the %s\nlinked with %s\n\n", TOP_PACKAGE_STRING, eay_version());
1030
1031        if (strcmp(*av, "-h") == 0)
1032                Usage();
1033
1034        ac--;
1035        av++;
1036
1037        for (i = 0; i < len; i++) {
1038                if ((ac == 0) || (strcmp(*av, func[i].name) == 0)) {
1039                        if ((func[i].func)(ac, av) != 0) {
1040                                printf ("\n!!!!! Test '%s' failed. !!!!!\n\n", func[i].name);
1041                                exit(1);
1042                        }
1043                        if (ac)
1044                                break;
1045                }
1046        }
1047        if (ac && i == len)
1048                Usage();
1049
1050        printf ("\n===== All tests passed =====\n\n");
1051        exit(0);
1052}
1053
1054void
1055Usage()
1056{
1057        int i;
1058        int len = sizeof(func)/sizeof(func[0]);
1059
1060        printf("Usage: eaytest [");
1061        for (i = 0; i < len; i++)
1062                printf("%s%s", func[i].name, (i<len-1)?"|":"");
1063        printf("]\n");
1064#ifndef CERTTEST_BROKEN
1065        printf("       eaytest cert [cert_directory]\n");
1066#endif
1067        exit(1);
1068}
1069
Note: See TracBrowser for help on using the repository browser.