Annotation of src/usr.bin/openssl/dgst.c, Revision 1.19
1.19 ! tb 1: /* $OpenBSD: dgst.c,v 1.18 2019/08/30 12:32:14 inoguchi Exp $ */
1.1 jsing 2: /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3: * All rights reserved.
4: *
5: * This package is an SSL implementation written
6: * by Eric Young (eay@cryptsoft.com).
7: * The implementation was written so as to conform with Netscapes SSL.
8: *
9: * This library is free for commercial and non-commercial use as long as
10: * the following conditions are aheared to. The following conditions
11: * apply to all code found in this distribution, be it the RC4, RSA,
12: * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13: * included with this distribution is covered by the same copyright terms
14: * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15: *
16: * Copyright remains Eric Young's, and as such any Copyright notices in
17: * the code are not to be removed.
18: * If this package is used in a product, Eric Young should be given attribution
19: * as the author of the parts of the library used.
20: * This can be in the form of a textual message at program startup or
21: * in documentation (online or textual) provided with the package.
22: *
23: * Redistribution and use in source and binary forms, with or without
24: * modification, are permitted provided that the following conditions
25: * are met:
26: * 1. Redistributions of source code must retain the copyright
27: * notice, this list of conditions and the following disclaimer.
28: * 2. Redistributions in binary form must reproduce the above copyright
29: * notice, this list of conditions and the following disclaimer in the
30: * documentation and/or other materials provided with the distribution.
31: * 3. All advertising materials mentioning features or use of this software
32: * must display the following acknowledgement:
33: * "This product includes cryptographic software written by
34: * Eric Young (eay@cryptsoft.com)"
35: * The word 'cryptographic' can be left out if the rouines from the library
36: * being used are not cryptographic related :-).
37: * 4. If you include any Windows specific code (or a derivative thereof) from
38: * the apps directory (application code) you must include an acknowledgement:
39: * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40: *
41: * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51: * SUCH DAMAGE.
52: *
53: * The licence and distribution terms for any publically available version or
54: * derivative of this code cannot be changed. i.e. this code cannot simply be
55: * copied and put under another distribution licence
56: * [including the GNU Public Licence.]
57: */
58:
59: #include <stdio.h>
60: #include <stdlib.h>
61: #include <string.h>
62:
63: #include "apps.h"
64:
65: #include <openssl/bio.h>
66: #include <openssl/err.h>
67: #include <openssl/evp.h>
68: #include <openssl/hmac.h>
69: #include <openssl/objects.h>
70: #include <openssl/pem.h>
71: #include <openssl/x509.h>
72:
73: #define BUFSIZE 1024*8
74:
75: int
76: do_fp(BIO * out, unsigned char *buf, BIO * bp, int sep, int binout,
77: EVP_PKEY * key, unsigned char *sigin, int siglen,
78: const char *sig_name, const char *md_name,
79: const char *file, BIO * bmd);
80:
1.14 inoguchi 81: static struct {
82: int argsused;
83: int debug;
84: int do_verify;
85: char *hmac_key;
86: char *keyfile;
87: int keyform;
88: const EVP_MD *m;
89: char *mac_name;
90: STACK_OF(OPENSSL_STRING) *macopts;
91: const EVP_MD *md;
92: int out_bin;
93: char *outfile;
94: char *passargin;
95: int separator;
96: char *sigfile;
97: STACK_OF(OPENSSL_STRING) *sigopts;
98: int want_pub;
99: } dgst_config;
100:
1.15 inoguchi 101: static int
102: dgst_opt_macopt(char *arg)
103: {
104: if (arg == NULL)
105: return (1);
106:
107: if (dgst_config.macopts == NULL &&
108: (dgst_config.macopts = sk_OPENSSL_STRING_new_null()) == NULL)
109: return (1);
110:
111: if (!sk_OPENSSL_STRING_push(dgst_config.macopts, arg))
112: return (1);
113:
114: return (0);
115: }
116:
117: static int
118: dgst_opt_md(int argc, char **argv, int *argsused)
119: {
120: char *name = argv[0];
121:
122: if (*name++ != '-')
123: return (1);
124:
1.16 inoguchi 125: if ((dgst_config.m = EVP_get_digestbyname(name)) == NULL)
1.15 inoguchi 126: return (1);
127:
1.16 inoguchi 128: dgst_config.md = dgst_config.m;
129:
1.15 inoguchi 130: *argsused = 1;
131: return (0);
132: }
133:
134: static int
135: dgst_opt_prverify(char *arg)
136: {
137: if (arg == NULL)
138: return (1);
139:
140: dgst_config.keyfile = arg;
141: dgst_config.do_verify = 1;
142: return (0);
143: }
144:
145: static int
146: dgst_opt_sigopt(char *arg)
147: {
148: if (arg == NULL)
149: return (1);
150:
151: if (dgst_config.sigopts == NULL &&
152: (dgst_config.sigopts = sk_OPENSSL_STRING_new_null()) == NULL)
153: return (1);
154:
155: if (!sk_OPENSSL_STRING_push(dgst_config.sigopts, arg))
156: return (1);
157:
158: return (0);
159: }
160:
161: static int
162: dgst_opt_verify(char *arg)
163: {
164: if (arg == NULL)
165: return (1);
166:
167: dgst_config.keyfile = arg;
168: dgst_config.want_pub = 1;
169: dgst_config.do_verify = 1;
170: return (0);
171: }
172:
173: static const struct option dgst_options[] = {
174: {
175: .name = "binary",
1.16 inoguchi 176: .desc = "Output the digest or signature in binary form",
1.15 inoguchi 177: .type = OPTION_VALUE,
178: .opt.value = &dgst_config.out_bin,
179: .value = 1,
180: },
181: {
182: .name = "c",
1.16 inoguchi 183: .desc = "Print the digest in two-digit groups separated by colons",
1.15 inoguchi 184: .type = OPTION_VALUE,
185: .opt.value = &dgst_config.separator,
186: .value = 1,
187: },
188: {
189: .name = "d",
1.16 inoguchi 190: .desc = "Print BIO debugging information",
1.15 inoguchi 191: .type = OPTION_FLAG,
192: .opt.flag = &dgst_config.debug,
193: },
194: {
195: .name = "hex",
196: .desc = "Output as hex dump",
197: .type = OPTION_VALUE,
198: .opt.value = &dgst_config.out_bin,
199: .value = 0,
200: },
201: {
202: .name = "hmac",
203: .argname = "key",
204: .desc = "Create hashed MAC with key",
205: .type = OPTION_ARG,
206: .opt.arg = &dgst_config.hmac_key,
207: },
208: {
209: .name = "keyform",
210: .argname = "format",
211: .desc = "Key file format (PEM)",
212: .type = OPTION_ARG_FORMAT,
213: .opt.value = &dgst_config.keyform,
214: },
215: {
216: .name = "mac",
217: .argname = "algorithm",
218: .desc = "Create MAC (not necessarily HMAC)",
219: .type = OPTION_ARG,
220: .opt.arg = &dgst_config.mac_name,
221: },
222: {
223: .name = "macopt",
224: .argname = "nm:v",
225: .desc = "MAC algorithm parameters or key",
226: .type = OPTION_ARG_FUNC,
227: .opt.argfunc = dgst_opt_macopt,
228: },
229: {
230: .name = "out",
231: .argname = "file",
232: .desc = "Output to file rather than stdout",
233: .type = OPTION_ARG,
234: .opt.arg = &dgst_config.outfile,
235: },
236: {
237: .name = "passin",
238: .argname = "arg",
239: .desc = "Input file passphrase source",
240: .type = OPTION_ARG,
241: .opt.arg = &dgst_config.passargin,
242: },
243: {
244: .name = "prverify",
245: .argname = "file",
246: .desc = "Verify a signature using private key in file",
247: .type = OPTION_ARG_FUNC,
248: .opt.argfunc = dgst_opt_prverify,
249: },
250: {
251: .name = "r",
1.16 inoguchi 252: .desc = "Output the digest in coreutils format",
1.15 inoguchi 253: .type = OPTION_VALUE,
254: .opt.value = &dgst_config.separator,
255: .value = 2,
256: },
257: {
258: .name = "sign",
259: .argname = "file",
260: .desc = "Sign digest using private key in file",
261: .type = OPTION_ARG,
262: .opt.arg = &dgst_config.keyfile,
263: },
264: {
265: .name = "signature",
266: .argname = "file",
267: .desc = "Signature to verify",
268: .type = OPTION_ARG,
269: .opt.arg = &dgst_config.sigfile,
270: },
271: {
272: .name = "sigopt",
273: .argname = "nm:v",
274: .desc = "Signature parameter",
275: .type = OPTION_ARG_FUNC,
276: .opt.argfunc = dgst_opt_sigopt,
277: },
278: {
279: .name = "verify",
280: .argname = "file",
281: .desc = "Verify a signature using public key in file",
282: .type = OPTION_ARG_FUNC,
283: .opt.argfunc = dgst_opt_verify,
284: },
285: {
286: .name = NULL,
287: .desc = "",
288: .type = OPTION_ARGV_FUNC,
289: .opt.argvfunc = dgst_opt_md,
290: },
291: { NULL },
292: };
293:
1.1 jsing 294: static void
295: list_md_fn(const EVP_MD * m, const char *from, const char *to, void *arg)
296: {
297: const char *mname;
298: /* Skip aliases */
299: if (!m)
300: return;
301: mname = OBJ_nid2ln(EVP_MD_type(m));
302: /* Skip shortnames */
303: if (strcmp(from, mname))
304: return;
305: if (strchr(mname, ' '))
306: mname = EVP_MD_name(m);
1.15 inoguchi 307: BIO_printf(arg, " -%-17s To use the %s message digest algorithm\n",
1.1 jsing 308: mname, mname);
309: }
310:
1.15 inoguchi 311: static void
312: dgst_usage(void)
313: {
314: fprintf(stderr, "usage: dgst [-cdr] [-binary] [-digest] [-hex]");
315: fprintf(stderr, " [-hmac key] [-keyform fmt]\n");
316: fprintf(stderr, " [-mac algorithm] [-macopt nm:v] [-out file]");
317: fprintf(stderr, " [-passin arg]\n");
318: fprintf(stderr, " [-prverify file] [-sign file]");
319: fprintf(stderr, " [-signature file]\n");
320: fprintf(stderr, " [-sigopt nm:v] [-verify file] [file ...]\n\n");
321: options_usage(dgst_options);
322: EVP_MD_do_all_sorted(list_md_fn, bio_err);
323: fprintf(stderr, "\n");
324: }
325:
1.1 jsing 326: int
327: dgst_main(int argc, char **argv)
328: {
329: unsigned char *buf = NULL;
330: int i, err = 1;
331: BIO *in = NULL, *inp;
332: BIO *bmd = NULL;
333: BIO *out = NULL;
334: #define PROG_NAME_SIZE 39
335: char pname[PROG_NAME_SIZE + 1];
336: EVP_PKEY *sigkey = NULL;
337: unsigned char *sigbuf = NULL;
338: int siglen = 0;
1.14 inoguchi 339: char *passin = NULL;
1.7 doug 340:
341: if (single_execution) {
1.10 deraadt 342: if (pledge("stdio cpath wpath rpath tty", NULL) == -1) {
1.7 doug 343: perror("pledge");
1.9 doug 344: exit(1);
345: }
1.7 doug 346: }
1.1 jsing 347:
348: if ((buf = malloc(BUFSIZE)) == NULL) {
349: BIO_printf(bio_err, "out of memory\n");
350: goto end;
351: }
352:
1.14 inoguchi 353: memset(&dgst_config, 0, sizeof(dgst_config));
354: dgst_config.keyform = FORMAT_PEM;
355: dgst_config.out_bin = -1;
356:
1.1 jsing 357: /* first check the program name */
358: program_name(argv[0], pname, sizeof pname);
359:
1.14 inoguchi 360: dgst_config.md = EVP_get_digestbyname(pname);
1.1 jsing 361:
1.15 inoguchi 362: if (options_parse(argc, argv, dgst_options, NULL,
363: &dgst_config.argsused) != 0) {
364: dgst_usage();
365: goto end;
1.1 jsing 366: }
1.15 inoguchi 367: argc -= dgst_config.argsused;
368: argv += dgst_config.argsused;
1.1 jsing 369:
1.14 inoguchi 370: if (dgst_config.do_verify && !dgst_config.sigfile) {
1.17 inoguchi 371: BIO_printf(bio_err,
372: "No signature to verify: use the -signature option\n");
1.1 jsing 373: goto end;
374: }
1.2 doug 375:
1.1 jsing 376: in = BIO_new(BIO_s_file());
377: bmd = BIO_new(BIO_f_md());
1.2 doug 378: if (in == NULL || bmd == NULL) {
379: ERR_print_errors(bio_err);
380: goto end;
381: }
382:
1.14 inoguchi 383: if (dgst_config.debug) {
1.1 jsing 384: BIO_set_callback(in, BIO_debug_callback);
385: /* needed for windows 3.1 */
386: BIO_set_callback_arg(in, (char *) bio_err);
387: }
1.14 inoguchi 388: if (!app_passwd(bio_err, dgst_config.passargin, NULL, &passin, NULL)) {
1.1 jsing 389: BIO_printf(bio_err, "Error getting password\n");
390: goto end;
391: }
1.14 inoguchi 392: if (dgst_config.out_bin == -1) {
393: if (dgst_config.keyfile)
394: dgst_config.out_bin = 1;
1.1 jsing 395: else
1.14 inoguchi 396: dgst_config.out_bin = 0;
1.1 jsing 397: }
398:
1.14 inoguchi 399: if (dgst_config.outfile) {
400: if (dgst_config.out_bin)
401: out = BIO_new_file(dgst_config.outfile, "wb");
1.1 jsing 402: else
1.14 inoguchi 403: out = BIO_new_file(dgst_config.outfile, "w");
1.1 jsing 404: } else {
405: out = BIO_new_fp(stdout, BIO_NOCLOSE);
406: }
407:
408: if (!out) {
409: BIO_printf(bio_err, "Error opening output file %s\n",
1.14 inoguchi 410: dgst_config.outfile ? dgst_config.outfile : "(stdout)");
1.1 jsing 411: ERR_print_errors(bio_err);
412: goto end;
413: }
1.17 inoguchi 414: if ((!!dgst_config.mac_name + !!dgst_config.keyfile +
415: !!dgst_config.hmac_key) > 1) {
416: BIO_printf(bio_err,
417: "MAC and Signing key cannot both be specified\n");
1.1 jsing 418: goto end;
419: }
1.14 inoguchi 420: if (dgst_config.keyfile) {
421: if (dgst_config.want_pub)
1.17 inoguchi 422: sigkey = load_pubkey(bio_err, dgst_config.keyfile,
423: dgst_config.keyform, 0, NULL, "key file");
1.1 jsing 424: else
1.17 inoguchi 425: sigkey = load_key(bio_err, dgst_config.keyfile,
426: dgst_config.keyform, 0, passin, "key file");
1.1 jsing 427: if (!sigkey) {
428: /*
429: * load_[pub]key() has already printed an appropriate
430: * message
431: */
432: goto end;
433: }
434: }
1.14 inoguchi 435: if (dgst_config.mac_name) {
1.1 jsing 436: EVP_PKEY_CTX *mac_ctx = NULL;
437: int r = 0;
1.14 inoguchi 438: if (!init_gen_str(bio_err, &mac_ctx, dgst_config.mac_name, 0))
1.1 jsing 439: goto mac_end;
1.14 inoguchi 440: if (dgst_config.macopts) {
1.1 jsing 441: char *macopt;
1.17 inoguchi 442: for (i = 0; i < sk_OPENSSL_STRING_num(
443: dgst_config.macopts); i++) {
444: macopt = sk_OPENSSL_STRING_value(
445: dgst_config.macopts, i);
1.1 jsing 446: if (pkey_ctrl_string(mac_ctx, macopt) <= 0) {
447: BIO_printf(bio_err,
448: "MAC parameter error \"%s\"\n",
449: macopt);
450: ERR_print_errors(bio_err);
451: goto mac_end;
452: }
453: }
454: }
455: if (EVP_PKEY_keygen(mac_ctx, &sigkey) <= 0) {
456: BIO_puts(bio_err, "Error generating key\n");
457: ERR_print_errors(bio_err);
458: goto mac_end;
459: }
460: r = 1;
1.17 inoguchi 461: mac_end:
1.18 inoguchi 462: EVP_PKEY_CTX_free(mac_ctx);
1.1 jsing 463: if (r == 0)
464: goto end;
465: }
1.14 inoguchi 466: if (dgst_config.hmac_key) {
1.6 bcook 467: sigkey = EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL,
1.14 inoguchi 468: (unsigned char *) dgst_config.hmac_key, -1);
1.1 jsing 469: if (!sigkey)
470: goto end;
471: }
472: if (sigkey) {
473: EVP_MD_CTX *mctx = NULL;
474: EVP_PKEY_CTX *pctx = NULL;
475: int r;
476: if (!BIO_get_md_ctx(bmd, &mctx)) {
477: BIO_printf(bio_err, "Error getting context\n");
478: ERR_print_errors(bio_err);
479: goto end;
480: }
1.14 inoguchi 481: if (dgst_config.do_verify)
1.17 inoguchi 482: r = EVP_DigestVerifyInit(mctx, &pctx, dgst_config.md,
483: NULL, sigkey);
1.1 jsing 484: else
1.17 inoguchi 485: r = EVP_DigestSignInit(mctx, &pctx, dgst_config.md,
486: NULL, sigkey);
1.1 jsing 487: if (!r) {
488: BIO_printf(bio_err, "Error setting context\n");
489: ERR_print_errors(bio_err);
490: goto end;
491: }
1.14 inoguchi 492: if (dgst_config.sigopts) {
1.1 jsing 493: char *sigopt;
1.17 inoguchi 494: for (i = 0; i < sk_OPENSSL_STRING_num(
495: dgst_config.sigopts); i++) {
496: sigopt = sk_OPENSSL_STRING_value(
497: dgst_config.sigopts, i);
1.1 jsing 498: if (pkey_ctrl_string(pctx, sigopt) <= 0) {
499: BIO_printf(bio_err,
500: "parameter error \"%s\"\n",
501: sigopt);
502: ERR_print_errors(bio_err);
503: goto end;
504: }
505: }
506: }
507: }
508: /* we use md as a filter, reading from 'in' */
509: else {
1.14 inoguchi 510: if (dgst_config.md == NULL)
511: dgst_config.md = EVP_sha256();
512: if (!BIO_set_md(bmd, dgst_config.md)) {
1.1 jsing 513: BIO_printf(bio_err, "Error setting digest %s\n", pname);
514: ERR_print_errors(bio_err);
515: goto end;
516: }
517: }
518:
1.14 inoguchi 519: if (dgst_config.sigfile && sigkey) {
1.1 jsing 520: BIO *sigbio;
521: siglen = EVP_PKEY_size(sigkey);
522: sigbuf = malloc(siglen);
1.3 rpointel 523: if (sigbuf == NULL) {
524: BIO_printf(bio_err, "out of memory\n");
525: ERR_print_errors(bio_err);
526: goto end;
527: }
1.14 inoguchi 528: sigbio = BIO_new_file(dgst_config.sigfile, "rb");
1.1 jsing 529: if (!sigbio) {
530: BIO_printf(bio_err, "Error opening signature file %s\n",
1.14 inoguchi 531: dgst_config.sigfile);
1.1 jsing 532: ERR_print_errors(bio_err);
533: goto end;
534: }
535: siglen = BIO_read(sigbio, sigbuf, siglen);
536: BIO_free(sigbio);
537: if (siglen <= 0) {
538: BIO_printf(bio_err, "Error reading signature file %s\n",
1.14 inoguchi 539: dgst_config.sigfile);
1.1 jsing 540: ERR_print_errors(bio_err);
541: goto end;
542: }
543: }
544: inp = BIO_push(bmd, in);
545:
1.14 inoguchi 546: if (dgst_config.md == NULL) {
1.1 jsing 547: EVP_MD_CTX *tctx;
548: BIO_get_md_ctx(bmd, &tctx);
1.14 inoguchi 549: dgst_config.md = EVP_MD_CTX_md(tctx);
1.1 jsing 550: }
551: if (argc == 0) {
552: BIO_set_fp(in, stdin, BIO_NOCLOSE);
1.17 inoguchi 553: err = do_fp(out, buf, inp, dgst_config.separator,
554: dgst_config.out_bin, sigkey, sigbuf, siglen, NULL, NULL,
555: "stdin", bmd);
1.1 jsing 556: } else {
557: const char *md_name = NULL, *sig_name = NULL;
1.14 inoguchi 558: if (!dgst_config.out_bin) {
1.1 jsing 559: if (sigkey) {
560: const EVP_PKEY_ASN1_METHOD *ameth;
561: ameth = EVP_PKEY_get0_asn1(sigkey);
562: if (ameth)
563: EVP_PKEY_asn1_get0_info(NULL, NULL,
564: NULL, NULL, &sig_name, ameth);
565: }
1.14 inoguchi 566: md_name = EVP_MD_name(dgst_config.md);
1.1 jsing 567: }
568: err = 0;
569: for (i = 0; i < argc; i++) {
570: int r;
571: if (BIO_read_filename(in, argv[i]) <= 0) {
572: perror(argv[i]);
573: err++;
574: continue;
575: } else {
1.17 inoguchi 576: r = do_fp(out, buf, inp, dgst_config.separator,
577: dgst_config.out_bin, sigkey, sigbuf, siglen,
578: sig_name, md_name, argv[i], bmd);
1.1 jsing 579: }
580: if (r)
581: err = r;
582: (void) BIO_reset(bmd);
583: }
584: }
585:
1.12 jsing 586: end:
1.11 deraadt 587: freezero(buf, BUFSIZE);
1.18 inoguchi 588: BIO_free(in);
1.1 jsing 589: free(passin);
590: BIO_free_all(out);
591: EVP_PKEY_free(sigkey);
1.18 inoguchi 592: sk_OPENSSL_STRING_free(dgst_config.sigopts);
593: sk_OPENSSL_STRING_free(dgst_config.macopts);
1.1 jsing 594: free(sigbuf);
1.18 inoguchi 595: BIO_free(bmd);
1.1 jsing 596:
597: return (err);
598: }
599:
600: int
601: do_fp(BIO * out, unsigned char *buf, BIO * bp, int sep, int binout,
602: EVP_PKEY * key, unsigned char *sigin, int siglen,
603: const char *sig_name, const char *md_name,
604: const char *file, BIO * bmd)
605: {
606: size_t len;
607: int i;
608:
609: for (;;) {
610: i = BIO_read(bp, (char *) buf, BUFSIZE);
611: if (i < 0) {
612: BIO_printf(bio_err, "Read Error in %s\n", file);
613: ERR_print_errors(bio_err);
614: return 1;
615: }
616: if (i == 0)
617: break;
618: }
619: if (sigin) {
620: EVP_MD_CTX *ctx;
621: BIO_get_md_ctx(bp, &ctx);
622: i = EVP_DigestVerifyFinal(ctx, sigin, (unsigned int) siglen);
623: if (i > 0)
624: BIO_printf(out, "Verified OK\n");
625: else if (i == 0) {
626: BIO_printf(out, "Verification Failure\n");
627: return 1;
628: } else {
629: BIO_printf(bio_err, "Error Verifying Data\n");
630: ERR_print_errors(bio_err);
631: return 1;
632: }
633: return 0;
634: }
635: if (key) {
636: EVP_MD_CTX *ctx;
637: BIO_get_md_ctx(bp, &ctx);
638: len = BUFSIZE;
639: if (!EVP_DigestSignFinal(ctx, buf, &len)) {
640: BIO_printf(bio_err, "Error Signing Data\n");
641: ERR_print_errors(bio_err);
642: return 1;
643: }
644: } else {
645: len = BIO_gets(bp, (char *) buf, BUFSIZE);
646: if ((int) len < 0) {
647: ERR_print_errors(bio_err);
648: return 1;
649: }
650: }
651:
652: if (binout)
653: BIO_write(out, buf, len);
654: else if (sep == 2) {
655: for (i = 0; i < (int) len; i++)
656: BIO_printf(out, "%02x", buf[i]);
657: BIO_printf(out, " *%s\n", file);
658: } else {
659: if (sig_name)
660: BIO_printf(out, "%s-%s(%s)= ", sig_name, md_name, file);
661: else if (md_name)
662: BIO_printf(out, "%s(%s)= ", md_name, file);
663: else
664: BIO_printf(out, "(%s)= ", file);
665: for (i = 0; i < (int) len; i++) {
666: if (sep && (i != 0))
667: BIO_printf(out, ":");
668: BIO_printf(out, "%02x", buf[i]);
669: }
670: BIO_printf(out, "\n");
671: }
672: return 0;
673: }