1 | /*
|
---|
2 | * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
|
---|
3 | *
|
---|
4 | * Licensed under the OpenSSL license (the "License"). You may not use
|
---|
5 | * this file except in compliance with the License. You can obtain a copy
|
---|
6 | * in the file LICENSE in the source distribution or at
|
---|
7 | * https://www.openssl.org/source/license.html
|
---|
8 | */
|
---|
9 |
|
---|
10 | #include <stdio.h>
|
---|
11 | #include <string.h>
|
---|
12 | #include <stdlib.h>
|
---|
13 | #include "apps.h"
|
---|
14 | #include <openssl/bio.h>
|
---|
15 | #include <openssl/err.h>
|
---|
16 | #include <openssl/evp.h>
|
---|
17 | #include <openssl/objects.h>
|
---|
18 | #include <openssl/x509.h>
|
---|
19 | #include <openssl/pem.h>
|
---|
20 | #include <openssl/hmac.h>
|
---|
21 |
|
---|
22 | #undef BUFSIZE
|
---|
23 | #define BUFSIZE 1024*8
|
---|
24 |
|
---|
25 | int do_fp(BIO *out, unsigned char *buf, BIO *bp, int sep, int binout,
|
---|
26 | EVP_PKEY *key, unsigned char *sigin, int siglen,
|
---|
27 | const char *sig_name, const char *md_name,
|
---|
28 | const char *file);
|
---|
29 |
|
---|
30 | typedef enum OPTION_choice {
|
---|
31 | OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
|
---|
32 | OPT_C, OPT_R, OPT_RAND, OPT_OUT, OPT_SIGN, OPT_PASSIN, OPT_VERIFY,
|
---|
33 | OPT_PRVERIFY, OPT_SIGNATURE, OPT_KEYFORM, OPT_ENGINE, OPT_ENGINE_IMPL,
|
---|
34 | OPT_HEX, OPT_BINARY, OPT_DEBUG, OPT_FIPS_FINGERPRINT,
|
---|
35 | OPT_HMAC, OPT_MAC, OPT_SIGOPT, OPT_MACOPT,
|
---|
36 | OPT_DIGEST
|
---|
37 | } OPTION_CHOICE;
|
---|
38 |
|
---|
39 | OPTIONS dgst_options[] = {
|
---|
40 | {OPT_HELP_STR, 1, '-', "Usage: %s [options] [file...]\n"},
|
---|
41 | {OPT_HELP_STR, 1, '-',
|
---|
42 | " file... files to digest (default is stdin)\n"},
|
---|
43 | {"help", OPT_HELP, '-', "Display this summary"},
|
---|
44 | {"c", OPT_C, '-', "Print the digest with separating colons"},
|
---|
45 | {"r", OPT_R, '-', "Print the digest in coreutils format"},
|
---|
46 | {"rand", OPT_RAND, 's',
|
---|
47 | "Use file(s) containing random data to seed RNG or an EGD sock"},
|
---|
48 | {"out", OPT_OUT, '>', "Output to filename rather than stdout"},
|
---|
49 | {"passin", OPT_PASSIN, 's', "Input file pass phrase source"},
|
---|
50 | {"sign", OPT_SIGN, 's', "Sign digest using private key"},
|
---|
51 | {"verify", OPT_VERIFY, 's',
|
---|
52 | "Verify a signature using public key"},
|
---|
53 | {"prverify", OPT_PRVERIFY, 's',
|
---|
54 | "Verify a signature using private key"},
|
---|
55 | {"signature", OPT_SIGNATURE, '<', "File with signature to verify"},
|
---|
56 | {"keyform", OPT_KEYFORM, 'f', "Key file format (PEM or ENGINE)"},
|
---|
57 | {"hex", OPT_HEX, '-', "Print as hex dump"},
|
---|
58 | {"binary", OPT_BINARY, '-', "Print in binary form"},
|
---|
59 | {"d", OPT_DEBUG, '-', "Print debug info"},
|
---|
60 | {"debug", OPT_DEBUG, '-', "Print debug info"},
|
---|
61 | {"fips-fingerprint", OPT_FIPS_FINGERPRINT, '-',
|
---|
62 | "Compute HMAC with the key used in OpenSSL-FIPS fingerprint"},
|
---|
63 | {"hmac", OPT_HMAC, 's', "Create hashed MAC with key"},
|
---|
64 | {"mac", OPT_MAC, 's', "Create MAC (not necessarily HMAC)"},
|
---|
65 | {"sigopt", OPT_SIGOPT, 's', "Signature parameter in n:v form"},
|
---|
66 | {"macopt", OPT_MACOPT, 's', "MAC algorithm parameters in n:v form or key"},
|
---|
67 | {"", OPT_DIGEST, '-', "Any supported digest"},
|
---|
68 | #ifndef OPENSSL_NO_ENGINE
|
---|
69 | {"engine", OPT_ENGINE, 's', "Use engine e, possibly a hardware device"},
|
---|
70 | {"engine_impl", OPT_ENGINE_IMPL, '-',
|
---|
71 | "Also use engine given by -engine for digest operations"},
|
---|
72 | #endif
|
---|
73 | {NULL}
|
---|
74 | };
|
---|
75 |
|
---|
76 | int dgst_main(int argc, char **argv)
|
---|
77 | {
|
---|
78 | BIO *in = NULL, *inp, *bmd = NULL, *out = NULL;
|
---|
79 | ENGINE *e = NULL, *impl = NULL;
|
---|
80 | EVP_PKEY *sigkey = NULL;
|
---|
81 | STACK_OF(OPENSSL_STRING) *sigopts = NULL, *macopts = NULL;
|
---|
82 | char *hmac_key = NULL;
|
---|
83 | char *mac_name = NULL;
|
---|
84 | char *passinarg = NULL, *passin = NULL;
|
---|
85 | const EVP_MD *md = NULL, *m;
|
---|
86 | const char *outfile = NULL, *keyfile = NULL, *prog = NULL;
|
---|
87 | const char *sigfile = NULL, *randfile = NULL;
|
---|
88 | OPTION_CHOICE o;
|
---|
89 | int separator = 0, debug = 0, keyform = FORMAT_PEM, siglen = 0;
|
---|
90 | int i, ret = 1, out_bin = -1, want_pub = 0, do_verify = 0;
|
---|
91 | unsigned char *buf = NULL, *sigbuf = NULL;
|
---|
92 | int engine_impl = 0;
|
---|
93 |
|
---|
94 | prog = opt_progname(argv[0]);
|
---|
95 | buf = app_malloc(BUFSIZE, "I/O buffer");
|
---|
96 | md = EVP_get_digestbyname(prog);
|
---|
97 |
|
---|
98 | prog = opt_init(argc, argv, dgst_options);
|
---|
99 | while ((o = opt_next()) != OPT_EOF) {
|
---|
100 | switch (o) {
|
---|
101 | case OPT_EOF:
|
---|
102 | case OPT_ERR:
|
---|
103 | opthelp:
|
---|
104 | BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
|
---|
105 | goto end;
|
---|
106 | case OPT_HELP:
|
---|
107 | opt_help(dgst_options);
|
---|
108 | ret = 0;
|
---|
109 | goto end;
|
---|
110 | case OPT_C:
|
---|
111 | separator = 1;
|
---|
112 | break;
|
---|
113 | case OPT_R:
|
---|
114 | separator = 2;
|
---|
115 | break;
|
---|
116 | case OPT_RAND:
|
---|
117 | randfile = opt_arg();
|
---|
118 | break;
|
---|
119 | case OPT_OUT:
|
---|
120 | outfile = opt_arg();
|
---|
121 | break;
|
---|
122 | case OPT_SIGN:
|
---|
123 | keyfile = opt_arg();
|
---|
124 | break;
|
---|
125 | case OPT_PASSIN:
|
---|
126 | passinarg = opt_arg();
|
---|
127 | break;
|
---|
128 | case OPT_VERIFY:
|
---|
129 | keyfile = opt_arg();
|
---|
130 | want_pub = do_verify = 1;
|
---|
131 | break;
|
---|
132 | case OPT_PRVERIFY:
|
---|
133 | keyfile = opt_arg();
|
---|
134 | do_verify = 1;
|
---|
135 | break;
|
---|
136 | case OPT_SIGNATURE:
|
---|
137 | sigfile = opt_arg();
|
---|
138 | break;
|
---|
139 | case OPT_KEYFORM:
|
---|
140 | if (!opt_format(opt_arg(), OPT_FMT_ANY, &keyform))
|
---|
141 | goto opthelp;
|
---|
142 | break;
|
---|
143 | case OPT_ENGINE:
|
---|
144 | e = setup_engine(opt_arg(), 0);
|
---|
145 | break;
|
---|
146 | case OPT_ENGINE_IMPL:
|
---|
147 | engine_impl = 1;
|
---|
148 | break;
|
---|
149 | case OPT_HEX:
|
---|
150 | out_bin = 0;
|
---|
151 | break;
|
---|
152 | case OPT_BINARY:
|
---|
153 | out_bin = 1;
|
---|
154 | break;
|
---|
155 | case OPT_DEBUG:
|
---|
156 | debug = 1;
|
---|
157 | break;
|
---|
158 | case OPT_FIPS_FINGERPRINT:
|
---|
159 | hmac_key = "etaonrishdlcupfm";
|
---|
160 | break;
|
---|
161 | case OPT_HMAC:
|
---|
162 | hmac_key = opt_arg();
|
---|
163 | break;
|
---|
164 | case OPT_MAC:
|
---|
165 | mac_name = opt_arg();
|
---|
166 | break;
|
---|
167 | case OPT_SIGOPT:
|
---|
168 | if (!sigopts)
|
---|
169 | sigopts = sk_OPENSSL_STRING_new_null();
|
---|
170 | if (!sigopts || !sk_OPENSSL_STRING_push(sigopts, opt_arg()))
|
---|
171 | goto opthelp;
|
---|
172 | break;
|
---|
173 | case OPT_MACOPT:
|
---|
174 | if (!macopts)
|
---|
175 | macopts = sk_OPENSSL_STRING_new_null();
|
---|
176 | if (!macopts || !sk_OPENSSL_STRING_push(macopts, opt_arg()))
|
---|
177 | goto opthelp;
|
---|
178 | break;
|
---|
179 | case OPT_DIGEST:
|
---|
180 | if (!opt_md(opt_unknown(), &m))
|
---|
181 | goto opthelp;
|
---|
182 | md = m;
|
---|
183 | break;
|
---|
184 | }
|
---|
185 | }
|
---|
186 | argc = opt_num_rest();
|
---|
187 | argv = opt_rest();
|
---|
188 | if (keyfile != NULL && argc > 1) {
|
---|
189 | BIO_printf(bio_err, "%s: Can only sign or verify one file.\n", prog);
|
---|
190 | goto end;
|
---|
191 | }
|
---|
192 |
|
---|
193 | if (do_verify && !sigfile) {
|
---|
194 | BIO_printf(bio_err,
|
---|
195 | "No signature to verify: use the -signature option\n");
|
---|
196 | goto end;
|
---|
197 | }
|
---|
198 | if (engine_impl)
|
---|
199 | impl = e;
|
---|
200 |
|
---|
201 | in = BIO_new(BIO_s_file());
|
---|
202 | bmd = BIO_new(BIO_f_md());
|
---|
203 | if ((in == NULL) || (bmd == NULL)) {
|
---|
204 | ERR_print_errors(bio_err);
|
---|
205 | goto end;
|
---|
206 | }
|
---|
207 |
|
---|
208 | if (debug) {
|
---|
209 | BIO_set_callback(in, BIO_debug_callback);
|
---|
210 | /* needed for windows 3.1 */
|
---|
211 | BIO_set_callback_arg(in, (char *)bio_err);
|
---|
212 | }
|
---|
213 |
|
---|
214 | if (!app_passwd(passinarg, NULL, &passin, NULL)) {
|
---|
215 | BIO_printf(bio_err, "Error getting password\n");
|
---|
216 | goto end;
|
---|
217 | }
|
---|
218 |
|
---|
219 | if (out_bin == -1) {
|
---|
220 | if (keyfile)
|
---|
221 | out_bin = 1;
|
---|
222 | else
|
---|
223 | out_bin = 0;
|
---|
224 | }
|
---|
225 |
|
---|
226 | if (randfile)
|
---|
227 | app_RAND_load_file(randfile, 0);
|
---|
228 |
|
---|
229 | out = bio_open_default(outfile, 'w', out_bin ? FORMAT_BINARY : FORMAT_TEXT);
|
---|
230 | if (out == NULL)
|
---|
231 | goto end;
|
---|
232 |
|
---|
233 | if ((! !mac_name + ! !keyfile + ! !hmac_key) > 1) {
|
---|
234 | BIO_printf(bio_err, "MAC and Signing key cannot both be specified\n");
|
---|
235 | goto end;
|
---|
236 | }
|
---|
237 |
|
---|
238 | if (keyfile) {
|
---|
239 | if (want_pub)
|
---|
240 | sigkey = load_pubkey(keyfile, keyform, 0, NULL, e, "key file");
|
---|
241 | else
|
---|
242 | sigkey = load_key(keyfile, keyform, 0, passin, e, "key file");
|
---|
243 | if (!sigkey) {
|
---|
244 | /*
|
---|
245 | * load_[pub]key() has already printed an appropriate message
|
---|
246 | */
|
---|
247 | goto end;
|
---|
248 | }
|
---|
249 | }
|
---|
250 |
|
---|
251 | if (mac_name) {
|
---|
252 | EVP_PKEY_CTX *mac_ctx = NULL;
|
---|
253 | int r = 0;
|
---|
254 | if (!init_gen_str(&mac_ctx, mac_name, impl, 0))
|
---|
255 | goto mac_end;
|
---|
256 | if (macopts) {
|
---|
257 | char *macopt;
|
---|
258 | for (i = 0; i < sk_OPENSSL_STRING_num(macopts); i++) {
|
---|
259 | macopt = sk_OPENSSL_STRING_value(macopts, i);
|
---|
260 | if (pkey_ctrl_string(mac_ctx, macopt) <= 0) {
|
---|
261 | BIO_printf(bio_err,
|
---|
262 | "MAC parameter error \"%s\"\n", macopt);
|
---|
263 | ERR_print_errors(bio_err);
|
---|
264 | goto mac_end;
|
---|
265 | }
|
---|
266 | }
|
---|
267 | }
|
---|
268 | if (EVP_PKEY_keygen(mac_ctx, &sigkey) <= 0) {
|
---|
269 | BIO_puts(bio_err, "Error generating key\n");
|
---|
270 | ERR_print_errors(bio_err);
|
---|
271 | goto mac_end;
|
---|
272 | }
|
---|
273 | r = 1;
|
---|
274 | mac_end:
|
---|
275 | EVP_PKEY_CTX_free(mac_ctx);
|
---|
276 | if (r == 0)
|
---|
277 | goto end;
|
---|
278 | }
|
---|
279 |
|
---|
280 | if (hmac_key) {
|
---|
281 | sigkey = EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, impl,
|
---|
282 | (unsigned char *)hmac_key, -1);
|
---|
283 | if (!sigkey)
|
---|
284 | goto end;
|
---|
285 | }
|
---|
286 |
|
---|
287 | if (sigkey) {
|
---|
288 | EVP_MD_CTX *mctx = NULL;
|
---|
289 | EVP_PKEY_CTX *pctx = NULL;
|
---|
290 | int r;
|
---|
291 | if (!BIO_get_md_ctx(bmd, &mctx)) {
|
---|
292 | BIO_printf(bio_err, "Error getting context\n");
|
---|
293 | ERR_print_errors(bio_err);
|
---|
294 | goto end;
|
---|
295 | }
|
---|
296 | if (do_verify)
|
---|
297 | r = EVP_DigestVerifyInit(mctx, &pctx, md, impl, sigkey);
|
---|
298 | else
|
---|
299 | r = EVP_DigestSignInit(mctx, &pctx, md, impl, sigkey);
|
---|
300 | if (!r) {
|
---|
301 | BIO_printf(bio_err, "Error setting context\n");
|
---|
302 | ERR_print_errors(bio_err);
|
---|
303 | goto end;
|
---|
304 | }
|
---|
305 | if (sigopts) {
|
---|
306 | char *sigopt;
|
---|
307 | for (i = 0; i < sk_OPENSSL_STRING_num(sigopts); i++) {
|
---|
308 | sigopt = sk_OPENSSL_STRING_value(sigopts, i);
|
---|
309 | if (pkey_ctrl_string(pctx, sigopt) <= 0) {
|
---|
310 | BIO_printf(bio_err, "parameter error \"%s\"\n", sigopt);
|
---|
311 | ERR_print_errors(bio_err);
|
---|
312 | goto end;
|
---|
313 | }
|
---|
314 | }
|
---|
315 | }
|
---|
316 | }
|
---|
317 | /* we use md as a filter, reading from 'in' */
|
---|
318 | else {
|
---|
319 | EVP_MD_CTX *mctx = NULL;
|
---|
320 | if (!BIO_get_md_ctx(bmd, &mctx)) {
|
---|
321 | BIO_printf(bio_err, "Error getting context\n");
|
---|
322 | ERR_print_errors(bio_err);
|
---|
323 | goto end;
|
---|
324 | }
|
---|
325 | if (md == NULL)
|
---|
326 | md = EVP_sha256();
|
---|
327 | if (!EVP_DigestInit_ex(mctx, md, impl)) {
|
---|
328 | BIO_printf(bio_err, "Error setting digest\n");
|
---|
329 | ERR_print_errors(bio_err);
|
---|
330 | goto end;
|
---|
331 | }
|
---|
332 | }
|
---|
333 |
|
---|
334 | if (sigfile && sigkey) {
|
---|
335 | BIO *sigbio = BIO_new_file(sigfile, "rb");
|
---|
336 | if (!sigbio) {
|
---|
337 | BIO_printf(bio_err, "Error opening signature file %s\n", sigfile);
|
---|
338 | ERR_print_errors(bio_err);
|
---|
339 | goto end;
|
---|
340 | }
|
---|
341 | siglen = EVP_PKEY_size(sigkey);
|
---|
342 | sigbuf = app_malloc(siglen, "signature buffer");
|
---|
343 | siglen = BIO_read(sigbio, sigbuf, siglen);
|
---|
344 | BIO_free(sigbio);
|
---|
345 | if (siglen <= 0) {
|
---|
346 | BIO_printf(bio_err, "Error reading signature file %s\n", sigfile);
|
---|
347 | ERR_print_errors(bio_err);
|
---|
348 | goto end;
|
---|
349 | }
|
---|
350 | }
|
---|
351 | inp = BIO_push(bmd, in);
|
---|
352 |
|
---|
353 | if (md == NULL) {
|
---|
354 | EVP_MD_CTX *tctx;
|
---|
355 | BIO_get_md_ctx(bmd, &tctx);
|
---|
356 | md = EVP_MD_CTX_md(tctx);
|
---|
357 | }
|
---|
358 |
|
---|
359 | if (argc == 0) {
|
---|
360 | BIO_set_fp(in, stdin, BIO_NOCLOSE);
|
---|
361 | ret = do_fp(out, buf, inp, separator, out_bin, sigkey, sigbuf,
|
---|
362 | siglen, NULL, NULL, "stdin");
|
---|
363 | } else {
|
---|
364 | const char *md_name = NULL, *sig_name = NULL;
|
---|
365 | if (!out_bin) {
|
---|
366 | if (sigkey) {
|
---|
367 | const EVP_PKEY_ASN1_METHOD *ameth;
|
---|
368 | ameth = EVP_PKEY_get0_asn1(sigkey);
|
---|
369 | if (ameth)
|
---|
370 | EVP_PKEY_asn1_get0_info(NULL, NULL,
|
---|
371 | NULL, NULL, &sig_name, ameth);
|
---|
372 | }
|
---|
373 | if (md)
|
---|
374 | md_name = EVP_MD_name(md);
|
---|
375 | }
|
---|
376 | ret = 0;
|
---|
377 | for (i = 0; i < argc; i++) {
|
---|
378 | int r;
|
---|
379 | if (BIO_read_filename(in, argv[i]) <= 0) {
|
---|
380 | perror(argv[i]);
|
---|
381 | ret++;
|
---|
382 | continue;
|
---|
383 | } else
|
---|
384 | r = do_fp(out, buf, inp, separator, out_bin, sigkey, sigbuf,
|
---|
385 | siglen, sig_name, md_name, argv[i]);
|
---|
386 | if (r)
|
---|
387 | ret = r;
|
---|
388 | (void)BIO_reset(bmd);
|
---|
389 | }
|
---|
390 | }
|
---|
391 | end:
|
---|
392 | OPENSSL_clear_free(buf, BUFSIZE);
|
---|
393 | BIO_free(in);
|
---|
394 | OPENSSL_free(passin);
|
---|
395 | BIO_free_all(out);
|
---|
396 | EVP_PKEY_free(sigkey);
|
---|
397 | sk_OPENSSL_STRING_free(sigopts);
|
---|
398 | sk_OPENSSL_STRING_free(macopts);
|
---|
399 | OPENSSL_free(sigbuf);
|
---|
400 | BIO_free(bmd);
|
---|
401 | release_engine(e);
|
---|
402 | return (ret);
|
---|
403 | }
|
---|
404 |
|
---|
405 | int do_fp(BIO *out, unsigned char *buf, BIO *bp, int sep, int binout,
|
---|
406 | EVP_PKEY *key, unsigned char *sigin, int siglen,
|
---|
407 | const char *sig_name, const char *md_name,
|
---|
408 | const char *file)
|
---|
409 | {
|
---|
410 | size_t len;
|
---|
411 | int i;
|
---|
412 |
|
---|
413 | for (;;) {
|
---|
414 | i = BIO_read(bp, (char *)buf, BUFSIZE);
|
---|
415 | if (i < 0) {
|
---|
416 | BIO_printf(bio_err, "Read Error in %s\n", file);
|
---|
417 | ERR_print_errors(bio_err);
|
---|
418 | return 1;
|
---|
419 | }
|
---|
420 | if (i == 0)
|
---|
421 | break;
|
---|
422 | }
|
---|
423 | if (sigin) {
|
---|
424 | EVP_MD_CTX *ctx;
|
---|
425 | BIO_get_md_ctx(bp, &ctx);
|
---|
426 | i = EVP_DigestVerifyFinal(ctx, sigin, (unsigned int)siglen);
|
---|
427 | if (i > 0)
|
---|
428 | BIO_printf(out, "Verified OK\n");
|
---|
429 | else if (i == 0) {
|
---|
430 | BIO_printf(out, "Verification Failure\n");
|
---|
431 | return 1;
|
---|
432 | } else {
|
---|
433 | BIO_printf(bio_err, "Error Verifying Data\n");
|
---|
434 | ERR_print_errors(bio_err);
|
---|
435 | return 1;
|
---|
436 | }
|
---|
437 | return 0;
|
---|
438 | }
|
---|
439 | if (key) {
|
---|
440 | EVP_MD_CTX *ctx;
|
---|
441 | BIO_get_md_ctx(bp, &ctx);
|
---|
442 | len = BUFSIZE;
|
---|
443 | if (!EVP_DigestSignFinal(ctx, buf, &len)) {
|
---|
444 | BIO_printf(bio_err, "Error Signing Data\n");
|
---|
445 | ERR_print_errors(bio_err);
|
---|
446 | return 1;
|
---|
447 | }
|
---|
448 | } else {
|
---|
449 | len = BIO_gets(bp, (char *)buf, BUFSIZE);
|
---|
450 | if ((int)len < 0) {
|
---|
451 | ERR_print_errors(bio_err);
|
---|
452 | return 1;
|
---|
453 | }
|
---|
454 | }
|
---|
455 |
|
---|
456 | if (binout)
|
---|
457 | BIO_write(out, buf, len);
|
---|
458 | else if (sep == 2) {
|
---|
459 | for (i = 0; i < (int)len; i++)
|
---|
460 | BIO_printf(out, "%02x", buf[i]);
|
---|
461 | BIO_printf(out, " *%s\n", file);
|
---|
462 | } else {
|
---|
463 | if (sig_name) {
|
---|
464 | BIO_puts(out, sig_name);
|
---|
465 | if (md_name)
|
---|
466 | BIO_printf(out, "-%s", md_name);
|
---|
467 | BIO_printf(out, "(%s)= ", file);
|
---|
468 | } else if (md_name)
|
---|
469 | BIO_printf(out, "%s(%s)= ", md_name, file);
|
---|
470 | else
|
---|
471 | BIO_printf(out, "(%s)= ", file);
|
---|
472 | for (i = 0; i < (int)len; i++) {
|
---|
473 | if (sep && (i != 0))
|
---|
474 | BIO_printf(out, ":");
|
---|
475 | BIO_printf(out, "%02x", buf[i]);
|
---|
476 | }
|
---|
477 | BIO_printf(out, "\n");
|
---|
478 | }
|
---|
479 | return 0;
|
---|
480 | }
|
---|