![[BACK]](/icons/back.gif){kind=icon}
Return to enc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / openssl|
Return to enc.c CVS log | Up to [local] / src / usr.bin / openssl |
1.28 ! tb 1: /* $OpenBSD: enc.c,v 1.27 2023/03/06 14:32:06 tb 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/comp.h>
67: #include <openssl/err.h>
68: #include <openssl/evp.h>
69: #include <openssl/objects.h>
70: #include <openssl/pem.h>
71: #include <openssl/x509.h>
72:
73: int set_hex(char *in, unsigned char *out, int size);
74:
75: #define SIZE (512)
76: #define BSIZE (8*1024)
1.4 jsing 77:
78: static struct {
79: int base64;
80: char *bufsize;
81: const EVP_CIPHER *cipher;
82: int debug;
83: int enc;
84: char *hiv;
85: char *hkey;
86: char *hsalt;
87: char *inf;
1.20 jsing 88: int iter;
1.4 jsing 89: char *keyfile;
90: char *keystr;
91: char *md;
92: int nopad;
93: int nosalt;
94: int olb64;
95: char *outf;
96: char *passarg;
1.20 jsing 97: int pbkdf2;
1.4 jsing 98: int printkey;
99: int verbose;
1.27 tb 100: } cfg;
1.4 jsing 101:
102: static int
103: enc_opt_cipher(int argc, char **argv, int *argsused)
104: {
105: char *name = argv[0];
106:
107: if (*name++ != '-')
108: return (1);
109:
110: if (strcmp(name, "none") == 0) {
1.27 tb 111: cfg.cipher = NULL;
1.4 jsing 112: *argsused = 1;
113: return (0);
114: }
115:
1.27 tb 116: if ((cfg.cipher = EVP_get_cipherbyname(name)) != NULL) {
1.4 jsing 117: *argsused = 1;
118: return (0);
119: }
120:
121: return (1);
122: }
123:
1.21 guenther 124: static const struct option enc_options[] = {
1.4 jsing 125: {
126: .name = "A",
127: .desc = "Process base64 data on one line (requires -a)",
128: .type = OPTION_FLAG,
1.27 tb 129: .opt.flag = &cfg.olb64,
1.4 jsing 130: },
131: {
132: .name = "a",
133: .desc = "Perform base64 encoding/decoding (alias -base64)",
134: .type = OPTION_FLAG,
1.27 tb 135: .opt.flag = &cfg.base64,
1.4 jsing 136: },
137: {
138: .name = "base64",
139: .type = OPTION_FLAG,
1.27 tb 140: .opt.flag = &cfg.base64,
1.4 jsing 141: },
142: {
143: .name = "bufsize",
144: .argname = "size",
145: .desc = "Specify the buffer size to use for I/O",
146: .type = OPTION_ARG,
1.27 tb 147: .opt.arg = &cfg.bufsize,
1.4 jsing 148: },
149: {
150: .name = "d",
151: .desc = "Decrypt the input data",
152: .type = OPTION_VALUE,
1.27 tb 153: .opt.value = &cfg.enc,
1.4 jsing 154: .value = 0,
155: },
156: {
157: .name = "debug",
158: .desc = "Print debugging information",
159: .type = OPTION_FLAG,
1.27 tb 160: .opt.flag = &cfg.debug,
1.4 jsing 161: },
162: {
163: .name = "e",
164: .desc = "Encrypt the input data (default)",
165: .type = OPTION_VALUE,
1.27 tb 166: .opt.value = &cfg.enc,
1.4 jsing 167: .value = 1,
168: },
169: {
170: .name = "in",
171: .argname = "file",
172: .desc = "Input file to read from (default stdin)",
173: .type = OPTION_ARG,
1.27 tb 174: .opt.arg = &cfg.inf,
1.4 jsing 175: },
176: {
1.16 naddy 177: .name = "iter",
178: .argname = "iterations",
179: .desc = "Specify iteration count and force use of PBKDF2",
1.19 jsing 180: .type = OPTION_ARG_INT,
1.27 tb 181: .opt.value = &cfg.iter,
1.16 naddy 182: },
183: {
1.4 jsing 184: .name = "iv",
185: .argname = "IV",
1.11 jmc 186: .desc = "IV to use, specified as a hexadecimal string",
1.4 jsing 187: .type = OPTION_ARG,
1.27 tb 188: .opt.arg = &cfg.hiv,
1.4 jsing 189: },
190: {
191: .name = "K",
192: .argname = "key",
1.11 jmc 193: .desc = "Key to use, specified as a hexadecimal string",
1.4 jsing 194: .type = OPTION_ARG,
1.27 tb 195: .opt.arg = &cfg.hkey,
1.4 jsing 196: },
197: {
198: .name = "k", /* Superseded by -pass. */
199: .type = OPTION_ARG,
1.27 tb 200: .opt.arg = &cfg.keystr,
1.4 jsing 201: },
202: {
203: .name = "kfile", /* Superseded by -pass. */
204: .type = OPTION_ARG,
1.27 tb 205: .opt.arg = &cfg.keyfile,
1.4 jsing 206: },
207: {
208: .name = "md",
209: .argname = "digest",
210: .desc = "Digest to use to create a key from the passphrase",
211: .type = OPTION_ARG,
1.27 tb 212: .opt.arg = &cfg.md,
1.4 jsing 213: },
214: {
215: .name = "none",
216: .desc = "Use NULL cipher (no encryption or decryption)",
217: .type = OPTION_ARGV_FUNC,
218: .opt.argvfunc = enc_opt_cipher,
219: },
220: {
221: .name = "nopad",
222: .desc = "Disable standard block padding",
223: .type = OPTION_FLAG,
1.27 tb 224: .opt.flag = &cfg.nopad,
1.4 jsing 225: },
226: {
227: .name = "nosalt",
228: .type = OPTION_VALUE,
1.27 tb 229: .opt.value = &cfg.nosalt,
1.4 jsing 230: .value = 1,
231: },
232: {
233: .name = "out",
234: .argname = "file",
235: .desc = "Output file to write to (default stdout)",
236: .type = OPTION_ARG,
1.27 tb 237: .opt.arg = &cfg.outf,
1.4 jsing 238: },
239: {
240: .name = "P",
241: .desc = "Print out the salt, key and IV used, then exit\n"
242: " (no encryption or decryption is performed)",
243: .type = OPTION_VALUE,
1.27 tb 244: .opt.value = &cfg.printkey,
1.4 jsing 245: .value = 2,
246: },
247: {
248: .name = "p",
249: .desc = "Print out the salt, key and IV used",
250: .type = OPTION_VALUE,
1.27 tb 251: .opt.value = &cfg.printkey,
1.4 jsing 252: .value = 1,
253: },
254: {
255: .name = "pass",
256: .argname = "source",
257: .desc = "Password source",
258: .type = OPTION_ARG,
1.27 tb 259: .opt.arg = &cfg.passarg,
1.4 jsing 260: },
261: {
1.16 naddy 262: .name = "pbkdf2",
263: .desc = "Use the pbkdf2 key derivation function",
264: .type = OPTION_FLAG,
1.27 tb 265: .opt.flag = &cfg.pbkdf2,
1.16 naddy 266: },
267: {
1.4 jsing 268: .name = "S",
269: .argname = "salt",
1.11 jmc 270: .desc = "Salt to use, specified as a hexadecimal string",
1.4 jsing 271: .type = OPTION_ARG,
1.27 tb 272: .opt.arg = &cfg.hsalt,
1.4 jsing 273: },
274: {
275: .name = "salt",
276: .desc = "Use a salt in the key derivation routines (default)",
277: .type = OPTION_VALUE,
1.27 tb 278: .opt.value = &cfg.nosalt,
1.4 jsing 279: .value = 0,
280: },
281: {
282: .name = "v",
283: .desc = "Verbose",
284: .type = OPTION_FLAG,
1.27 tb 285: .opt.flag = &cfg.verbose,
1.4 jsing 286: },
287: {
288: .name = NULL,
289: .type = OPTION_ARGV_FUNC,
290: .opt.argvfunc = enc_opt_cipher,
291: },
292: { NULL },
293: };
1.1 jsing 294:
295: static void
1.26 tb 296: skip_aead_and_xts(const OBJ_NAME *name, void *arg)
297: {
298: const EVP_CIPHER *cipher;
299:
300: if ((cipher = EVP_get_cipherbyname(name->name)) == NULL)
301: return;
302:
303: if ((EVP_CIPHER_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0)
304: return;
305: if (EVP_CIPHER_mode(cipher) == EVP_CIPH_XTS_MODE)
306: return;
307:
308: show_cipher(name, arg);
309: }
310:
311: static void
1.4 jsing 312: enc_usage(void)
313: {
1.18 inoguchi 314: int n = 0;
315:
1.4 jsing 316: fprintf(stderr, "usage: enc -ciphername [-AadePp] [-base64] "
317: "[-bufsize number] [-debug]\n"
1.16 naddy 318: " [-in file] [-iter iterations] [-iv IV] [-K key] "
319: "[-k password]\n"
1.4 jsing 320: " [-kfile file] [-md digest] [-none] [-nopad] [-nosalt]\n"
1.16 naddy 321: " [-out file] [-pass source] [-pbkdf2] [-S salt] [-salt]\n\n");
1.4 jsing 322: options_usage(enc_options);
323: fprintf(stderr, "\n");
324:
325: fprintf(stderr, "Valid ciphername values:\n\n");
1.26 tb 326: OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH, skip_aead_and_xts, &n);
1.4 jsing 327: fprintf(stderr, "\n");
1.1 jsing 328: }
329:
330: int
331: enc_main(int argc, char **argv)
332: {
333: static const char magic[] = "Salted__";
334: char mbuf[sizeof magic - 1];
1.4 jsing 335: char *strbuf = NULL, *pass = NULL;
336: unsigned char *buff = NULL;
337: int bsize = BSIZE;
1.1 jsing 338: int ret = 1, inl;
339: unsigned char key[EVP_MAX_KEY_LENGTH], iv[EVP_MAX_IV_LENGTH];
340: unsigned char salt[PKCS5_SALT_LEN];
341: EVP_CIPHER_CTX *ctx = NULL;
1.4 jsing 342: const EVP_MD *dgst = NULL;
343: BIO *in = NULL, *out = NULL, *b64 = NULL, *benc = NULL;
344: BIO *rbio = NULL, *wbio = NULL;
1.1 jsing 345: #define PROG_NAME_SIZE 39
346: char pname[PROG_NAME_SIZE + 1];
1.4 jsing 347: int i;
1.8 doug 348:
1.25 joshua 349: if (pledge("stdio cpath wpath rpath tty", NULL) == -1) {
350: perror("pledge");
351: exit(1);
1.8 doug 352: }
1.4 jsing 353:
1.27 tb 354: memset(&cfg, 0, sizeof(cfg));
355: cfg.enc = 1;
1.1 jsing 356:
357: /* first check the program name */
1.4 jsing 358: program_name(argv[0], pname, sizeof(pname));
359:
1.1 jsing 360: if (strcmp(pname, "base64") == 0)
1.27 tb 361: cfg.base64 = 1;
1.4 jsing 362:
1.27 tb 363: cfg.cipher = EVP_get_cipherbyname(pname);
1.4 jsing 364:
1.27 tb 365: if (!cfg.base64 && cfg.cipher == NULL &&
1.4 jsing 366: strcmp(pname, "enc") != 0)
1.1 jsing 367: {
368: BIO_printf(bio_err, "%s is an unknown cipher\n", pname);
1.4 jsing 369: goto end;
370: }
371:
372: if (options_parse(argc, argv, enc_options, NULL, NULL) != 0) {
373: enc_usage();
374: goto end;
1.1 jsing 375: }
1.4 jsing 376:
1.27 tb 377: if (cfg.keyfile != NULL) {
1.4 jsing 378: static char buf[128];
379: FILE *infile;
380:
1.27 tb 381: infile = fopen(cfg.keyfile, "r");
1.4 jsing 382: if (infile == NULL) {
383: BIO_printf(bio_err, "unable to read key from '%s'\n",
1.27 tb 384: cfg.keyfile);
1.4 jsing 385: goto end;
1.1 jsing 386: }
1.4 jsing 387: buf[0] = '\0';
388: if (!fgets(buf, sizeof buf, infile)) {
389: BIO_printf(bio_err, "unable to read key from '%s'\n",
1.27 tb 390: cfg.keyfile);
1.4 jsing 391: fclose(infile);
392: goto end;
1.1 jsing 393: }
1.4 jsing 394: fclose(infile);
395: i = strlen(buf);
396: if ((i > 0) && ((buf[i - 1] == '\n') || (buf[i - 1] == '\r')))
397: buf[--i] = '\0';
398: if ((i > 0) && ((buf[i - 1] == '\n') || (buf[i - 1] == '\r')))
399: buf[--i] = '\0';
400: if (i < 1) {
401: BIO_printf(bio_err, "zero length password\n");
1.1 jsing 402: goto end;
403: }
1.27 tb 404: cfg.keystr = buf;
1.26 tb 405: }
406:
1.27 tb 407: if (cfg.cipher != NULL &&
408: (EVP_CIPHER_flags(cfg.cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0) {
1.26 tb 409: BIO_printf(bio_err, "enc does not support AEAD ciphers\n");
410: goto end;
411: }
412:
1.27 tb 413: if (cfg.cipher != NULL &&
414: EVP_CIPHER_mode(cfg.cipher) == EVP_CIPH_XTS_MODE) {
1.26 tb 415: BIO_printf(bio_err, "enc does not support XTS mode\n");
416: goto end;
1.1 jsing 417: }
418:
1.27 tb 419: if (cfg.md != NULL &&
420: (dgst = EVP_get_digestbyname(cfg.md)) == NULL) {
1.4 jsing 421: BIO_printf(bio_err,
422: "%s is an unsupported message digest type\n",
1.27 tb 423: cfg.md);
1.1 jsing 424: goto end;
425: }
426: if (dgst == NULL) {
1.15 beck 427: dgst = EVP_sha256();
1.1 jsing 428: }
1.4 jsing 429:
1.27 tb 430: if (cfg.bufsize != NULL) {
431: char *p = cfg.bufsize;
1.1 jsing 432: unsigned long n;
433:
1.4 jsing 434: /* XXX - provide an OPTION_ARG_DISKUNIT. */
435: for (n = 0; *p != '\0'; p++) {
436: i = *p;
1.1 jsing 437: if ((i <= '9') && (i >= '0'))
438: n = n * 10 + i - '0';
439: else if (i == 'k') {
440: n *= 1024;
1.4 jsing 441: p++;
1.1 jsing 442: break;
443: }
444: }
1.4 jsing 445: if (*p != '\0') {
1.1 jsing 446: BIO_printf(bio_err, "invalid 'bufsize' specified.\n");
447: goto end;
448: }
1.4 jsing 449: /* It must be large enough for a base64 encoded line. */
1.27 tb 450: if (cfg.base64 && n < 80)
1.1 jsing 451: n = 80;
452:
1.4 jsing 453: bsize = (int)n;
1.27 tb 454: if (cfg.verbose)
1.1 jsing 455: BIO_printf(bio_err, "bufsize=%d\n", bsize);
456: }
457: strbuf = malloc(SIZE);
458: buff = malloc(EVP_ENCODE_LENGTH(bsize));
459: if ((buff == NULL) || (strbuf == NULL)) {
460: BIO_printf(bio_err, "malloc failure %ld\n", (long) EVP_ENCODE_LENGTH(bsize));
461: goto end;
462: }
463: in = BIO_new(BIO_s_file());
464: out = BIO_new(BIO_s_file());
465: if ((in == NULL) || (out == NULL)) {
466: ERR_print_errors(bio_err);
467: goto end;
468: }
1.27 tb 469: if (cfg.debug) {
1.1 jsing 470: BIO_set_callback(in, BIO_debug_callback);
471: BIO_set_callback(out, BIO_debug_callback);
472: BIO_set_callback_arg(in, (char *) bio_err);
473: BIO_set_callback_arg(out, (char *) bio_err);
474: }
1.27 tb 475: if (cfg.inf == NULL) {
476: if (cfg.bufsize != NULL)
1.1 jsing 477: setvbuf(stdin, (char *) NULL, _IONBF, 0);
478: BIO_set_fp(in, stdin, BIO_NOCLOSE);
479: } else {
1.27 tb 480: if (BIO_read_filename(in, cfg.inf) <= 0) {
481: perror(cfg.inf);
1.1 jsing 482: goto end;
483: }
484: }
485:
1.27 tb 486: if (!cfg.keystr && cfg.passarg) {
487: if (!app_passwd(bio_err, cfg.passarg, NULL,
1.4 jsing 488: &pass, NULL)) {
1.1 jsing 489: BIO_printf(bio_err, "Error getting password\n");
490: goto end;
491: }
1.27 tb 492: cfg.keystr = pass;
1.1 jsing 493: }
1.27 tb 494: if (cfg.keystr == NULL && cfg.cipher != NULL &&
495: cfg.hkey == NULL) {
1.1 jsing 496: for (;;) {
497: char buf[200];
1.2 doug 498: int retval;
1.1 jsing 499:
1.4 jsing 500: retval = snprintf(buf, sizeof buf,
501: "enter %s %s password:",
1.27 tb 502: OBJ_nid2ln(EVP_CIPHER_nid(cfg.cipher)),
503: cfg.enc ? "encryption" : "decryption");
1.2 doug 504: if ((size_t)retval >= sizeof buf) {
1.4 jsing 505: BIO_printf(bio_err,
506: "Password prompt too long\n");
1.1 jsing 507: goto end;
508: }
509: strbuf[0] = '\0';
1.4 jsing 510: i = EVP_read_pw_string((char *)strbuf, SIZE, buf,
1.27 tb 511: cfg.enc);
1.1 jsing 512: if (i == 0) {
513: if (strbuf[0] == '\0') {
514: ret = 1;
515: goto end;
516: }
1.27 tb 517: cfg.keystr = strbuf;
1.1 jsing 518: break;
519: }
520: if (i < 0) {
521: BIO_printf(bio_err, "bad password read\n");
522: goto end;
523: }
524: }
525: }
1.27 tb 526: if (cfg.outf == NULL) {
1.1 jsing 527: BIO_set_fp(out, stdout, BIO_NOCLOSE);
1.27 tb 528: if (cfg.bufsize != NULL)
1.4 jsing 529: setvbuf(stdout, (char *)NULL, _IONBF, 0);
1.1 jsing 530: } else {
1.27 tb 531: if (BIO_write_filename(out, cfg.outf) <= 0) {
532: perror(cfg.outf);
1.1 jsing 533: goto end;
534: }
535: }
536:
537: rbio = in;
538: wbio = out;
539:
1.27 tb 540: if (cfg.base64) {
1.1 jsing 541: if ((b64 = BIO_new(BIO_f_base64())) == NULL)
542: goto end;
1.27 tb 543: if (cfg.debug) {
1.1 jsing 544: BIO_set_callback(b64, BIO_debug_callback);
545: BIO_set_callback_arg(b64, (char *) bio_err);
546: }
1.27 tb 547: if (cfg.olb64)
1.1 jsing 548: BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
1.27 tb 549: if (cfg.enc)
1.1 jsing 550: wbio = BIO_push(b64, wbio);
551: else
552: rbio = BIO_push(b64, rbio);
553: }
1.27 tb 554: if (cfg.cipher != NULL) {
1.1 jsing 555: /*
1.4 jsing 556: * Note that keystr is NULL if a key was passed on the command
1.1 jsing 557: * line, so we get no salt in that case. Is this a bug?
558: */
1.27 tb 559: if (cfg.keystr != NULL) {
1.1 jsing 560: /*
561: * Salt handling: if encrypting generate a salt and
562: * write to output BIO. If decrypting read salt from
563: * input BIO.
564: */
565: unsigned char *sptr;
1.27 tb 566: if (cfg.nosalt)
1.1 jsing 567: sptr = NULL;
568: else {
1.27 tb 569: if (cfg.enc) {
570: if (cfg.hsalt) {
571: if (!set_hex(cfg.hsalt, salt, sizeof salt)) {
1.1 jsing 572: BIO_printf(bio_err,
573: "invalid hex salt value\n");
574: goto end;
575: }
1.3 jsing 576: } else
577: arc4random_buf(salt,
578: sizeof(salt));
1.1 jsing 579: /*
580: * If -P option then don't bother
581: * writing
582: */
1.27 tb 583: if ((cfg.printkey != 2)
1.1 jsing 584: && (BIO_write(wbio, magic,
585: sizeof magic - 1) != sizeof magic - 1
586: || BIO_write(wbio,
587: (char *) salt,
588: sizeof salt) != sizeof salt)) {
589: BIO_printf(bio_err, "error writing output file\n");
590: goto end;
591: }
592: } else if (BIO_read(rbio, mbuf, sizeof mbuf) != sizeof mbuf
593: || BIO_read(rbio,
594: (unsigned char *) salt,
595: sizeof salt) != sizeof salt) {
596: BIO_printf(bio_err, "error reading input file\n");
597: goto end;
598: } else if (memcmp(mbuf, magic, sizeof magic - 1)) {
599: BIO_printf(bio_err, "bad magic number\n");
600: goto end;
601: }
602: sptr = salt;
603: }
1.27 tb 604: if (cfg.pbkdf2 == 1 || cfg.iter > 0) {
1.15 beck 605: /*
606: * derive key and default iv
607: * concatenated into a temporary buffer
608: */
609: unsigned char tmpkeyiv[EVP_MAX_KEY_LENGTH + EVP_MAX_IV_LENGTH];
1.27 tb 610: int iklen = EVP_CIPHER_key_length(cfg.cipher);
611: int ivlen = EVP_CIPHER_iv_length(cfg.cipher);
1.15 beck 612: /* not needed if HASH_UPDATE() is fixed : */
613: int islen = (sptr != NULL ? sizeof(salt) : 0);
614:
1.27 tb 615: if (cfg.iter == 0)
616: cfg.iter = 10000;
1.15 beck 617:
1.27 tb 618: if (!PKCS5_PBKDF2_HMAC(cfg.keystr,
619: strlen(cfg.keystr), sptr, islen,
620: cfg.iter, dgst, iklen+ivlen, tmpkeyiv)) {
1.15 beck 621: BIO_printf(bio_err, "PKCS5_PBKDF2_HMAC failed\n");
622: goto end;
623: }
624: /* split and move data back to global buffer */
625: memcpy(key, tmpkeyiv, iklen);
1.22 bcook 626: memcpy(iv, tmpkeyiv + iklen, ivlen);
627: explicit_bzero(tmpkeyiv, sizeof tmpkeyiv);
1.15 beck 628: } else {
1.27 tb 629: EVP_BytesToKey(cfg.cipher, dgst, sptr,
630: (unsigned char *)cfg.keystr,
631: strlen(cfg.keystr), 1, key, iv);
1.15 beck 632: }
1.1 jsing 633:
634: /*
635: * zero the complete buffer or the string passed from
636: * the command line bug picked up by Larry J. Hughes
637: * Jr. <hughes@indiana.edu>
638: */
1.27 tb 639: if (cfg.keystr == strbuf)
640: explicit_bzero(cfg.keystr, SIZE);
1.1 jsing 641: else
1.27 tb 642: explicit_bzero(cfg.keystr,
643: strlen(cfg.keystr));
1.1 jsing 644: }
1.27 tb 645: if (cfg.hiv != NULL &&
646: !set_hex(cfg.hiv, iv, sizeof iv)) {
1.1 jsing 647: BIO_printf(bio_err, "invalid hex iv value\n");
648: goto end;
649: }
1.27 tb 650: if (cfg.hiv == NULL && cfg.keystr == NULL &&
651: EVP_CIPHER_iv_length(cfg.cipher) != 0) {
1.1 jsing 652: /*
653: * No IV was explicitly set and no IV was generated
654: * during EVP_BytesToKey. Hence the IV is undefined,
655: * making correct decryption impossible.
656: */
657: BIO_printf(bio_err, "iv undefined\n");
658: goto end;
659: }
1.27 tb 660: if (cfg.hkey != NULL &&
661: !set_hex(cfg.hkey, key, sizeof key)) {
1.1 jsing 662: BIO_printf(bio_err, "invalid hex key value\n");
663: goto end;
664: }
665: if ((benc = BIO_new(BIO_f_cipher())) == NULL)
666: goto end;
667:
668: /*
669: * Since we may be changing parameters work on the encryption
670: * context rather than calling BIO_set_cipher().
671: */
672:
673: BIO_get_cipher_ctx(benc, &ctx);
674:
1.27 tb 675: if (!EVP_CipherInit_ex(ctx, cfg.cipher, NULL, NULL,
676: NULL, cfg.enc)) {
1.1 jsing 677: BIO_printf(bio_err, "Error setting cipher %s\n",
1.27 tb 678: EVP_CIPHER_name(cfg.cipher));
1.1 jsing 679: ERR_print_errors(bio_err);
680: goto end;
681: }
1.27 tb 682: if (cfg.nopad)
1.1 jsing 683: EVP_CIPHER_CTX_set_padding(ctx, 0);
684:
1.4 jsing 685: if (!EVP_CipherInit_ex(ctx, NULL, NULL, key, iv,
1.27 tb 686: cfg.enc)) {
1.1 jsing 687: BIO_printf(bio_err, "Error setting cipher %s\n",
1.27 tb 688: EVP_CIPHER_name(cfg.cipher));
1.1 jsing 689: ERR_print_errors(bio_err);
690: goto end;
691: }
1.27 tb 692: if (cfg.debug) {
1.1 jsing 693: BIO_set_callback(benc, BIO_debug_callback);
694: BIO_set_callback_arg(benc, (char *) bio_err);
695: }
1.27 tb 696: if (cfg.printkey) {
1.24 tb 697: int key_len, iv_len;
698:
1.27 tb 699: if (!cfg.nosalt) {
1.1 jsing 700: printf("salt=");
701: for (i = 0; i < (int) sizeof(salt); i++)
702: printf("%02X", salt[i]);
703: printf("\n");
704: }
1.27 tb 705: key_len = EVP_CIPHER_key_length(cfg.cipher);
1.24 tb 706: if (key_len > 0) {
1.1 jsing 707: printf("key=");
1.24 tb 708: for (i = 0; i < key_len; i++)
1.1 jsing 709: printf("%02X", key[i]);
710: printf("\n");
711: }
1.27 tb 712: iv_len = EVP_CIPHER_iv_length(cfg.cipher);
1.24 tb 713: if (iv_len > 0) {
1.1 jsing 714: printf("iv =");
1.24 tb 715: for (i = 0; i < iv_len; i++)
1.1 jsing 716: printf("%02X", iv[i]);
717: printf("\n");
718: }
1.27 tb 719: if (cfg.printkey == 2) {
1.1 jsing 720: ret = 0;
721: goto end;
722: }
723: }
724: }
725: /* Only encrypt/decrypt as we write the file */
726: if (benc != NULL)
727: wbio = BIO_push(benc, wbio);
728:
729: for (;;) {
730: inl = BIO_read(rbio, (char *) buff, bsize);
731: if (inl <= 0)
732: break;
733: if (BIO_write(wbio, (char *) buff, inl) != inl) {
734: BIO_printf(bio_err, "error writing output file\n");
735: goto end;
736: }
737: }
738: if (!BIO_flush(wbio)) {
739: BIO_printf(bio_err, "bad decrypt\n");
740: goto end;
741: }
742: ret = 0;
1.27 tb 743: if (cfg.verbose) {
1.1 jsing 744: BIO_printf(bio_err, "bytes read :%8ld\n", BIO_number_read(in));
745: BIO_printf(bio_err, "bytes written:%8ld\n", BIO_number_written(out));
746: }
1.14 jsing 747: end:
1.1 jsing 748: ERR_print_errors(bio_err);
749: free(strbuf);
750: free(buff);
751: BIO_free(in);
1.13 jsing 752: BIO_free_all(out);
1.1 jsing 753: BIO_free(benc);
754: BIO_free(b64);
755: free(pass);
756:
757: return (ret);
758: }
759:
760: int
761: set_hex(char *in, unsigned char *out, int size)
762: {
763: int i, n;
764: unsigned char j;
765:
766: n = strlen(in);
767: if (n > (size * 2)) {
768: BIO_printf(bio_err, "hex string is too long\n");
769: return (0);
770: }
771: memset(out, 0, size);
772: for (i = 0; i < n; i++) {
773: j = (unsigned char) *in;
774: *(in++) = '\0';
775: if (j == 0)
776: break;
777: if ((j >= '0') && (j <= '9'))
778: j -= '0';
779: else if ((j >= 'A') && (j <= 'F'))
780: j = j - 'A' + 10;
781: else if ((j >= 'a') && (j <= 'f'))
782: j = j - 'a' + 10;
783: else {
784: BIO_printf(bio_err, "non-hex digit\n");
785: return (0);
786: }
787: if (i & 1)
788: out[i / 2] |= j;
789: else
790: out[i / 2] = (j << 4);
791: }
792: return (1);
793: }