| 1 | /*
|
|---|
| 2 | * Copyright 1995-2021 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 <stdlib.h>
|
|---|
| 12 | #include <string.h>
|
|---|
| 13 | #include <limits.h>
|
|---|
| 14 | #include "apps.h"
|
|---|
| 15 | #include "progs.h"
|
|---|
| 16 | #include <openssl/bio.h>
|
|---|
| 17 | #include <openssl/err.h>
|
|---|
| 18 | #include <openssl/evp.h>
|
|---|
| 19 | #include <openssl/objects.h>
|
|---|
| 20 | #include <openssl/x509.h>
|
|---|
| 21 | #include <openssl/rand.h>
|
|---|
| 22 | #include <openssl/pem.h>
|
|---|
| 23 | #ifndef OPENSSL_NO_COMP
|
|---|
| 24 | # include <openssl/comp.h>
|
|---|
| 25 | #endif
|
|---|
| 26 | #include <ctype.h>
|
|---|
| 27 |
|
|---|
| 28 | #undef SIZE
|
|---|
| 29 | #undef BSIZE
|
|---|
| 30 | #define SIZE (512)
|
|---|
| 31 | #define BSIZE (8*1024)
|
|---|
| 32 |
|
|---|
| 33 | static int set_hex(const char *in, unsigned char *out, int size);
|
|---|
| 34 | static void show_ciphers(const OBJ_NAME *name, void *bio_);
|
|---|
| 35 |
|
|---|
| 36 | struct doall_enc_ciphers {
|
|---|
| 37 | BIO *bio;
|
|---|
| 38 | int n;
|
|---|
| 39 | };
|
|---|
| 40 |
|
|---|
| 41 | typedef enum OPTION_choice {
|
|---|
| 42 | OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
|
|---|
| 43 | OPT_LIST,
|
|---|
| 44 | OPT_E, OPT_IN, OPT_OUT, OPT_PASS, OPT_ENGINE, OPT_D, OPT_P, OPT_V,
|
|---|
| 45 | OPT_NOPAD, OPT_SALT, OPT_NOSALT, OPT_DEBUG, OPT_UPPER_P, OPT_UPPER_A,
|
|---|
| 46 | OPT_A, OPT_Z, OPT_BUFSIZE, OPT_K, OPT_KFILE, OPT_UPPER_K, OPT_NONE,
|
|---|
| 47 | OPT_UPPER_S, OPT_IV, OPT_MD, OPT_ITER, OPT_PBKDF2, OPT_CIPHER,
|
|---|
| 48 | OPT_R_ENUM
|
|---|
| 49 | } OPTION_CHOICE;
|
|---|
| 50 |
|
|---|
| 51 | const OPTIONS enc_options[] = {
|
|---|
| 52 | {"help", OPT_HELP, '-', "Display this summary"},
|
|---|
| 53 | {"list", OPT_LIST, '-', "List ciphers"},
|
|---|
| 54 | {"ciphers", OPT_LIST, '-', "Alias for -list"},
|
|---|
| 55 | {"in", OPT_IN, '<', "Input file"},
|
|---|
| 56 | {"out", OPT_OUT, '>', "Output file"},
|
|---|
| 57 | {"pass", OPT_PASS, 's', "Passphrase source"},
|
|---|
| 58 | {"e", OPT_E, '-', "Encrypt"},
|
|---|
| 59 | {"d", OPT_D, '-', "Decrypt"},
|
|---|
| 60 | {"p", OPT_P, '-', "Print the iv/key"},
|
|---|
| 61 | {"P", OPT_UPPER_P, '-', "Print the iv/key and exit"},
|
|---|
| 62 | {"v", OPT_V, '-', "Verbose output"},
|
|---|
| 63 | {"nopad", OPT_NOPAD, '-', "Disable standard block padding"},
|
|---|
| 64 | {"salt", OPT_SALT, '-', "Use salt in the KDF (default)"},
|
|---|
| 65 | {"nosalt", OPT_NOSALT, '-', "Do not use salt in the KDF"},
|
|---|
| 66 | {"debug", OPT_DEBUG, '-', "Print debug info"},
|
|---|
| 67 | {"a", OPT_A, '-', "Base64 encode/decode, depending on encryption flag"},
|
|---|
| 68 | {"base64", OPT_A, '-', "Same as option -a"},
|
|---|
| 69 | {"A", OPT_UPPER_A, '-',
|
|---|
| 70 | "Used with -[base64|a] to specify base64 buffer as a single line"},
|
|---|
| 71 | {"bufsize", OPT_BUFSIZE, 's', "Buffer size"},
|
|---|
| 72 | {"k", OPT_K, 's', "Passphrase"},
|
|---|
| 73 | {"kfile", OPT_KFILE, '<', "Read passphrase from file"},
|
|---|
| 74 | {"K", OPT_UPPER_K, 's', "Raw key, in hex"},
|
|---|
| 75 | {"S", OPT_UPPER_S, 's', "Salt, in hex"},
|
|---|
| 76 | {"iv", OPT_IV, 's', "IV in hex"},
|
|---|
| 77 | {"md", OPT_MD, 's', "Use specified digest to create a key from the passphrase"},
|
|---|
| 78 | {"iter", OPT_ITER, 'p', "Specify the iteration count and force use of PBKDF2"},
|
|---|
| 79 | {"pbkdf2", OPT_PBKDF2, '-', "Use password-based key derivation function 2"},
|
|---|
| 80 | {"none", OPT_NONE, '-', "Don't encrypt"},
|
|---|
| 81 | {"", OPT_CIPHER, '-', "Any supported cipher"},
|
|---|
| 82 | OPT_R_OPTIONS,
|
|---|
| 83 | #ifdef ZLIB
|
|---|
| 84 | {"z", OPT_Z, '-', "Compress or decompress encrypted data using zlib"},
|
|---|
| 85 | #endif
|
|---|
| 86 | #ifndef OPENSSL_NO_ENGINE
|
|---|
| 87 | {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
|
|---|
| 88 | #endif
|
|---|
| 89 | {NULL}
|
|---|
| 90 | };
|
|---|
| 91 |
|
|---|
| 92 | int enc_main(int argc, char **argv)
|
|---|
| 93 | {
|
|---|
| 94 | static char buf[128];
|
|---|
| 95 | static const char magic[] = "Salted__";
|
|---|
| 96 | ENGINE *e = NULL;
|
|---|
| 97 | BIO *in = NULL, *out = NULL, *b64 = NULL, *benc = NULL, *rbio =
|
|---|
| 98 | NULL, *wbio = NULL;
|
|---|
| 99 | EVP_CIPHER_CTX *ctx = NULL;
|
|---|
| 100 | const EVP_CIPHER *cipher = NULL, *c;
|
|---|
| 101 | const EVP_MD *dgst = NULL;
|
|---|
| 102 | char *hkey = NULL, *hiv = NULL, *hsalt = NULL, *p;
|
|---|
| 103 | char *infile = NULL, *outfile = NULL, *prog;
|
|---|
| 104 | char *str = NULL, *passarg = NULL, *pass = NULL, *strbuf = NULL;
|
|---|
| 105 | char mbuf[sizeof(magic) - 1];
|
|---|
| 106 | OPTION_CHOICE o;
|
|---|
| 107 | int bsize = BSIZE, verbose = 0, debug = 0, olb64 = 0, nosalt = 0;
|
|---|
| 108 | int enc = 1, printkey = 0, i, k;
|
|---|
| 109 | int base64 = 0, informat = FORMAT_BINARY, outformat = FORMAT_BINARY;
|
|---|
| 110 | int ret = 1, inl, nopad = 0;
|
|---|
| 111 | unsigned char key[EVP_MAX_KEY_LENGTH], iv[EVP_MAX_IV_LENGTH];
|
|---|
| 112 | unsigned char *buff = NULL, salt[PKCS5_SALT_LEN];
|
|---|
| 113 | int pbkdf2 = 0;
|
|---|
| 114 | int iter = 0;
|
|---|
| 115 | long n;
|
|---|
| 116 | struct doall_enc_ciphers dec;
|
|---|
| 117 | #ifdef ZLIB
|
|---|
| 118 | int do_zlib = 0;
|
|---|
| 119 | BIO *bzl = NULL;
|
|---|
| 120 | #endif
|
|---|
| 121 |
|
|---|
| 122 | /* first check the program name */
|
|---|
| 123 | prog = opt_progname(argv[0]);
|
|---|
| 124 | if (strcmp(prog, "base64") == 0) {
|
|---|
| 125 | base64 = 1;
|
|---|
| 126 | #ifdef ZLIB
|
|---|
| 127 | } else if (strcmp(prog, "zlib") == 0) {
|
|---|
| 128 | do_zlib = 1;
|
|---|
| 129 | #endif
|
|---|
| 130 | } else {
|
|---|
| 131 | cipher = EVP_get_cipherbyname(prog);
|
|---|
| 132 | if (cipher == NULL && strcmp(prog, "enc") != 0) {
|
|---|
| 133 | BIO_printf(bio_err, "%s is not a known cipher\n", prog);
|
|---|
| 134 | goto end;
|
|---|
| 135 | }
|
|---|
| 136 | }
|
|---|
| 137 |
|
|---|
| 138 | prog = opt_init(argc, argv, enc_options);
|
|---|
| 139 | while ((o = opt_next()) != OPT_EOF) {
|
|---|
| 140 | switch (o) {
|
|---|
| 141 | case OPT_EOF:
|
|---|
| 142 | case OPT_ERR:
|
|---|
| 143 | opthelp:
|
|---|
| 144 | BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
|
|---|
| 145 | goto end;
|
|---|
| 146 | case OPT_HELP:
|
|---|
| 147 | opt_help(enc_options);
|
|---|
| 148 | ret = 0;
|
|---|
| 149 | goto end;
|
|---|
| 150 | case OPT_LIST:
|
|---|
| 151 | BIO_printf(bio_out, "Supported ciphers:\n");
|
|---|
| 152 | dec.bio = bio_out;
|
|---|
| 153 | dec.n = 0;
|
|---|
| 154 | OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH,
|
|---|
| 155 | show_ciphers, &dec);
|
|---|
| 156 | BIO_printf(bio_out, "\n");
|
|---|
| 157 | ret = 0;
|
|---|
| 158 | goto end;
|
|---|
| 159 | case OPT_E:
|
|---|
| 160 | enc = 1;
|
|---|
| 161 | break;
|
|---|
| 162 | case OPT_IN:
|
|---|
| 163 | infile = opt_arg();
|
|---|
| 164 | break;
|
|---|
| 165 | case OPT_OUT:
|
|---|
| 166 | outfile = opt_arg();
|
|---|
| 167 | break;
|
|---|
| 168 | case OPT_PASS:
|
|---|
| 169 | passarg = opt_arg();
|
|---|
| 170 | break;
|
|---|
| 171 | case OPT_ENGINE:
|
|---|
| 172 | e = setup_engine(opt_arg(), 0);
|
|---|
| 173 | break;
|
|---|
| 174 | case OPT_D:
|
|---|
| 175 | enc = 0;
|
|---|
| 176 | break;
|
|---|
| 177 | case OPT_P:
|
|---|
| 178 | printkey = 1;
|
|---|
| 179 | break;
|
|---|
| 180 | case OPT_V:
|
|---|
| 181 | verbose = 1;
|
|---|
| 182 | break;
|
|---|
| 183 | case OPT_NOPAD:
|
|---|
| 184 | nopad = 1;
|
|---|
| 185 | break;
|
|---|
| 186 | case OPT_SALT:
|
|---|
| 187 | nosalt = 0;
|
|---|
| 188 | break;
|
|---|
| 189 | case OPT_NOSALT:
|
|---|
| 190 | nosalt = 1;
|
|---|
| 191 | break;
|
|---|
| 192 | case OPT_DEBUG:
|
|---|
| 193 | debug = 1;
|
|---|
| 194 | break;
|
|---|
| 195 | case OPT_UPPER_P:
|
|---|
| 196 | printkey = 2;
|
|---|
| 197 | break;
|
|---|
| 198 | case OPT_UPPER_A:
|
|---|
| 199 | olb64 = 1;
|
|---|
| 200 | break;
|
|---|
| 201 | case OPT_A:
|
|---|
| 202 | base64 = 1;
|
|---|
| 203 | break;
|
|---|
| 204 | case OPT_Z:
|
|---|
| 205 | #ifdef ZLIB
|
|---|
| 206 | do_zlib = 1;
|
|---|
| 207 | #endif
|
|---|
| 208 | break;
|
|---|
| 209 | case OPT_BUFSIZE:
|
|---|
| 210 | p = opt_arg();
|
|---|
| 211 | i = (int)strlen(p) - 1;
|
|---|
| 212 | k = i >= 1 && p[i] == 'k';
|
|---|
| 213 | if (k)
|
|---|
| 214 | p[i] = '\0';
|
|---|
| 215 | if (!opt_long(opt_arg(), &n)
|
|---|
| 216 | || n < 0 || (k && n >= LONG_MAX / 1024))
|
|---|
| 217 | goto opthelp;
|
|---|
| 218 | if (k)
|
|---|
| 219 | n *= 1024;
|
|---|
| 220 | bsize = (int)n;
|
|---|
| 221 | break;
|
|---|
| 222 | case OPT_K:
|
|---|
| 223 | str = opt_arg();
|
|---|
| 224 | break;
|
|---|
| 225 | case OPT_KFILE:
|
|---|
| 226 | in = bio_open_default(opt_arg(), 'r', FORMAT_TEXT);
|
|---|
| 227 | if (in == NULL)
|
|---|
| 228 | goto opthelp;
|
|---|
| 229 | i = BIO_gets(in, buf, sizeof(buf));
|
|---|
| 230 | BIO_free(in);
|
|---|
| 231 | in = NULL;
|
|---|
| 232 | if (i <= 0) {
|
|---|
| 233 | BIO_printf(bio_err,
|
|---|
| 234 | "%s Can't read key from %s\n", prog, opt_arg());
|
|---|
| 235 | goto opthelp;
|
|---|
| 236 | }
|
|---|
| 237 | while (--i > 0 && (buf[i] == '\r' || buf[i] == '\n'))
|
|---|
| 238 | buf[i] = '\0';
|
|---|
| 239 | if (i <= 0) {
|
|---|
| 240 | BIO_printf(bio_err, "%s: zero length password\n", prog);
|
|---|
| 241 | goto opthelp;
|
|---|
| 242 | }
|
|---|
| 243 | str = buf;
|
|---|
| 244 | break;
|
|---|
| 245 | case OPT_UPPER_K:
|
|---|
| 246 | hkey = opt_arg();
|
|---|
| 247 | break;
|
|---|
| 248 | case OPT_UPPER_S:
|
|---|
| 249 | hsalt = opt_arg();
|
|---|
| 250 | break;
|
|---|
| 251 | case OPT_IV:
|
|---|
| 252 | hiv = opt_arg();
|
|---|
| 253 | break;
|
|---|
| 254 | case OPT_MD:
|
|---|
| 255 | if (!opt_md(opt_arg(), &dgst))
|
|---|
| 256 | goto opthelp;
|
|---|
| 257 | break;
|
|---|
| 258 | case OPT_CIPHER:
|
|---|
| 259 | if (!opt_cipher(opt_unknown(), &c))
|
|---|
| 260 | goto opthelp;
|
|---|
| 261 | cipher = c;
|
|---|
| 262 | break;
|
|---|
| 263 | case OPT_ITER:
|
|---|
| 264 | if (!opt_int(opt_arg(), &iter))
|
|---|
| 265 | goto opthelp;
|
|---|
| 266 | pbkdf2 = 1;
|
|---|
| 267 | break;
|
|---|
| 268 | case OPT_PBKDF2:
|
|---|
| 269 | pbkdf2 = 1;
|
|---|
| 270 | if (iter == 0) /* do not overwrite a chosen value */
|
|---|
| 271 | iter = 10000;
|
|---|
| 272 | break;
|
|---|
| 273 | case OPT_NONE:
|
|---|
| 274 | cipher = NULL;
|
|---|
| 275 | break;
|
|---|
| 276 | case OPT_R_CASES:
|
|---|
| 277 | if (!opt_rand(o))
|
|---|
| 278 | goto end;
|
|---|
| 279 | break;
|
|---|
| 280 | }
|
|---|
| 281 | }
|
|---|
| 282 | if (opt_num_rest() != 0) {
|
|---|
| 283 | BIO_printf(bio_err, "Extra arguments given.\n");
|
|---|
| 284 | goto opthelp;
|
|---|
| 285 | }
|
|---|
| 286 |
|
|---|
| 287 | if (cipher && EVP_CIPHER_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) {
|
|---|
| 288 | BIO_printf(bio_err, "%s: AEAD ciphers not supported\n", prog);
|
|---|
| 289 | goto end;
|
|---|
| 290 | }
|
|---|
| 291 |
|
|---|
| 292 | if (cipher && (EVP_CIPHER_mode(cipher) == EVP_CIPH_XTS_MODE)) {
|
|---|
| 293 | BIO_printf(bio_err, "%s XTS ciphers not supported\n", prog);
|
|---|
| 294 | goto end;
|
|---|
| 295 | }
|
|---|
| 296 |
|
|---|
| 297 | if (dgst == NULL)
|
|---|
| 298 | dgst = EVP_sha256();
|
|---|
| 299 |
|
|---|
| 300 | if (iter == 0)
|
|---|
| 301 | iter = 1;
|
|---|
| 302 |
|
|---|
| 303 | /* It must be large enough for a base64 encoded line */
|
|---|
| 304 | if (base64 && bsize < 80)
|
|---|
| 305 | bsize = 80;
|
|---|
| 306 | if (verbose)
|
|---|
| 307 | BIO_printf(bio_err, "bufsize=%d\n", bsize);
|
|---|
| 308 |
|
|---|
| 309 | #ifdef ZLIB
|
|---|
| 310 | if (!do_zlib)
|
|---|
| 311 | #endif
|
|---|
| 312 | if (base64) {
|
|---|
| 313 | if (enc)
|
|---|
| 314 | outformat = FORMAT_BASE64;
|
|---|
| 315 | else
|
|---|
| 316 | informat = FORMAT_BASE64;
|
|---|
| 317 | }
|
|---|
| 318 |
|
|---|
| 319 | strbuf = app_malloc(SIZE, "strbuf");
|
|---|
| 320 | buff = app_malloc(EVP_ENCODE_LENGTH(bsize), "evp buffer");
|
|---|
| 321 |
|
|---|
| 322 | if (infile == NULL) {
|
|---|
| 323 | in = dup_bio_in(informat);
|
|---|
| 324 | } else {
|
|---|
| 325 | in = bio_open_default(infile, 'r', informat);
|
|---|
| 326 | }
|
|---|
| 327 | if (in == NULL)
|
|---|
| 328 | goto end;
|
|---|
| 329 |
|
|---|
| 330 | if (str == NULL && passarg != NULL) {
|
|---|
| 331 | if (!app_passwd(passarg, NULL, &pass, NULL)) {
|
|---|
| 332 | BIO_printf(bio_err, "Error getting password\n");
|
|---|
| 333 | goto end;
|
|---|
| 334 | }
|
|---|
| 335 | str = pass;
|
|---|
| 336 | }
|
|---|
| 337 |
|
|---|
| 338 | if ((str == NULL) && (cipher != NULL) && (hkey == NULL)) {
|
|---|
| 339 | if (1) {
|
|---|
| 340 | #ifndef OPENSSL_NO_UI_CONSOLE
|
|---|
| 341 | for (;;) {
|
|---|
| 342 | char prompt[200];
|
|---|
| 343 |
|
|---|
| 344 | BIO_snprintf(prompt, sizeof(prompt), "enter %s %s password:",
|
|---|
| 345 | OBJ_nid2ln(EVP_CIPHER_nid(cipher)),
|
|---|
| 346 | (enc) ? "encryption" : "decryption");
|
|---|
| 347 | strbuf[0] = '\0';
|
|---|
| 348 | i = EVP_read_pw_string((char *)strbuf, SIZE, prompt, enc);
|
|---|
| 349 | if (i == 0) {
|
|---|
| 350 | if (strbuf[0] == '\0') {
|
|---|
| 351 | ret = 1;
|
|---|
| 352 | goto end;
|
|---|
| 353 | }
|
|---|
| 354 | str = strbuf;
|
|---|
| 355 | break;
|
|---|
| 356 | }
|
|---|
| 357 | if (i < 0) {
|
|---|
| 358 | BIO_printf(bio_err, "bad password read\n");
|
|---|
| 359 | goto end;
|
|---|
| 360 | }
|
|---|
| 361 | }
|
|---|
| 362 | } else {
|
|---|
| 363 | #endif
|
|---|
| 364 | BIO_printf(bio_err, "password required\n");
|
|---|
| 365 | goto end;
|
|---|
| 366 | }
|
|---|
| 367 | }
|
|---|
| 368 |
|
|---|
| 369 | out = bio_open_default(outfile, 'w', outformat);
|
|---|
| 370 | if (out == NULL)
|
|---|
| 371 | goto end;
|
|---|
| 372 |
|
|---|
| 373 | if (debug) {
|
|---|
| 374 | BIO_set_callback(in, BIO_debug_callback);
|
|---|
| 375 | BIO_set_callback(out, BIO_debug_callback);
|
|---|
| 376 | BIO_set_callback_arg(in, (char *)bio_err);
|
|---|
| 377 | BIO_set_callback_arg(out, (char *)bio_err);
|
|---|
| 378 | }
|
|---|
| 379 |
|
|---|
| 380 | rbio = in;
|
|---|
| 381 | wbio = out;
|
|---|
| 382 |
|
|---|
| 383 | #ifdef ZLIB
|
|---|
| 384 | if (do_zlib) {
|
|---|
| 385 | if ((bzl = BIO_new(BIO_f_zlib())) == NULL)
|
|---|
| 386 | goto end;
|
|---|
| 387 | if (debug) {
|
|---|
| 388 | BIO_set_callback(bzl, BIO_debug_callback);
|
|---|
| 389 | BIO_set_callback_arg(bzl, (char *)bio_err);
|
|---|
| 390 | }
|
|---|
| 391 | if (enc)
|
|---|
| 392 | wbio = BIO_push(bzl, wbio);
|
|---|
| 393 | else
|
|---|
| 394 | rbio = BIO_push(bzl, rbio);
|
|---|
| 395 | }
|
|---|
| 396 | #endif
|
|---|
| 397 |
|
|---|
| 398 | if (base64) {
|
|---|
| 399 | if ((b64 = BIO_new(BIO_f_base64())) == NULL)
|
|---|
| 400 | goto end;
|
|---|
| 401 | if (debug) {
|
|---|
| 402 | BIO_set_callback(b64, BIO_debug_callback);
|
|---|
| 403 | BIO_set_callback_arg(b64, (char *)bio_err);
|
|---|
| 404 | }
|
|---|
| 405 | if (olb64)
|
|---|
| 406 | BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
|
|---|
| 407 | if (enc)
|
|---|
| 408 | wbio = BIO_push(b64, wbio);
|
|---|
| 409 | else
|
|---|
| 410 | rbio = BIO_push(b64, rbio);
|
|---|
| 411 | }
|
|---|
| 412 |
|
|---|
| 413 | if (cipher != NULL) {
|
|---|
| 414 | /*
|
|---|
| 415 | * Note that str is NULL if a key was passed on the command line, so
|
|---|
| 416 | * we get no salt in that case. Is this a bug?
|
|---|
| 417 | */
|
|---|
| 418 | if (str != NULL) {
|
|---|
| 419 | /*
|
|---|
| 420 | * Salt handling: if encrypting generate a salt and write to
|
|---|
| 421 | * output BIO. If decrypting read salt from input BIO.
|
|---|
| 422 | */
|
|---|
| 423 | unsigned char *sptr;
|
|---|
| 424 | size_t str_len = strlen(str);
|
|---|
| 425 |
|
|---|
| 426 | if (nosalt) {
|
|---|
| 427 | sptr = NULL;
|
|---|
| 428 | } else {
|
|---|
| 429 | if (enc) {
|
|---|
| 430 | if (hsalt) {
|
|---|
| 431 | if (!set_hex(hsalt, salt, sizeof(salt))) {
|
|---|
| 432 | BIO_printf(bio_err, "invalid hex salt value\n");
|
|---|
| 433 | goto end;
|
|---|
| 434 | }
|
|---|
| 435 | } else if (RAND_bytes(salt, sizeof(salt)) <= 0) {
|
|---|
| 436 | goto end;
|
|---|
| 437 | }
|
|---|
| 438 | /*
|
|---|
| 439 | * If -P option then don't bother writing
|
|---|
| 440 | */
|
|---|
| 441 | if ((printkey != 2)
|
|---|
| 442 | && (BIO_write(wbio, magic,
|
|---|
| 443 | sizeof(magic) - 1) != sizeof(magic) - 1
|
|---|
| 444 | || BIO_write(wbio,
|
|---|
| 445 | (char *)salt,
|
|---|
| 446 | sizeof(salt)) != sizeof(salt))) {
|
|---|
| 447 | BIO_printf(bio_err, "error writing output file\n");
|
|---|
| 448 | goto end;
|
|---|
| 449 | }
|
|---|
| 450 | } else if (BIO_read(rbio, mbuf, sizeof(mbuf)) != sizeof(mbuf)
|
|---|
| 451 | || BIO_read(rbio,
|
|---|
| 452 | (unsigned char *)salt,
|
|---|
| 453 | sizeof(salt)) != sizeof(salt)) {
|
|---|
| 454 | BIO_printf(bio_err, "error reading input file\n");
|
|---|
| 455 | goto end;
|
|---|
| 456 | } else if (memcmp(mbuf, magic, sizeof(magic) - 1)) {
|
|---|
| 457 | BIO_printf(bio_err, "bad magic number\n");
|
|---|
| 458 | goto end;
|
|---|
| 459 | }
|
|---|
| 460 | sptr = salt;
|
|---|
| 461 | }
|
|---|
| 462 |
|
|---|
| 463 | if (pbkdf2 == 1) {
|
|---|
| 464 | /*
|
|---|
| 465 | * derive key and default iv
|
|---|
| 466 | * concatenated into a temporary buffer
|
|---|
| 467 | */
|
|---|
| 468 | unsigned char tmpkeyiv[EVP_MAX_KEY_LENGTH + EVP_MAX_IV_LENGTH];
|
|---|
| 469 | int iklen = EVP_CIPHER_key_length(cipher);
|
|---|
| 470 | int ivlen = EVP_CIPHER_iv_length(cipher);
|
|---|
| 471 | /* not needed if HASH_UPDATE() is fixed : */
|
|---|
| 472 | int islen = (sptr != NULL ? sizeof(salt) : 0);
|
|---|
| 473 | if (!PKCS5_PBKDF2_HMAC(str, str_len, sptr, islen,
|
|---|
| 474 | iter, dgst, iklen+ivlen, tmpkeyiv)) {
|
|---|
| 475 | BIO_printf(bio_err, "PKCS5_PBKDF2_HMAC failed\n");
|
|---|
| 476 | goto end;
|
|---|
| 477 | }
|
|---|
| 478 | /* split and move data back to global buffer */
|
|---|
| 479 | memcpy(key, tmpkeyiv, iklen);
|
|---|
| 480 | memcpy(iv, tmpkeyiv+iklen, ivlen);
|
|---|
| 481 | } else {
|
|---|
| 482 | BIO_printf(bio_err, "*** WARNING : "
|
|---|
| 483 | "deprecated key derivation used.\n"
|
|---|
| 484 | "Using -iter or -pbkdf2 would be better.\n");
|
|---|
| 485 | if (!EVP_BytesToKey(cipher, dgst, sptr,
|
|---|
| 486 | (unsigned char *)str, str_len,
|
|---|
| 487 | 1, key, iv)) {
|
|---|
| 488 | BIO_printf(bio_err, "EVP_BytesToKey failed\n");
|
|---|
| 489 | goto end;
|
|---|
| 490 | }
|
|---|
| 491 | }
|
|---|
| 492 | /*
|
|---|
| 493 | * zero the complete buffer or the string passed from the command
|
|---|
| 494 | * line.
|
|---|
| 495 | */
|
|---|
| 496 | if (str == strbuf)
|
|---|
| 497 | OPENSSL_cleanse(str, SIZE);
|
|---|
| 498 | else
|
|---|
| 499 | OPENSSL_cleanse(str, str_len);
|
|---|
| 500 | }
|
|---|
| 501 | if (hiv != NULL) {
|
|---|
| 502 | int siz = EVP_CIPHER_iv_length(cipher);
|
|---|
| 503 | if (siz == 0) {
|
|---|
| 504 | BIO_printf(bio_err, "warning: iv not used by this cipher\n");
|
|---|
| 505 | } else if (!set_hex(hiv, iv, siz)) {
|
|---|
| 506 | BIO_printf(bio_err, "invalid hex iv value\n");
|
|---|
| 507 | goto end;
|
|---|
| 508 | }
|
|---|
| 509 | }
|
|---|
| 510 | if ((hiv == NULL) && (str == NULL)
|
|---|
| 511 | && EVP_CIPHER_iv_length(cipher) != 0) {
|
|---|
| 512 | /*
|
|---|
| 513 | * No IV was explicitly set and no IV was generated.
|
|---|
| 514 | * Hence the IV is undefined, making correct decryption impossible.
|
|---|
| 515 | */
|
|---|
| 516 | BIO_printf(bio_err, "iv undefined\n");
|
|---|
| 517 | goto end;
|
|---|
| 518 | }
|
|---|
| 519 | if (hkey != NULL) {
|
|---|
| 520 | if (!set_hex(hkey, key, EVP_CIPHER_key_length(cipher))) {
|
|---|
| 521 | BIO_printf(bio_err, "invalid hex key value\n");
|
|---|
| 522 | goto end;
|
|---|
| 523 | }
|
|---|
| 524 | /* wiping secret data as we no longer need it */
|
|---|
| 525 | OPENSSL_cleanse(hkey, strlen(hkey));
|
|---|
| 526 | }
|
|---|
| 527 |
|
|---|
| 528 | if ((benc = BIO_new(BIO_f_cipher())) == NULL)
|
|---|
| 529 | goto end;
|
|---|
| 530 |
|
|---|
| 531 | /*
|
|---|
| 532 | * Since we may be changing parameters work on the encryption context
|
|---|
| 533 | * rather than calling BIO_set_cipher().
|
|---|
| 534 | */
|
|---|
| 535 |
|
|---|
| 536 | BIO_get_cipher_ctx(benc, &ctx);
|
|---|
| 537 |
|
|---|
| 538 | if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc)) {
|
|---|
| 539 | BIO_printf(bio_err, "Error setting cipher %s\n",
|
|---|
| 540 | EVP_CIPHER_name(cipher));
|
|---|
| 541 | ERR_print_errors(bio_err);
|
|---|
| 542 | goto end;
|
|---|
| 543 | }
|
|---|
| 544 |
|
|---|
| 545 | if (nopad)
|
|---|
| 546 | EVP_CIPHER_CTX_set_padding(ctx, 0);
|
|---|
| 547 |
|
|---|
| 548 | if (!EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc)) {
|
|---|
| 549 | BIO_printf(bio_err, "Error setting cipher %s\n",
|
|---|
| 550 | EVP_CIPHER_name(cipher));
|
|---|
| 551 | ERR_print_errors(bio_err);
|
|---|
| 552 | goto end;
|
|---|
| 553 | }
|
|---|
| 554 |
|
|---|
| 555 | if (debug) {
|
|---|
| 556 | BIO_set_callback(benc, BIO_debug_callback);
|
|---|
| 557 | BIO_set_callback_arg(benc, (char *)bio_err);
|
|---|
| 558 | }
|
|---|
| 559 |
|
|---|
| 560 | if (printkey) {
|
|---|
| 561 | if (!nosalt) {
|
|---|
| 562 | printf("salt=");
|
|---|
| 563 | for (i = 0; i < (int)sizeof(salt); i++)
|
|---|
| 564 | printf("%02X", salt[i]);
|
|---|
| 565 | printf("\n");
|
|---|
| 566 | }
|
|---|
| 567 | if (EVP_CIPHER_key_length(cipher) > 0) {
|
|---|
| 568 | printf("key=");
|
|---|
| 569 | for (i = 0; i < EVP_CIPHER_key_length(cipher); i++)
|
|---|
| 570 | printf("%02X", key[i]);
|
|---|
| 571 | printf("\n");
|
|---|
| 572 | }
|
|---|
| 573 | if (EVP_CIPHER_iv_length(cipher) > 0) {
|
|---|
| 574 | printf("iv =");
|
|---|
| 575 | for (i = 0; i < EVP_CIPHER_iv_length(cipher); i++)
|
|---|
| 576 | printf("%02X", iv[i]);
|
|---|
| 577 | printf("\n");
|
|---|
| 578 | }
|
|---|
| 579 | if (printkey == 2) {
|
|---|
| 580 | ret = 0;
|
|---|
| 581 | goto end;
|
|---|
| 582 | }
|
|---|
| 583 | }
|
|---|
| 584 | }
|
|---|
| 585 |
|
|---|
| 586 | /* Only encrypt/decrypt as we write the file */
|
|---|
| 587 | if (benc != NULL)
|
|---|
| 588 | wbio = BIO_push(benc, wbio);
|
|---|
| 589 |
|
|---|
| 590 | while (BIO_pending(rbio) || !BIO_eof(rbio)) {
|
|---|
| 591 | inl = BIO_read(rbio, (char *)buff, bsize);
|
|---|
| 592 | if (inl <= 0)
|
|---|
| 593 | break;
|
|---|
| 594 | if (BIO_write(wbio, (char *)buff, inl) != inl) {
|
|---|
| 595 | BIO_printf(bio_err, "error writing output file\n");
|
|---|
| 596 | goto end;
|
|---|
| 597 | }
|
|---|
| 598 | }
|
|---|
| 599 | if (!BIO_flush(wbio)) {
|
|---|
| 600 | BIO_printf(bio_err, "bad decrypt\n");
|
|---|
| 601 | goto end;
|
|---|
| 602 | }
|
|---|
| 603 |
|
|---|
| 604 | ret = 0;
|
|---|
| 605 | if (verbose) {
|
|---|
| 606 | BIO_printf(bio_err, "bytes read : %8ju\n", BIO_number_read(in));
|
|---|
| 607 | BIO_printf(bio_err, "bytes written: %8ju\n", BIO_number_written(out));
|
|---|
| 608 | }
|
|---|
| 609 | end:
|
|---|
| 610 | ERR_print_errors(bio_err);
|
|---|
| 611 | OPENSSL_free(strbuf);
|
|---|
| 612 | OPENSSL_free(buff);
|
|---|
| 613 | BIO_free(in);
|
|---|
| 614 | BIO_free_all(out);
|
|---|
| 615 | BIO_free(benc);
|
|---|
| 616 | BIO_free(b64);
|
|---|
| 617 | #ifdef ZLIB
|
|---|
| 618 | BIO_free(bzl);
|
|---|
| 619 | #endif
|
|---|
| 620 | release_engine(e);
|
|---|
| 621 | OPENSSL_free(pass);
|
|---|
| 622 | return ret;
|
|---|
| 623 | }
|
|---|
| 624 |
|
|---|
| 625 | static void show_ciphers(const OBJ_NAME *name, void *arg)
|
|---|
| 626 | {
|
|---|
| 627 | struct doall_enc_ciphers *dec = (struct doall_enc_ciphers *)arg;
|
|---|
| 628 | const EVP_CIPHER *cipher;
|
|---|
| 629 |
|
|---|
| 630 | if (!islower((unsigned char)*name->name))
|
|---|
| 631 | return;
|
|---|
| 632 |
|
|---|
| 633 | /* Filter out ciphers that we cannot use */
|
|---|
| 634 | cipher = EVP_get_cipherbyname(name->name);
|
|---|
| 635 | if (cipher == NULL ||
|
|---|
| 636 | (EVP_CIPHER_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0 ||
|
|---|
| 637 | EVP_CIPHER_mode(cipher) == EVP_CIPH_XTS_MODE)
|
|---|
| 638 | return;
|
|---|
| 639 |
|
|---|
| 640 | BIO_printf(dec->bio, "-%-25s", name->name);
|
|---|
| 641 | if (++dec->n == 3) {
|
|---|
| 642 | BIO_printf(dec->bio, "\n");
|
|---|
| 643 | dec->n = 0;
|
|---|
| 644 | } else
|
|---|
| 645 | BIO_printf(dec->bio, " ");
|
|---|
| 646 | }
|
|---|
| 647 |
|
|---|
| 648 | static int set_hex(const char *in, unsigned char *out, int size)
|
|---|
| 649 | {
|
|---|
| 650 | int i, n;
|
|---|
| 651 | unsigned char j;
|
|---|
| 652 |
|
|---|
| 653 | i = size * 2;
|
|---|
| 654 | n = strlen(in);
|
|---|
| 655 | if (n > i) {
|
|---|
| 656 | BIO_printf(bio_err, "hex string is too long, ignoring excess\n");
|
|---|
| 657 | n = i; /* ignore exceeding part */
|
|---|
| 658 | } else if (n < i) {
|
|---|
| 659 | BIO_printf(bio_err, "hex string is too short, padding with zero bytes to length\n");
|
|---|
| 660 | }
|
|---|
| 661 |
|
|---|
| 662 | memset(out, 0, size);
|
|---|
| 663 | for (i = 0; i < n; i++) {
|
|---|
| 664 | j = (unsigned char)*in++;
|
|---|
| 665 | if (!isxdigit(j)) {
|
|---|
| 666 | BIO_printf(bio_err, "non-hex digit\n");
|
|---|
| 667 | return 0;
|
|---|
| 668 | }
|
|---|
| 669 | j = (unsigned char)OPENSSL_hexchar2int(j);
|
|---|
| 670 | if (i & 1)
|
|---|
| 671 | out[i / 2] |= j;
|
|---|
| 672 | else
|
|---|
| 673 | out[i / 2] = (j << 4);
|
|---|
| 674 | }
|
|---|
| 675 | return 1;
|
|---|
| 676 | }
|
|---|
