-/* evp_test.c */
/*
* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project.
#include <openssl/err.h>
#include <openssl/x509v3.h>
#include <openssl/pkcs12.h>
+#include <openssl/kdf.h>
#include "internal/numbers.h"
/* Remove spaces from beginning and end of a string */
static int test_bin(const char *value, unsigned char **buf, size_t *buflen)
{
long len;
+
+ *buflen = 0;
if (!*value) {
/*
* Don't return NULL for zero length buffer.
*buflen = len;
return 1;
}
+#ifndef OPENSSL_NO_SCRYPT
+/* Currently only used by scrypt tests */
/* Parse unsigned decimal 64 bit integer value */
static int test_uint64(const char *value, uint64_t *pr)
{
}
return 1;
}
+#endif
/* Structure holding test information */
struct evp_test {
/* file being read */
- FILE *in;
+ BIO *in;
/* List of public and private keys */
struct key_list *private;
struct key_list *public;
static const struct evp_test_method psign_test_method, pverify_test_method;
static const struct evp_test_method pdecrypt_test_method;
static const struct evp_test_method pverify_recover_test_method;
+static const struct evp_test_method pderive_test_method;
static const struct evp_test_method pbe_test_method;
static const struct evp_test_method encode_test_method;
+static const struct evp_test_method kdf_test_method;
static const struct evp_test_method *evp_test_list[] = {
&digest_test_method,
&pverify_test_method,
&pdecrypt_test_method,
&pverify_recover_test_method,
+ &pderive_test_method,
&pbe_test_method,
&encode_test_method,
+ &kdf_test_method,
NULL
};
if (!parse_line(&keyword, &value, buf))
return 1;
if (strcmp(keyword, "PrivateKey") == 0) {
- save_pos = ftell(t->in);
- pk = PEM_read_PrivateKey(t->in, NULL, 0, NULL);
+ save_pos = BIO_tell(t->in);
+ pk = PEM_read_bio_PrivateKey(t->in, NULL, 0, NULL);
if (pk == NULL && !check_unsupported()) {
fprintf(stderr, "Error reading private key %s\n", value);
ERR_print_errors_fp(stderr);
add_key = 1;
}
if (strcmp(keyword, "PublicKey") == 0) {
- save_pos = ftell(t->in);
- pk = PEM_read_PUBKEY(t->in, NULL, 0, NULL);
+ save_pos = BIO_tell(t->in);
+ pk = PEM_read_bio_PUBKEY(t->in, NULL, 0, NULL);
if (pk == NULL && !check_unsupported()) {
fprintf(stderr, "Error reading public key %s\n", value);
ERR_print_errors_fp(stderr);
key = OPENSSL_malloc(sizeof(*key));
if (!key)
return 0;
- key->name = BUF_strdup(value);
+ key->name = OPENSSL_strdup(value);
key->key = pk;
key->next = *lst;
*lst = key;
/* Rewind input, read to end and update line numbers */
- fseek(t->in, save_pos, SEEK_SET);
- while (fgets(tmpbuf, sizeof(tmpbuf), t->in)) {
+ (void)BIO_seek(t->in, save_pos);
+ while (BIO_gets(t->in,tmpbuf, sizeof(tmpbuf))) {
t->line++;
if (strncmp(tmpbuf, "-----END", 8) == 0)
return 1;
fprintf(stderr, "Line %d: multiple result lines\n", t->line);
return 0;
}
- t->expected_err = BUF_strdup(value);
+ t->expected_err = OPENSSL_strdup(value);
if (!t->expected_err)
return 0;
} else {
}
/* The result printing code expects a non-NULL buffer. */
- t->out_expected = BUF_memdup(expected, expected_len ? expected_len : 1);
+ t->out_expected = OPENSSL_memdup(expected, expected_len ? expected_len : 1);
t->out_expected_len = expected_len;
- t->out_received = BUF_memdup(received, received_len ? received_len : 1);
+ t->out_received = OPENSSL_memdup(received, received_len ? received_len : 1);
t->out_received_len = received_len;
if (t->out_expected == NULL || t->out_received == NULL) {
fprintf(stderr, "Memory allocation error!\n");
int main(int argc, char **argv)
{
- FILE *in = NULL;
+ BIO *in = NULL;
char buf[10240];
struct evp_test t;
CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
- ERR_load_crypto_strings();
- OpenSSL_add_all_algorithms();
-
memset(&t, 0, sizeof(t));
t.start_line = -1;
- in = fopen(argv[1], "r");
+ in = BIO_new_file(argv[1], "r");
t.in = in;
- while (fgets(buf, sizeof(buf), in)) {
+ while (BIO_gets(in, buf, sizeof(buf))) {
t.line++;
if (!process_test(&t, buf, 0))
exit(1);
t.ntests, t.errors, t.nskip);
free_key_list(t.public);
free_key_list(t.private);
- fclose(in);
- EVP_cleanup();
- CRYPTO_cleanup_all_ex_data();
- ERR_remove_thread_state(NULL);
- ERR_free_strings();
- CRYPTO_mem_leaks_fp(stderr);
+ BIO_free(in);
+
+#ifndef OPENSSL_NO_CRYPTO_MDEBUG
+ if (CRYPTO_mem_leaks_fp(stderr) <= 0)
+ return 1;
+#endif
if (t.errors)
return 1;
return 0;
{
int type;
struct mac_data *mdat;
- if (strcmp(alg, "HMAC") == 0)
+ if (strcmp(alg, "HMAC") == 0) {
type = EVP_PKEY_HMAC;
- else if (strcmp(alg, "CMAC") == 0)
+ } else if (strcmp(alg, "CMAC") == 0) {
+#ifndef OPENSSL_NO_CMAC
type = EVP_PKEY_CMAC;
- else
+#else
+ t->skip = 1;
+ return 1;
+#endif
+ } else
return 0;
mdat = OPENSSL_malloc(sizeof(*mdat));
if (strcmp(keyword, "Key") == 0)
return test_bin(value, &mdata->key, &mdata->key_len);
if (strcmp(keyword, "Algorithm") == 0) {
- mdata->alg = BUF_strdup(value);
+ mdata->alg = OPENSSL_strdup(value);
if (!mdata->alg)
return 0;
return 1;
unsigned char *mac = NULL;
size_t mac_len;
+#ifdef OPENSSL_NO_DES
+ if (strstr(mdata->alg, "DES") != NULL) {
+ /* Skip DES */
+ err = NULL;
+ goto err;
+ }
+#endif
+
err = "MAC_PKEY_CTX_ERROR";
genctx = EVP_PKEY_CTX_new_id(mdata->type, NULL);
if (!genctx)
EVP_PKEY_CTX_free(kdata->ctx);
}
+static int pkey_test_ctrl(EVP_PKEY_CTX *pctx, const char *value)
+{
+ int rv;
+ char *p, *tmpval;
+
+ tmpval = OPENSSL_strdup(value);
+ if (tmpval == NULL)
+ return 0;
+ p = strchr(tmpval, ':');
+ if (p != NULL)
+ *p++ = 0;
+ rv = EVP_PKEY_CTX_ctrl_str(pctx, tmpval, p);
+ OPENSSL_free(tmpval);
+ return rv > 0;
+}
+
static int pkey_test_parse(struct evp_test *t,
const char *keyword, const char *value)
{
return test_bin(value, &kdata->input, &kdata->input_len);
if (strcmp(keyword, "Output") == 0)
return test_bin(value, &kdata->output, &kdata->output_len);
- if (strcmp(keyword, "Ctrl") == 0) {
- char *p = strchr(value, ':');
- if (p)
- *p++ = 0;
- if (EVP_PKEY_CTX_ctrl_str(kdata->ctx, value, p) <= 0)
- return 0;
- return 1;
- }
+ if (strcmp(keyword, "Ctrl") == 0)
+ return pkey_test_ctrl(kdata->ctx, value);
return 0;
}
verify_test_run
};
+
+static int pderive_test_init(struct evp_test *t, const char *name)
+{
+ return pkey_test_init(t, name, 0, EVP_PKEY_derive_init, 0);
+}
+
+static int pderive_test_parse(struct evp_test *t,
+ const char *keyword, const char *value)
+{
+ struct pkey_data *kdata = t->data;
+
+ if (strcmp(keyword, "PeerKey") == 0) {
+ EVP_PKEY *peer;
+ if (find_key(&peer, value, t->public) == 0)
+ return 0;
+ if (EVP_PKEY_derive_set_peer(kdata->ctx, peer) <= 0)
+ return 0;
+ return 1;
+ }
+ if (strcmp(keyword, "SharedSecret") == 0)
+ return test_bin(value, &kdata->output, &kdata->output_len);
+ if (strcmp(keyword, "Ctrl") == 0)
+ return pkey_test_ctrl(kdata->ctx, value);
+ return 0;
+}
+
+static int pderive_test_run(struct evp_test *t)
+{
+ struct pkey_data *kdata = t->data;
+ unsigned char *out = NULL;
+ size_t out_len;
+ const char *err = "INTERNAL_ERROR";
+
+ out_len = kdata->output_len;
+ out = OPENSSL_malloc(out_len);
+ if (!out) {
+ fprintf(stderr, "Error allocating output buffer!\n");
+ exit(1);
+ }
+ err = "DERIVE_ERROR";
+ if (EVP_PKEY_derive(kdata->ctx, out, &out_len) <= 0)
+ goto err;
+ err = "SHARED_SECRET_LENGTH_MISMATCH";
+ if (out_len != kdata->output_len)
+ goto err;
+ err = "SHARED_SECRET_MISMATCH";
+ if (check_output(t, kdata->output, out, out_len))
+ goto err;
+ err = NULL;
+ err:
+ OPENSSL_free(out);
+ t->err = err;
+ return 1;
+}
+
+static const struct evp_test_method pderive_test_method = {
+ "Derive",
+ pderive_test_init,
+ pkey_test_cleanup,
+ pderive_test_parse,
+ pderive_test_run
+};
+
/* PBE tests */
#define PBE_TYPE_SCRYPT 1
struct pbe_data *pdat;
int pbe_type = 0;
+ if (strcmp(alg, "scrypt") == 0) {
#ifndef OPENSSL_NO_SCRYPT
- if (strcmp(alg, "scrypt") == 0)
pbe_type = PBE_TYPE_SCRYPT;
+#else
+ t->skip = 1;
+ return 1;
#endif
- else if (strcmp(alg, "pbkdf2") == 0)
+ } else if (strcmp(alg, "pbkdf2") == 0) {
pbe_type = PBE_TYPE_PBKDF2;
- else if (strcmp(alg, "pkcs12") == 0)
+ } else if (strcmp(alg, "pkcs12") == 0) {
pbe_type = PBE_TYPE_PKCS12;
- else
+ } else {
fprintf(stderr, "Unknown pbe algorithm %s\n", alg);
+ }
pdat = OPENSSL_malloc(sizeof(*pdat));
pdat->pbe_type = pbe_type;
pdat->pass = NULL;
edata->encoding = BASE64_VALID_ENCODING;
} else if (strcmp(encoding, "invalid") == 0) {
edata->encoding = BASE64_INVALID_ENCODING;
- t->expected_err = BUF_strdup("DECODE_ERROR");
+ t->expected_err = OPENSSL_strdup("DECODE_ERROR");
if (t->expected_err == NULL)
return 0;
} else {
encode_test_parse,
encode_test_run,
};
+
+/* KDF operations */
+
+struct kdf_data {
+ /* Context for this operation */
+ EVP_PKEY_CTX *ctx;
+ /* Expected output */
+ unsigned char *output;
+ size_t output_len;
+};
+
+/*
+ * Perform public key operation setup: lookup key, allocated ctx and call
+ * the appropriate initialisation function
+ */
+static int kdf_test_init(struct evp_test *t, const char *name)
+{
+ struct kdf_data *kdata;
+
+ kdata = OPENSSL_malloc(sizeof(*kdata));
+ if (kdata == NULL)
+ return 0;
+ kdata->ctx = NULL;
+ kdata->output = NULL;
+ t->data = kdata;
+ kdata->ctx = EVP_PKEY_CTX_new_id(OBJ_sn2nid(name), NULL);
+ if (kdata->ctx == NULL)
+ return 0;
+ if (EVP_PKEY_derive_init(kdata->ctx) <= 0)
+ return 0;
+ return 1;
+}
+
+static void kdf_test_cleanup(struct evp_test *t)
+{
+ struct kdf_data *kdata = t->data;
+ OPENSSL_free(kdata->output);
+ EVP_PKEY_CTX_free(kdata->ctx);
+}
+
+static int kdf_test_parse(struct evp_test *t,
+ const char *keyword, const char *value)
+{
+ struct kdf_data *kdata = t->data;
+ if (strcmp(keyword, "Output") == 0)
+ return test_bin(value, &kdata->output, &kdata->output_len);
+ if (strncmp(keyword, "Ctrl", 4) == 0)
+ return pkey_test_ctrl(kdata->ctx, value);
+ return 0;
+}
+
+static int kdf_test_run(struct evp_test *t)
+{
+ struct kdf_data *kdata = t->data;
+ unsigned char *out = NULL;
+ size_t out_len = kdata->output_len;
+ const char *err = "INTERNAL_ERROR";
+ out = OPENSSL_malloc(out_len);
+ if (!out) {
+ fprintf(stderr, "Error allocating output buffer!\n");
+ exit(1);
+ }
+ err = "KDF_DERIVE_ERROR";
+ if (EVP_PKEY_derive(kdata->ctx, out, &out_len) <= 0)
+ goto err;
+ err = "KDF_LENGTH_MISMATCH";
+ if (out_len != kdata->output_len)
+ goto err;
+ err = "KDF_MISMATCH";
+ if (check_output(t, kdata->output, out, out_len))
+ goto err;
+ err = NULL;
+ err:
+ OPENSSL_free(out);
+ t->err = err;
+ return 1;
+}
+
+static const struct evp_test_method kdf_test_method = {
+ "KDF",
+ kdf_test_init,
+ kdf_test_cleanup,
+ kdf_test_parse,
+ kdf_test_run
+};
projects / openssl.git / blobdiff