/*
- * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2015-2020 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
#include "internal/sizes.h"
#include "crypto/evp.h"
+static OPENSSL_CTX *testctx = NULL;
+
/*
* kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
* should never use this key anywhere but in an example.
}
#endif
-#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODE)
+/* This uses kExampleRSAKeyDER and kExampleRSAKeyPKCS8 to verify encoding */
+static int test_privatekey_to_pkcs8(void)
+{
+ EVP_PKEY *pkey = NULL;
+ BIO *membio = NULL;
+ char *membuf = NULL;
+ size_t membuf_len = 0;
+ int ok = 0;
+
+ if (!TEST_ptr(membio = BIO_new(BIO_s_mem()))
+ || !TEST_ptr(pkey = load_example_rsa_key())
+ || !TEST_int_gt(i2d_PKCS8PrivateKey_bio(membio, pkey, NULL,
+ NULL, 0, NULL, NULL),
+ 0)
+ || !TEST_ptr((membuf_len = (size_t)BIO_get_mem_data(membio, &membuf),
+ membuf))
+ || !TEST_mem_eq(membuf, membuf_len,
+ kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8))
+ /*
+ * We try to write PEM as well, just to see that it doesn't err, but
+ * assume that the result is correct.
+ */
+ || !TEST_int_gt(PEM_write_bio_PKCS8PrivateKey(membio, pkey, NULL,
+ NULL, 0, NULL, NULL),
+ 0))
+ goto done;
+
+ ok = 1;
+ done:
+ EVP_PKEY_free(pkey);
+ BIO_free_all(membio);
+ return ok;
+}
+
+#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
static int test_EVP_SM2_verify(void)
{
#endif
};
-static int test_set_get_raw_keys_int(int tst, int pub)
+static int test_set_get_raw_keys_int(int tst, int pub, int uselibctx)
{
int ret = 0;
unsigned char buf[80];
if (pub) {
inlen = strlen(keys[tst].pub);
in = (unsigned char *)keys[tst].pub;
- pkey = EVP_PKEY_new_raw_public_key(keys[tst].type,
- NULL,
- in,
- inlen);
+ if (uselibctx) {
+ pkey = EVP_PKEY_new_raw_public_key_with_libctx(
+ testctx,
+ OBJ_nid2sn(keys[tst].type),
+ NULL,
+ in,
+ inlen);
+ } else {
+ pkey = EVP_PKEY_new_raw_public_key(keys[tst].type,
+ NULL,
+ in,
+ inlen);
+ }
} else {
inlen = strlen(keys[tst].priv);
in = (unsigned char *)keys[tst].priv;
- pkey = EVP_PKEY_new_raw_private_key(keys[tst].type,
- NULL,
- in,
- inlen);
+ if (uselibctx) {
+ pkey = EVP_PKEY_new_raw_private_key_with_libctx(
+ testctx, OBJ_nid2sn(keys[tst].type),
+ NULL,
+ in,
+ inlen);
+ } else {
+ pkey = EVP_PKEY_new_raw_private_key(keys[tst].type,
+ NULL,
+ in,
+ inlen);
+ }
}
if (!TEST_ptr(pkey)
static int test_set_get_raw_keys(int tst)
{
- return test_set_get_raw_keys_int(tst, 0)
- && test_set_get_raw_keys_int(tst, 1);
+ return test_set_get_raw_keys_int(tst, 0, 0)
+ && test_set_get_raw_keys_int(tst, 0, 1)
+ && test_set_get_raw_keys_int(tst, 1, 0)
+ && test_set_get_raw_keys_int(tst, 1, 1);
}
static int pkey_custom_check(EVP_PKEY *pkey)
return ret;
}
+#ifndef OPENSSL_NO_CMAC
+static int test_CMAC_keygen(void)
+{
+ /*
+ * This is a legacy method for CMACs, but should still work.
+ * This verifies that it works without an ENGINE.
+ */
+ EVP_PKEY_CTX *kctx = EVP_PKEY_CTX_new_id(EVP_PKEY_CMAC, NULL);
+ int ret = 0;
+
+ if (!TEST_true(EVP_PKEY_keygen_init(kctx) > 0)
+ && !TEST_true(EVP_PKEY_CTX_ctrl(kctx, -1, EVP_PKEY_OP_KEYGEN,
+ EVP_PKEY_CTRL_CIPHER,
+ 0, (void *)EVP_aes_256_ecb()) > 0))
+ goto done;
+ ret = 1;
+
+ done:
+ EVP_PKEY_CTX_free(kctx);
+ return ret;
+}
+#endif
+
static int test_HKDF(void)
{
EVP_PKEY_CTX *pctx;
return ret;
}
+static int test_emptyikm_HKDF(void)
+{
+ EVP_PKEY_CTX *pctx;
+ unsigned char out[20];
+ size_t outlen;
+ int ret = 0;
+ unsigned char salt[] = "9876543210";
+ unsigned char key[] = "";
+ unsigned char info[] = "stringinfo";
+ const unsigned char expected[] = {
+ 0x68, 0x81, 0xa5, 0x3e, 0x5b, 0x9c, 0x7b, 0x6f, 0x2e, 0xec, 0xc8, 0x47,
+ 0x7c, 0xfa, 0x47, 0x35, 0x66, 0x82, 0x15, 0x30
+ };
+ size_t expectedlen = sizeof(expected);
+
+ if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)))
+ goto done;
+
+ outlen = sizeof(out);
+ memset(out, 0, outlen);
+
+ if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
+ || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
+ || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
+ sizeof(salt) - 1), 0)
+ || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
+ sizeof(key) - 1), 0)
+ || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
+ sizeof(info) - 1), 0)
+ || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
+ || !TEST_mem_eq(out, outlen, expected, expectedlen))
+ goto done;
+
+ ret = 1;
+
+ done:
+ EVP_PKEY_CTX_free(pctx);
+
+ return ret;
+}
+
#ifndef OPENSSL_NO_EC
static int test_X509_PUBKEY_inplace(void)
{
}
#endif
+/*
+ * We test what happens with an empty template. For the sake of this test,
+ * the template must be ignored, and we know that's the case for RSA keys
+ * (this might arguably be a misfeature, but that's what we currently do,
+ * even in provider code, since that's how the legacy RSA implementation
+ * does things)
+ */
+static int test_keygen_with_empty_template(int n)
+{
+ EVP_PKEY_CTX *ctx = NULL;
+ EVP_PKEY *pkey = NULL;
+ EVP_PKEY *tkey = NULL;
+ int ret = 0;
+
+ switch (n) {
+ case 0:
+ /* We do test with no template at all as well */
+ if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)))
+ goto err;
+ break;
+ case 1:
+ /* Here we create an empty RSA key that serves as our template */
+ if (!TEST_ptr(tkey = EVP_PKEY_new())
+ || !TEST_true(EVP_PKEY_set_type(tkey, EVP_PKEY_RSA))
+ || !TEST_ptr(ctx = EVP_PKEY_CTX_new(tkey, NULL)))
+ goto err;
+ break;
+ }
+
+ if (!TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
+ || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0))
+ goto err;
+
+ ret = 1;
+ err:
+ EVP_PKEY_CTX_free(ctx);
+ EVP_PKEY_free(pkey);
+ EVP_PKEY_free(tkey);
+ return ret;
+}
+
+/*
+ * Test that we fail if we attempt to use an algorithm that is not available
+ * in the current library context (unless we are using an algorithm that should
+ * be made available via legacy codepaths).
+ */
+static int test_pkey_ctx_fail_without_provider(int tst)
+{
+ OPENSSL_CTX *tmpctx = OPENSSL_CTX_new();
+ OSSL_PROVIDER *nullprov = NULL;
+ EVP_PKEY_CTX *pctx = NULL;
+ int ret = 0;
+
+ if (!TEST_ptr(tmpctx))
+ goto err;
+
+ nullprov = OSSL_PROVIDER_load(tmpctx, "null");
+ if (!TEST_ptr(nullprov))
+ goto err;
+
+ pctx = EVP_PKEY_CTX_new_from_name(tmpctx, tst == 0 ? "RSA" : "HMAC", "");
+
+ /* RSA is not available via any provider so we expect this to fail */
+ if (tst == 0 && !TEST_ptr_null(pctx))
+ goto err;
+
+ /*
+ * HMAC is always available because it is implemented via legacy codepaths
+ * and not in a provider at all. We expect this to pass.
+ */
+ if (tst == 1 && !TEST_ptr(pctx))
+ goto err;
+
+ ret = 1;
+
+ err:
+ EVP_PKEY_CTX_free(pctx);
+ OSSL_PROVIDER_unload(nullprov);
+ OPENSSL_CTX_free(tmpctx);
+ return ret;
+}
+
int setup_tests(void)
{
+ testctx = OPENSSL_CTX_new();
+
+ if (!TEST_ptr(testctx))
+ return 0;
+
ADD_ALL_TESTS(test_EVP_DigestSignInit, 9);
ADD_TEST(test_EVP_DigestVerifyInit);
ADD_TEST(test_EVP_Enveloped);
ADD_ALL_TESTS(test_d2i_AutoPrivateKey, OSSL_NELEM(keydata));
+ ADD_TEST(test_privatekey_to_pkcs8);
#ifndef OPENSSL_NO_EC
ADD_TEST(test_EVP_PKCS82PKEY);
#endif
-#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODE)
+#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
ADD_TEST(test_EVP_SM2);
ADD_TEST(test_EVP_SM2_verify);
#endif
if (!TEST_int_eq(EVP_PKEY_meth_add0(custom_pmeth), 1))
return 0;
ADD_ALL_TESTS(test_EVP_PKEY_check, OSSL_NELEM(keycheckdata));
+#ifndef OPENSSL_NO_CMAC
+ ADD_TEST(test_CMAC_keygen);
+#endif
ADD_TEST(test_HKDF);
+ ADD_TEST(test_emptyikm_HKDF);
#ifndef OPENSSL_NO_EC
ADD_TEST(test_X509_PUBKEY_inplace);
ADD_ALL_TESTS(test_invalide_ec_char2_pub_range_decode,
#ifndef OPENSSL_NO_DH
ADD_TEST(test_EVP_PKEY_set1_DH);
#endif
+ ADD_ALL_TESTS(test_keygen_with_empty_template, 2);
+ ADD_ALL_TESTS(test_pkey_ctx_fail_without_provider, 2);
return 1;
}
+
+void cleanup_tests(void)
+{
+ OPENSSL_CTX_free(testctx);
+}