OPT_E, OPT_IN, OPT_OUT, OPT_PASS, OPT_ENGINE, OPT_D, OPT_P, OPT_V,
OPT_NOPAD, OPT_SALT, OPT_NOSALT, OPT_DEBUG, OPT_UPPER_P, OPT_UPPER_A,
OPT_A, OPT_Z, OPT_BUFSIZE, OPT_K, OPT_KFILE, OPT_UPPER_K, OPT_NONE,
- OPT_UPPER_S, OPT_IV, OPT_MD, OPT_NON_FIPS_ALLOW, OPT_CIPHER
+ OPT_UPPER_S, OPT_IV, OPT_MD, OPT_CIPHER
} OPTION_CHOICE;
OPTIONS enc_options[] = {
{"in", OPT_IN, '<', "Input file"},
{"out", OPT_OUT, '>', "Output file"},
{"pass", OPT_PASS, 's', "Passphrase source"},
-#ifndef OPENSSL_NO_ENGINE
- {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
-#endif
{"e", OPT_E, '-', "Encrypt"},
{"d", OPT_D, '-', "Decrypt"},
{"p", OPT_P, '-', "Print the iv/key"},
{"A", OPT_UPPER_A, '-'},
{"a", OPT_A, '-', "base64 encode/decode, depending on encryption flag"},
{"base64", OPT_A, '-', "Base64 output as a single line"},
-#ifdef ZLIB
- {"z", OPT_Z, '-', "Use zlib as the 'encryption'"},
-#endif
{"bufsize", OPT_BUFSIZE, 's', "Buffer size"},
{"k", OPT_K, 's', "Passphrase"},
{"kfile", OPT_KFILE, '<', "Fead passphrase from file"},
- {"K", OPT_UPPER_K, '-', "Same as -iv"},
+ {"K", OPT_UPPER_K, 's', "Raw key, in hex"},
{"S", OPT_UPPER_S, 's', "Salt, in hex"},
{"iv", OPT_IV, 's', "IV in hex"},
{"md", OPT_MD, 's', "Use specified digest to create key from passphrase"},
- {"non-fips-allow", OPT_NON_FIPS_ALLOW, '-'},
{"none", OPT_NONE, '-', "Don't encrypt"},
{"", OPT_CIPHER, '-', "Any supported cipher"},
+#ifdef ZLIB
+ {"z", OPT_Z, '-', "Use zlib as the 'encryption'"},
+#endif
+#ifndef OPENSSL_NO_ENGINE
+ {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
+#endif
{NULL}
};
char mbuf[sizeof magic - 1];
OPTION_CHOICE o;
int bsize = BSIZE, verbose = 0, debug = 0, olb64 = 0, nosalt = 0;
- int enc = 1, printkey = 0, i, k, base64 = 0;
- int ret = 1, inl, nopad = 0, non_fips_allow = 0;
+ int enc = 1, printkey = 0, i, k;
+ int base64 = 0, informat = FORMAT_BINARY, outformat = FORMAT_BINARY;
+ int ret = 1, inl, nopad = 0;
unsigned char key[EVP_MAX_KEY_LENGTH], iv[EVP_MAX_IV_LENGTH];
unsigned char *buff = NULL, salt[PKCS5_SALT_LEN];
unsigned long n;
str = opt_arg();
break;
case OPT_KFILE:
- in = bio_open_default(opt_arg(), "r");
+ in = bio_open_default(opt_arg(), 'r', FORMAT_TEXT);
if (in == NULL)
goto opthelp;
i = BIO_gets(in, buf, sizeof buf);
if (!opt_md(opt_arg(), &dgst))
goto opthelp;
break;
- case OPT_NON_FIPS_ALLOW:
- non_fips_allow = 1;
- break;
case OPT_CIPHER:
if (!opt_cipher(opt_unknown(), &c))
goto opthelp;
}
if (dgst == NULL)
- dgst = EVP_md5();
+ dgst = EVP_sha256();
/* It must be large enough for a base64 encoded line */
if (base64 && bsize < 80)
if (verbose)
BIO_printf(bio_err, "bufsize=%d\n", bsize);
- strbuf = OPENSSL_malloc(SIZE);
- buff = OPENSSL_malloc(EVP_ENCODE_LENGTH(bsize));
- if ((buff == NULL) || (strbuf == NULL)) {
- BIO_printf(bio_err, "OPENSSL_malloc failure %ld\n",
- (long)EVP_ENCODE_LENGTH(bsize));
- goto end;
+ if (base64) {
+ if (enc)
+ outformat = FORMAT_BASE64;
+ else
+ informat = FORMAT_BASE64;
}
+ strbuf = app_malloc(SIZE, "strbuf");
+ buff = app_malloc(EVP_ENCODE_LENGTH(bsize), "evp buffer");
+
if (debug) {
BIO_set_callback(in, BIO_debug_callback);
BIO_set_callback(out, BIO_debug_callback);
if (infile == NULL) {
unbuffer(stdin);
- in = dup_bio_in();
+ in = dup_bio_in(informat);
} else
- in = bio_open_default(infile, "r");
+ in = bio_open_default(infile, 'r', informat);
if (in == NULL)
goto end;
}
}
- out = bio_open_default(outfile, "w");
+ out = bio_open_default(outfile, 'w', outformat);
if (out == NULL)
goto end;
else
OPENSSL_cleanse(str, strlen(str));
}
- if ((hiv != NULL) && !set_hex(hiv, iv, sizeof iv)) {
- BIO_printf(bio_err, "invalid hex iv value\n");
- goto end;
+ if (hiv != NULL) {
+ int siz = EVP_CIPHER_iv_length(cipher);
+ if (siz == 0) {
+ BIO_printf(bio_err, "warning: iv not use by this cipher\n");
+ } else if (!set_hex(hiv, iv, sizeof iv)) {
+ BIO_printf(bio_err, "invalid hex iv value\n");
+ goto end;
+ }
}
if ((hiv == NULL) && (str == NULL)
&& EVP_CIPHER_iv_length(cipher) != 0) {
BIO_printf(bio_err, "iv undefined\n");
goto end;
}
- if ((hkey != NULL) && !set_hex(hkey, key, sizeof key)) {
+ if ((hkey != NULL) && !set_hex(hkey, key, EVP_CIPHER_key_length(cipher))) {
BIO_printf(bio_err, "invalid hex key value\n");
goto end;
}
BIO_get_cipher_ctx(benc, &ctx);
- if (non_fips_allow)
- EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPH_FLAG_NON_FIPS_ALLOW);
-
if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc)) {
BIO_printf(bio_err, "Error setting cipher %s\n",
EVP_CIPHER_name(cipher));
ret = 0;
if (verbose) {
- BIO_printf(bio_err, "bytes read :%8ld\n", BIO_number_read(in));
- BIO_printf(bio_err, "bytes written:%8ld\n", BIO_number_written(out));
+ BIO_printf(bio_err, "bytes read :%8"PRIu64"\n", BIO_number_read(in));
+ BIO_printf(bio_err, "bytes written:%8"PRIu64"\n", BIO_number_written(out));
}
end:
ERR_print_errors(bio_err);
- if (strbuf != NULL)
- OPENSSL_free(strbuf);
- if (buff != NULL)
- OPENSSL_free(buff);
+ OPENSSL_free(strbuf);
+ OPENSSL_free(buff);
BIO_free(in);
BIO_free_all(out);
BIO_free(benc);
#ifdef ZLIB
BIO_free(bzl);
#endif
- if (pass)
- OPENSSL_free(pass);
+ OPENSSL_free(pass);
return (ret);
}
*(in++) = '\0';
if (j == 0)
break;
- if ((j >= '0') && (j <= '9'))
- j -= '0';
- else if ((j >= 'A') && (j <= 'F'))
- j = j - 'A' + 10;
- else if ((j >= 'a') && (j <= 'f'))
- j = j - 'a' + 10;
- else {
+ if (!isxdigit(j)) {
BIO_printf(bio_err, "non-hex digit\n");
return (0);
}
+ j = (unsigned char)app_hex(j);
if (i & 1)
out[i / 2] |= j;
else
projects / openssl.git / blobdiff