From 4d6426de6c249f785db4a25267af8f6d62293ec6 Mon Sep 17 00:00:00 2001 From: Rajeev Ranjan Date: Tue, 18 Jul 2023 10:32:57 +0200 Subject: [PATCH] POC KEM implemetation cmp_asn.c: add ASN1 structure for OSSL_CMP_KEMCIPHERTEXTINFO cmp{_asn.c, .h.in}: add function OSSL_CMP_ITAV_new_KemCiphertext cmp{_msg.c, .h.in}: add function OSSL_CMP_MSG_get_extraCerts cmp_server.c: extend unprotected_exception for KemCiphertextInfo without value objects.txt, oids.txt, obj_{dah.h, mac.num, mac.h}: add id_it_KemCiphertextInfo (preliminary value for prototyping) cmp{.h.in, _local.h, _asn.c}: add structure OSSL_CMP_KEMOTHERINFO for kdf objects.txt, cmp_{asn.c, local.h}: add OSSL_CMP_KEMBMPARAMETER and preliminary value for id-KemBasedMac objects.txt : add NID_hkdfWithSHA256 openssl.txt, cmperr.h: add KBM error. cmp_{client.c, ctx.c, local.h}, cmp.h.in: extend OSSL_CMP_CTX for KEM. cmp_mock_srv.c: add support of Key encapculation and ITAV with kemCiphertext build.info, cmp.h.in, cmp_{kem.c, local.h}: add functions for kemBasedMac cmp_{genm.c, local.h}: convert static function to ossl_cmp_genm_get_itav cmp_{hdr.c, local.h}: add func ossl_cmp_hdr_has_KemCiphertextInfo cmp_protect.c: extend protection for KemBasedMac cmp_client.c: add kembasedMac protection to OSSL_CMP_exec_certreq cmp_vfy.c: add msg validation for NID_id_KemBasedMac cmp_client.c: extend unprotected_exception for NID_id_it_KemCiphertextInfo. cmp_server.c: adapt server for kem objects.txt, obj_{dat.h, mac.num. mac.h}, oids.txt: add oids for id_kem_rsa & id_kdf_kdf2 cmp_{asn.c, local.h}: add asn structure for OSSL_CMP_RSAKEMPARAMETERS cmp_{kem.c, local.h}: add function ossl_cmp_kem_get_ssk_using_srvcert kem{.crt, .key, _only.crt}: add certificate with kem. TODO! server_withkem.cnf, test_withserverkem.cnf: added for testing libcrypto.num: add CMP APIs server_kem.crt: add server cert with keyusage=keyEncipherment test_credentials.csv: add test with kem cert cmp_{asn.c, kem.c, local.h}: move ossl_cmp_kem_KemOtherInfo_new() from cmp_kem.c cmp_mock_srv.c: add TODO for verifying client Kem certificate. cmp_ctx.c: add TODO to generalize KEM default parameter cmp_ctx.c: add helper function to set octet secret in ctx. cmp_{ctx.c,local.h}: remove ossl_cmp_ctx_get0_transactionID() cmp_{ctx.c, local.h}: update kem variable name cmp_client.c: update kem variable name cmp_kem.c: update kem variable name cmp_protect.c: update kem variable name cmp_server.c: update kem variable name cmp_kem.c: fix return in case of error cmp_kem.c: remove RSA kem code from cmp_kem.c cmp_{kemrsa.c, local.h}: add rsa kem and kdf2 implementation build.info: add file cmp_kemrsa.c cmp_kem.c: updated to support KEM from oqsprovider kem_{RSA,kyber512}.{crt,key}: add RSA and kyber512 cert and key for KEM testing cmp_{util.c, local.h}: add function ossl_cmp_x509_algor_set0 cmp_asn.c: fix memory leak cmp_kem.c: fix memory leak cmp_kemrsa.c: fix memory leak to be removed, cmp_kem.c:add debug message kem_kyber1024.{crt, priv, pub}: add kyber1024 key and certificate for testing. --- apps/lib/cmp_mock_srv.c | 41 +- crypto/cmp/build.info | 2 +- crypto/cmp/cmp_asn.c | 110 +++- crypto/cmp/cmp_client.c | 29 + crypto/cmp/cmp_ctx.c | 95 ++- crypto/cmp/cmp_genm.c | 12 +- crypto/cmp/cmp_hdr.c | 24 + crypto/cmp/cmp_kem.c | 602 ++++++++++++++++++ crypto/cmp/cmp_kemrsa.c | 199 ++++++ crypto/cmp/cmp_local.h | 134 ++++ crypto/cmp/cmp_msg.c | 8 + crypto/cmp/cmp_protect.c | 96 ++- crypto/cmp/cmp_server.c | 78 ++- crypto/cmp/cmp_util.c | 14 + crypto/cmp/cmp_vfy.c | 36 ++ crypto/err/openssl.txt | 2 + crypto/objects/obj_dat.h | 35 +- crypto/objects/obj_mac.num | 5 + crypto/objects/objects.txt | 10 + fuzz/oids.txt | 5 + include/openssl/cmp.h.in | 11 +- include/openssl/cmperr.h | 2 + include/openssl/obj_mac.h | 22 + .../80-test_cmp_http_data/Mock/kem.crt | 22 + .../80-test_cmp_http_data/Mock/kem.key | 28 + .../80-test_cmp_http_data/Mock/kem_RSA.crt | 22 + .../80-test_cmp_http_data/Mock/kem_RSA.key | 28 + .../Mock/kem_kyber1024.crt | 48 ++ .../Mock/kem_kyber512.crt | 32 + .../Mock/kem_kyber512.key | 54 ++ .../80-test_cmp_http_data/Mock/kem_only.crt | 22 + .../80-test_cmp_http_data/Mock/kyber1024.priv | 102 +++ .../80-test_cmp_http_data/Mock/kyber1024.pub | 36 ++ .../80-test_cmp_http_data/Mock/server_kem.crt | 20 + .../Mock/server_withkem.cnf | 17 + .../Mock/test_withserverkem.cnf | 141 ++++ .../test_credentials.csv | 3 + util/libcrypto.num | 3 + 38 files changed, 2092 insertions(+), 58 deletions(-) create mode 100644 crypto/cmp/cmp_kem.c create mode 100644 crypto/cmp/cmp_kemrsa.c create mode 100644 test/recipes/80-test_cmp_http_data/Mock/kem.crt create mode 100644 test/recipes/80-test_cmp_http_data/Mock/kem.key create mode 100644 test/recipes/80-test_cmp_http_data/Mock/kem_RSA.crt create mode 100644 test/recipes/80-test_cmp_http_data/Mock/kem_RSA.key create mode 100644 test/recipes/80-test_cmp_http_data/Mock/kem_kyber1024.crt create mode 100644 test/recipes/80-test_cmp_http_data/Mock/kem_kyber512.crt create mode 100644 test/recipes/80-test_cmp_http_data/Mock/kem_kyber512.key create mode 100644 test/recipes/80-test_cmp_http_data/Mock/kem_only.crt create mode 100644 test/recipes/80-test_cmp_http_data/Mock/kyber1024.priv create mode 100644 test/recipes/80-test_cmp_http_data/Mock/kyber1024.pub create mode 100644 test/recipes/80-test_cmp_http_data/Mock/server_kem.crt create mode 100644 test/recipes/80-test_cmp_http_data/Mock/server_withkem.cnf create mode 100644 test/recipes/80-test_cmp_http_data/Mock/test_withserverkem.cnf diff --git a/apps/lib/cmp_mock_srv.c b/apps/lib/cmp_mock_srv.c index 5fed3a9fd07a1..26f9bfd96d9a9 100644 --- a/apps/lib/cmp_mock_srv.c +++ b/apps/lib/cmp_mock_srv.c @@ -391,10 +391,31 @@ static OSSL_CMP_PKISI *process_rr(OSSL_CMP_SRV_CTX *srv_ctx, return OSSL_CMP_PKISI_dup(ctx->statusOut); } -static OSSL_CMP_ITAV *process_genm_itav(mock_srv_ctx *ctx, int req_nid, - const OSSL_CMP_ITAV *req) +/* TODO: extend it to check for certificate with KEM key (PQ keys) */ +static X509 *extracert_withKEM(STACK_OF(X509) *certs) { - OSSL_CMP_ITAV *rsp; + int i; + + if (certs == NULL) + return NULL; + + for (i = 0; i < sk_X509_num(certs); i++) { + X509 *cert = sk_X509_value(certs, i); + + if ((X509_get_key_usage(cert) & X509v3_KU_KEY_ENCIPHERMENT)) { + return cert; + } + } + return NULL; +} + +static OSSL_CMP_ITAV *process_genm_itav(OSSL_CMP_SRV_CTX *srv_ctx, + int req_nid, + const OSSL_CMP_ITAV *req, + const OSSL_CMP_MSG *genm) +{ + OSSL_CMP_ITAV *rsp = NULL; + mock_srv_ctx *ctx = OSSL_CMP_SRV_CTX_get0_custom_ctx(srv_ctx); switch (req_nid) { case NID_id_it_caCerts: @@ -405,6 +426,18 @@ static OSSL_CMP_ITAV *process_genm_itav(mock_srv_ctx *ctx, int req_nid, ctx->newWithOld, ctx->oldWithNew); break; + case NID_id_it_KemCiphertextInfo: + if (OSSL_CMP_ITAV_get0_value(req) == NULL) { + X509 *kemcert; + + /* TODO: add certificate path validation */ + kemcert = extracert_withKEM(OSSL_CMP_MSG_get_extraCerts(genm)); + if (kemcert == NULL) + break; + rsp = OSSL_CMP_SRV_kem_get_ss(srv_ctx, X509_get0_pubkey(kemcert)); + break; + } + /* fall through */ default: rsp = OSSL_CMP_ITAV_dup(req); } @@ -434,7 +467,7 @@ static int process_genm(OSSL_CMP_SRV_CTX *srv_ctx, if ((*out = sk_OSSL_CMP_ITAV_new_reserve(NULL, 1)) == NULL) return 0; - rsp = process_genm_itav(ctx, OBJ_obj2nid(obj), req); + rsp = process_genm_itav(srv_ctx, OBJ_obj2nid(obj), req, genm); if (rsp != NULL && sk_OSSL_CMP_ITAV_push(*out, rsp)) return 1; sk_OSSL_CMP_ITAV_free(*out); diff --git a/crypto/cmp/build.info b/crypto/cmp/build.info index 907d78d25ffbb..571327efd153c 100644 --- a/crypto/cmp/build.info +++ b/crypto/cmp/build.info @@ -2,7 +2,7 @@ LIBS=../../libcrypto $OPENSSLSRC=\ cmp_asn.c cmp_ctx.c cmp_err.c cmp_util.c \ cmp_status.c cmp_hdr.c cmp_protect.c cmp_msg.c cmp_vfy.c \ - cmp_server.c cmp_client.c cmp_genm.c + cmp_server.c cmp_client.c cmp_genm.c cmp_kem.c cmp_kemrsa.c IF[{- !$disabled{'http'} -}] $OPENSSLSRC=$OPENSSLSRC cmp_http.c diff --git a/crypto/cmp/cmp_asn.c b/crypto/cmp/cmp_asn.c index 3049d4f080081..5f4999a400781 100644 --- a/crypto/cmp/cmp_asn.c +++ b/crypto/cmp/cmp_asn.c @@ -55,6 +55,36 @@ ASN1_SEQUENCE(OSSL_CMP_CAKEYUPDANNCONTENT) = { } ASN1_SEQUENCE_END(OSSL_CMP_CAKEYUPDANNCONTENT) IMPLEMENT_ASN1_FUNCTIONS(OSSL_CMP_CAKEYUPDANNCONTENT) +ASN1_SEQUENCE(OSSL_CMP_RSAKEMPARAMETERS) = { + ASN1_SIMPLE(OSSL_CMP_RSAKEMPARAMETERS, KeyDerivationFunction, X509_ALGOR), + ASN1_SIMPLE(OSSL_CMP_RSAKEMPARAMETERS, KeyLength, ASN1_INTEGER) +} ASN1_SEQUENCE_END(OSSL_CMP_RSAKEMPARAMETERS) +IMPLEMENT_ASN1_FUNCTIONS(OSSL_CMP_RSAKEMPARAMETERS) + +ASN1_SEQUENCE(OSSL_CMP_KEMCIPHERTEXTINFO) = { + ASN1_SIMPLE(OSSL_CMP_KEMCIPHERTEXTINFO, kem, X509_ALGOR), + ASN1_SIMPLE(OSSL_CMP_KEMCIPHERTEXTINFO, ct, ASN1_OCTET_STRING) +} ASN1_SEQUENCE_END(OSSL_CMP_KEMCIPHERTEXTINFO) +IMPLEMENT_ASN1_FUNCTIONS(OSSL_CMP_KEMCIPHERTEXTINFO) + +ASN1_SEQUENCE(OSSL_CMP_KEMOTHERINFO) = { + ASN1_SEQUENCE_OF(OSSL_CMP_KEMOTHERINFO, staticString, ASN1_UTF8STRING), + ASN1_EXP_OPT(OSSL_CMP_KEMOTHERINFO, transactionID, ASN1_OCTET_STRING, 0), + ASN1_EXP_OPT(OSSL_CMP_KEMOTHERINFO, senderNonce, ASN1_OCTET_STRING, 1), + ASN1_EXP_OPT(OSSL_CMP_KEMOTHERINFO, recipNonce, ASN1_OCTET_STRING, 2), + ASN1_SIMPLE(OSSL_CMP_KEMOTHERINFO, len, ASN1_INTEGER), + ASN1_SIMPLE(OSSL_CMP_KEMOTHERINFO, mac, X509_ALGOR), + ASN1_SIMPLE(OSSL_CMP_KEMOTHERINFO, ct, ASN1_OCTET_STRING) +} ASN1_SEQUENCE_END(OSSL_CMP_KEMOTHERINFO) +IMPLEMENT_ASN1_FUNCTIONS(OSSL_CMP_KEMOTHERINFO) + +ASN1_SEQUENCE(OSSL_CMP_KEMBMPARAMETER) = { + ASN1_SIMPLE(OSSL_CMP_KEMBMPARAMETER, kdf, X509_ALGOR), + ASN1_SIMPLE(OSSL_CMP_KEMBMPARAMETER, len, ASN1_INTEGER), + ASN1_SIMPLE(OSSL_CMP_KEMBMPARAMETER, mac, X509_ALGOR) +} ASN1_SEQUENCE_END(OSSL_CMP_KEMBMPARAMETER) +IMPLEMENT_ASN1_FUNCTIONS(OSSL_CMP_KEMBMPARAMETER) + ASN1_SEQUENCE(OSSL_CMP_ERRORMSGCONTENT) = { ASN1_SIMPLE(OSSL_CMP_ERRORMSGCONTENT, pKIStatusInfo, OSSL_CMP_PKISI), ASN1_OPT(OSSL_CMP_ERRORMSGCONTENT, errorCode, ASN1_INTEGER), @@ -120,6 +150,9 @@ ASN1_ADB(OSSL_CMP_ITAV) = { ADB_ENTRY(NID_id_it_certProfile, ASN1_SEQUENCE_OF_OPT(OSSL_CMP_ITAV, infoValue.certProfile, ASN1_UTF8STRING)), + ADB_ENTRY(NID_id_it_KemCiphertextInfo, + ASN1_OPT(OSSL_CMP_ITAV, infoValue.KemCiphertextInfoValue, + OSSL_CMP_KEMCIPHERTEXTINFO)), } ASN1_ADB_END(OSSL_CMP_ITAV, 0, infoType, 0, &infotypeandvalue_default_tt, NULL); @@ -223,6 +256,81 @@ int OSSL_CMP_ITAV_get0_certProfile(const OSSL_CMP_ITAV *itav, return 1; } +OSSL_CMP_ITAV *ossl_cmp_itav_new_KemCiphertext(X509_ALGOR *kem, + unsigned char *in_ct, + int len) +{ + OSSL_CMP_ITAV *itav = NULL; + OSSL_CMP_KEMCIPHERTEXTINFO *KemCtInfoValue; + + if (kem == NULL || in_ct == NULL) + return NULL; + + if ((KemCtInfoValue = OSSL_CMP_KEMCIPHERTEXTINFO_new()) == NULL + || !ossl_cmp_x509_algor_set0(&KemCtInfoValue->kem, kem) + || !ossl_cmp_asn1_octet_string_set1_bytes(&KemCtInfoValue->ct, + in_ct, len)) + goto err; + + if ((itav = OSSL_CMP_ITAV_new()) == NULL) + goto err; + + itav->infoType = OBJ_nid2obj(NID_id_it_KemCiphertextInfo); + itav->infoValue.KemCiphertextInfoValue = KemCtInfoValue; + + return itav; + + err: + OSSL_CMP_KEMCIPHERTEXTINFO_free(KemCtInfoValue); + OSSL_CMP_ITAV_free(itav); + return NULL; +} + +#define KEMCMP_STATICSTRING "CMP-KEM" +int ossl_cmp_kem_KemOtherInfo_new(OSSL_CMP_CTX *ctx, + unsigned char **out, int *len) +{ + int ret = 0; + OSSL_CMP_KEMOTHERINFO *kemOtherInfo; + + if (out == NULL || len == NULL) + return 0; + + if ((kemOtherInfo = OSSL_CMP_KEMOTHERINFO_new()) == NULL) + return 0; + + if (!ossl_cmp_sk_ASN1_UTF8STRING_push_str(kemOtherInfo->staticString, + KEMCMP_STATICSTRING, -1)) + goto err; + + kemOtherInfo->transactionID = ctx->transactionID; + kemOtherInfo->senderNonce = ossl_cmp_ctx_get_kem_senderNonce(ctx); + kemOtherInfo->recipNonce = ossl_cmp_ctx_get_kem_recipNonce(ctx); + + if (!ASN1_INTEGER_set(kemOtherInfo->len, ctx->kem_ssklen) + || !X509_ALGOR_set0(kemOtherInfo->mac, OBJ_nid2obj(NID_hmacWithSHA256), + V_ASN1_UNDEF, NULL)) + goto err; + + if (ctx->kem_ct != NULL + && !ossl_cmp_asn1_octet_string_set1(&kemOtherInfo->ct, + ctx->kem_ct)) + goto err; + + *out = NULL; + if ((*len = i2d_OSSL_CMP_KEMOTHERINFO(kemOtherInfo, out)) <= 0) + goto err; + + ret = 1; + + err: + kemOtherInfo->transactionID = NULL; + kemOtherInfo->senderNonce = NULL; + kemOtherInfo->recipNonce = NULL; + OSSL_CMP_KEMOTHERINFO_free(kemOtherInfo); + return ret; +} + OSSL_CMP_ITAV *OSSL_CMP_ITAV_new_caCerts(const STACK_OF(X509) *caCerts) { OSSL_CMP_ITAV *itav = OSSL_CMP_ITAV_new(); @@ -303,7 +411,7 @@ OSSL_CMP_ITAV *OSSL_CMP_ITAV_new_rootCaKeyUpdate(const X509 *newWithNew, itav->infoValue.rootCaKeyUpdate = upd; return itav; - err: + err: OSSL_CMP_ROOTCAKEYUPDATE_free(upd); return NULL; } diff --git a/crypto/cmp/cmp_client.c b/crypto/cmp/cmp_client.c index 91876ee948e63..0d69b3592a09c 100644 --- a/crypto/cmp/cmp_client.c +++ b/crypto/cmp/cmp_client.c @@ -39,6 +39,19 @@ static int unprotected_exception(const OSSL_CMP_CTX *ctx, if (!ossl_assert(ctx != NULL && rep != NULL)) return -1; + /* unprotected response with cipher text */ + if (rcvd_type == OSSL_CMP_PKIBODY_GENP + && ctx->kem_status == KBM_SSK_USING_CLIENT_KEM_KEY + && sk_OSSL_CMP_ITAV_num(rep->body->value.genm) == 1) { + OSSL_CMP_ITAV *req_itav = sk_OSSL_CMP_ITAV_value(rep->body->value.genm, + 0); + ASN1_OBJECT *obj = OSSL_CMP_ITAV_get0_type(req_itav); + + if (OBJ_obj2nid(obj) == NID_id_it_KemCiphertextInfo + && OSSL_CMP_ITAV_get0_value(req_itav) != NULL) + return 1; + } + if (!ctx->unprotectedErrors) return 0; @@ -865,11 +878,20 @@ X509 *OSSL_CMP_exec_certreq(OSSL_CMP_CTX *ctx, int req_type, int rid = is_p10 ? OSSL_CMP_CERTREQID_NONE : OSSL_CMP_CERTREQID; int rep_type = is_p10 ? OSSL_CMP_PKIBODY_CP : req_type + 1; X509 *result = NULL; + int kembasedmac; if (ctx == NULL) { ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT); return NULL; } + kembasedmac = ossl_cmp_kem_BasedMac_required(ctx); + if (kembasedmac == -1) { + goto err; + } else if (kembasedmac == 1 + && ctx->kem_status == KBM_SSK_USING_CLIENT_KEM_KEY) { + if (!OSSL_CMP_get_ssk(ctx)) + goto err; + } if (!initial_certreq(ctx, req_type, crm, &rep, rep_type)) goto err; @@ -1045,6 +1067,13 @@ STACK_OF(OSSL_CMP_ITAV) *OSSL_CMP_exec_GENM_ses(OSSL_CMP_CTX *ctx) /* received stack of itavs not to be freed with the genp */ genp->body->value.genp = NULL; + if (ctx->kem_status == KBM_SSK_USING_CLIENT_KEM_KEY + && genp->header != NULL) { + ossl_cmp_ctx_set1_kem_senderNonce(ctx, + genp->header->senderNonce); + ossl_cmp_ctx_set1_kem_recipNonce(ctx, + genp->header->recipNonce); + } err: OSSL_CMP_MSG_free(genm); OSSL_CMP_MSG_free(genp); diff --git a/crypto/cmp/cmp_ctx.c b/crypto/cmp/cmp_ctx.c index 3f4fdd0164543..e2d3d1e9249c9 100644 --- a/crypto/cmp/cmp_ctx.c +++ b/crypto/cmp/cmp_ctx.c @@ -141,6 +141,11 @@ OSSL_CMP_CTX *OSSL_CMP_CTX_new(OSSL_LIB_CTX *libctx, const char *propq) ctx->popoMethod = OSSL_CRMF_POPO_SIGNATURE; ctx->revocationReason = CRL_REASON_NONE; + /* TODO: default values for kem need to be generalized */ + ctx->kem_ssklen = 32; + ctx->kem_mac = NID_hmacWithSHA256; + ctx->kem_kdf = NID_hkdfWithSHA256; + /* all other elements are initialized to 0 or NULL, respectively */ return ctx; @@ -186,7 +191,12 @@ int OSSL_CMP_CTX_reinit(OSSL_CMP_CTX *ctx) && ossl_cmp_ctx_set1_first_senderNonce(ctx, NULL) && OSSL_CMP_CTX_set1_transactionID(ctx, NULL) && OSSL_CMP_CTX_set1_senderNonce(ctx, NULL) - && ossl_cmp_ctx_set1_recipNonce(ctx, NULL); + && ossl_cmp_ctx_set1_recipNonce(ctx, NULL) + && ossl_cmp_ctx_set1_kem_senderNonce(ctx, NULL) + && ossl_cmp_ctx_set1_kem_recipNonce(ctx, NULL) + && ossl_cmp_ctx_set1_kem_ct(ctx, NULL) + && ossl_cmp_ctx_set1_kem_ssk(ctx, NULL, 0) + && ossl_cmp_ctx_set1_kem_secret(ctx, NULL, 0); } /* Frees OSSL_CMP_CTX variables allocated in OSSL_CMP_CTX_new() */ @@ -249,6 +259,12 @@ void OSSL_CMP_CTX_free(OSSL_CMP_CTX *ctx) OSSL_STACK_OF_X509_free(ctx->caPubs); OSSL_STACK_OF_X509_free(ctx->extraCertsIn); + ASN1_OCTET_STRING_free(ctx->kem_senderNonce); + ASN1_OCTET_STRING_free(ctx->kem_recipNonce); + ASN1_OCTET_STRING_free(ctx->kem_ct ); + ASN1_OCTET_STRING_free(ctx->kem_ssk); + ASN1_OCTET_STRING_free(ctx->kem_secret); + OPENSSL_free(ctx); } @@ -431,25 +447,34 @@ int OSSL_CMP_CTX_set1_referenceValue(OSSL_CMP_CTX *ctx, ossl_cmp_asn1_octet_string_set1_bytes(&ctx->referenceValue, ref, len); } +#define DEFINE_OSSL_set1_octetsecret(PREFIX, FIELD) \ +int PREFIX##_set1_##FIELD(OSSL_CMP_CTX *ctx, \ + const unsigned char *sec, int len) \ +{ \ + ASN1_OCTET_STRING *secret = NULL; \ + \ + if (ctx == NULL) { \ + ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT); \ + return 0; \ + } \ + if (ossl_cmp_asn1_octet_string_set1_bytes(&secret, sec, len) != 1) \ + return 0; \ + if (ctx->FIELD != NULL) { \ + OPENSSL_cleanse(ctx->FIELD->data, ctx->FIELD->length); \ + ASN1_OCTET_STRING_free(ctx->FIELD); \ + } \ + ctx->FIELD = secret; \ + return 1; \ +} + /* Set or clear the password to be used for protecting messages with PBMAC */ -int OSSL_CMP_CTX_set1_secretValue(OSSL_CMP_CTX *ctx, - const unsigned char *sec, int len) -{ - ASN1_OCTET_STRING *secretValue = NULL; +DEFINE_OSSL_set1_octetsecret(OSSL_CMP_CTX, secretValue) - if (ctx == NULL) { - ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT); - return 0; - } - if (ossl_cmp_asn1_octet_string_set1_bytes(&secretValue, sec, len) != 1) - return 0; - if (ctx->secretValue != NULL) { - OPENSSL_cleanse(ctx->secretValue->data, ctx->secretValue->length); - ASN1_OCTET_STRING_free(ctx->secretValue); - } - ctx->secretValue = secretValue; - return 1; -} +/* Set or clear the ssk to be used for protecting messages with KEM-MAC */ +DEFINE_OSSL_set1_octetsecret(ossl_cmp_ctx, kem_ssk) + +/* Set or clear the secret to be used for deriving ssk */ +DEFINE_OSSL_set1_octetsecret(ossl_cmp_ctx, kem_secret) #define DEFINE_OSSL_CMP_CTX_get1_certs(FIELD) \ STACK_OF(X509) *OSSL_CMP_CTX_get1_##FIELD(const OSSL_CMP_CTX *ctx) \ @@ -797,6 +822,7 @@ EVP_PKEY *ossl_cmp_ctx_get0_newPubkey(const OSSL_CMP_CTX *ctx) return ctx->pkey; } + #define DEFINE_set1_ASN1_OCTET_STRING(PREFIX, FIELD) \ int PREFIX##_set1_##FIELD(OSSL_CMP_CTX *ctx, const ASN1_OCTET_STRING *id) \ { \ @@ -819,6 +845,24 @@ DEFINE_set1_ASN1_OCTET_STRING(OSSL_CMP_CTX, senderNonce) /* store the first req sender nonce for verifying delayed delivery */ DEFINE_set1_ASN1_OCTET_STRING(ossl_cmp_ctx, first_senderNonce) +/* Set the kem_recipNonce to be used for the recipNonce in KemOtherInfo */ +DEFINE_set1_ASN1_OCTET_STRING(ossl_cmp_ctx, kem_recipNonce) + +/* get kem_recipNonce from context */ +DEFINE_OSSL_get(ossl_cmp_ctx, kem_recipNonce, ASN1_OCTET_STRING *, NULL) + +/* Set the kem_senderNonce to be used for the senderNonce in KemOtherInfo */ +DEFINE_set1_ASN1_OCTET_STRING(ossl_cmp_ctx, kem_senderNonce) + +/* get kem_senderNonce from context */ +DEFINE_OSSL_get(ossl_cmp_ctx, kem_senderNonce, ASN1_OCTET_STRING *, NULL) + +/* Set the ciphertext to be used in KemOtherInfo */ +DEFINE_set1_ASN1_OCTET_STRING(ossl_cmp_ctx, kem_ct) + +/* get ciphertext from context */ +DEFINE_OSSL_get(ossl_cmp_ctx, kem_ct, ASN1_OCTET_STRING *, NULL) + /* Set the proxy server to use for HTTP(S) connections */ DEFINE_OSSL_CMP_CTX_set1(proxy, char) @@ -973,6 +1017,15 @@ int OSSL_CMP_CTX_set_option(OSSL_CMP_CTX *ctx, int opt, int val) } ctx->revocationReason = val; break; + case OSSL_CMP_OPT_KEM_STATUS: + ctx->kem_status = val; + break; + case OSSL_CMP_OPT_SSK_LEN: + ctx->kem_ssklen = val; + break; + case OSSL_CMP_OPT_KEM_MAC_ALGNID: + ctx->kem_mac = val; + break; default: ERR_raise(ERR_LIB_CMP, CMP_R_INVALID_OPTION); return 0; @@ -1035,6 +1088,12 @@ int OSSL_CMP_CTX_get_option(const OSSL_CMP_CTX *ctx, int opt) return ctx->permitTAInExtraCertsForIR; case OSSL_CMP_OPT_REVOCATION_REASON: return ctx->revocationReason; + case OSSL_CMP_OPT_KEM_STATUS: + return ctx->kem_status; + case OSSL_CMP_OPT_SSK_LEN: + return ctx->kem_ssklen; + case OSSL_CMP_OPT_KEM_MAC_ALGNID: + return ctx->kem_mac; default: ERR_raise(ERR_LIB_CMP, CMP_R_INVALID_OPTION); return -1; diff --git a/crypto/cmp/cmp_genm.c b/crypto/cmp/cmp_genm.c index dad6ef1189713..4ff6cd417bf87 100644 --- a/crypto/cmp/cmp_genm.c +++ b/crypto/cmp/cmp_genm.c @@ -72,9 +72,9 @@ static int ossl_X509_check_all(OSSL_CMP_CTX *ctx, const char *source, return ret; } -static OSSL_CMP_ITAV *get_genm_itav(OSSL_CMP_CTX *ctx, - OSSL_CMP_ITAV *req, /* gets consumed */ - int expected, const char *desc) +OSSL_CMP_ITAV *ossl_cmp_genm_get_itav(OSSL_CMP_CTX *ctx, + OSSL_CMP_ITAV *req, /* gets consumed */ + int expected, const char *desc) { STACK_OF(OSSL_CMP_ITAV) *itavs = NULL; int i, n; @@ -152,7 +152,8 @@ int OSSL_CMP_get1_caCerts(OSSL_CMP_CTX *ctx, STACK_OF(X509) **out) if ((req = OSSL_CMP_ITAV_new_caCerts(NULL)) == NULL) return 0; - if ((itav = get_genm_itav(ctx, req, NID_id_it_caCerts, "caCerts")) == NULL) + if ((itav = ossl_cmp_genm_get_itav(ctx, req, + NID_id_it_caCerts, "caCerts")) == NULL) return 0; if (!OSSL_CMP_ITAV_get0_caCerts(itav, &certs)) goto end; @@ -300,7 +301,8 @@ int OSSL_CMP_get1_rootCaKeyUpdate(OSSL_CMP_CTX *ctx, if ((req = OSSL_CMP_ITAV_new_rootCaCert(oldWithOld)) == NULL) return 0; - itav = get_genm_itav(ctx, req, NID_id_it_rootCaKeyUpdate, "rootCaKeyUpdate"); + itav = ossl_cmp_genm_get_itav(ctx, req, NID_id_it_rootCaKeyUpdate, + "rootCaKeyUpdate"); if (itav == NULL) return 0; diff --git a/crypto/cmp/cmp_hdr.c b/crypto/cmp/cmp_hdr.c index 4358b38873f35..40503f67cfe52 100644 --- a/crypto/cmp/cmp_hdr.c +++ b/crypto/cmp/cmp_hdr.c @@ -269,6 +269,30 @@ int ossl_cmp_hdr_has_implicitConfirm(const OSSL_CMP_PKIHEADER *hdr) return 0; } +/* return -1 for error */ +int ossl_cmp_hdr_has_KemCiphertextInfo(const OSSL_CMP_PKIHEADER *hdr, + OSSL_CMP_ITAV **kemctinfo) +{ + int itavCount; + int i; + OSSL_CMP_ITAV *itav; + + if (!ossl_assert(hdr != NULL && kemctinfo != NULL)) + return -1; + + *kemctinfo = NULL; + itavCount = sk_OSSL_CMP_ITAV_num(hdr->generalInfo); + for (i = 0; i < itavCount; i++) { + itav = sk_OSSL_CMP_ITAV_value(hdr->generalInfo, i); + if (itav != NULL + && OBJ_obj2nid(itav->infoType) == NID_id_it_KemCiphertextInfo) { + *kemctinfo = itav; + return 1; + } + } + return 0; +} + /* * set ctx->transactionID in CMP header * if ctx->transactionID is NULL, a random one is created with 128 bit diff --git a/crypto/cmp/cmp_kem.c b/crypto/cmp/cmp_kem.c new file mode 100644 index 0000000000000..614829d7bfb5d --- /dev/null +++ b/crypto/cmp/cmp_kem.c @@ -0,0 +1,602 @@ +/* + * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. + * Copyright Siemens AG 2023 + * + * 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 + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include "cmp_local.h" +#include +#include +#include +#include +#include +#include "crypto/asn1.h" + +#define RSAKEM_KEYLENGTH 32 + +static void print_buf(const char *title, const unsigned char *buf, + size_t buf_len) +{ + size_t i = 0; + + fprintf(stdout, "%s , len %ld\n", title, buf_len); + for (i = 0; i < buf_len; ++i) + fprintf(stdout, "%02X%s", buf[i], + (i + 1) % 16 == 0 ? "\r\n" : " "); + +} + +/* TODO: look for existing OpenSSL solution */ +static int x509_algor_from_nid_with_md(int nid, X509_ALGOR **palg, + const EVP_MD *md) +{ + X509_ALGOR *algtmp = NULL; + ASN1_STRING *stmp = NULL; + + *palg = NULL; + if (md == NULL) + return 0; + /* need to embed algorithm ID inside another */ + if (!ossl_x509_algor_new_from_md(&algtmp, md)) + goto err; + if (ASN1_item_pack(algtmp, ASN1_ITEM_rptr(X509_ALGOR), &stmp) == NULL) + goto err; + *palg = ossl_X509_ALGOR_from_nid(nid, V_ASN1_SEQUENCE, stmp); + if (*palg == NULL) + goto err; + stmp = NULL; + err: + ASN1_STRING_free(stmp); + X509_ALGOR_free(algtmp); + return *palg != NULL; +} + +X509_ALGOR *ossl_cmp_kem_kdf_algor(const OSSL_CMP_CTX *ctx, int nid_kdf) +{ + X509_ALGOR *alg = NULL; + + if (nid_kdf == NID_hkdfWithSHA256) { + alg = ossl_X509_ALGOR_from_nid(NID_hkdfWithSHA256, + V_ASN1_UNDEF, NULL); + } else if (nid_kdf == NID_id_kdf_kdf2) { + EVP_MD *md = NULL; + + if ((md = EVP_MD_fetch(ctx->libctx, "SHA256", + ctx->propq)) == NULL) + return NULL; + (void)x509_algor_from_nid_with_md(NID_id_kdf_kdf2, &alg, md); + EVP_MD_free(md); + } + + return alg; +} + +static X509_ALGOR *mac_algor(const OSSL_CMP_CTX *ctx) +{ + X509_ALGOR *alg = NULL; + + if (ctx->kem_mac == NID_hmacWithSHA256) + alg = ossl_X509_ALGOR_from_nid(NID_hmacWithSHA256, V_ASN1_UNDEF, NULL); + + return alg; +} + +static int get_pknid(const EVP_PKEY *pkey) +{ + int pknid; + + if (pkey == NULL) + return NID_undef; + pknid = EVP_PKEY_get_base_id(pkey); + if (pknid <= 0) { /* check whether a provider registered a NID */ + const char *typename = EVP_PKEY_get0_type_name(pkey); + + if (typename != NULL) + pknid = OBJ_txt2nid(typename); + } + return pknid; +} + +static X509_ALGOR *kem_algor(OSSL_CMP_CTX *ctx, + const EVP_PKEY *pubkey) +{ + X509_ALGOR *kem = NULL; + int pknid = get_pknid(pubkey); + + if (pknid <= 0) + return NULL; + + switch (pknid) { + case EVP_PKEY_RSA: + /* kem rsa */ + kem = ossl_cmp_rsakem_algor(ctx); + break; + case EVP_PKEY_EC: + case EVP_PKEY_X25519: + case EVP_PKEY_X448: + /* TODO: fall through */ + default: + /* TODO: Check if any other algorithm need parameter */ + kem = ossl_X509_ALGOR_from_nid(pknid, V_ASN1_UNDEF, NULL); + break; + } + return kem; +} + +X509_ALGOR *ossl_cmp_kem_BasedMac_algor(const OSSL_CMP_CTX *ctx) +{ + X509_ALGOR *alg = NULL; + OSSL_CMP_KEMBMPARAMETER *param = NULL; + unsigned char *param_der = NULL; + int param_der_len; + ASN1_STRING *param_str = NULL; + + if ((param = OSSL_CMP_KEMBMPARAMETER_new()) == NULL + || !ossl_cmp_x509_algor_set0(¶m->kdf, + ossl_cmp_kem_kdf_algor(ctx, ctx->kem_kdf)) + || !ossl_cmp_x509_algor_set0(¶m->mac, mac_algor(ctx)) + || !ASN1_INTEGER_set(param->len, ctx->kem_ssklen)) + goto err; + + if ((param_str = ASN1_STRING_new()) == NULL) + goto err; + if ((param_der_len = i2d_OSSL_CMP_KEMBMPARAMETER(param, ¶m_der)) < 0) + goto err; + if (!ASN1_STRING_set(param_str, param_der, param_der_len)) + goto err; + + alg = ossl_X509_ALGOR_from_nid(NID_id_KemBasedMac, + V_ASN1_SEQUENCE, param_str); + + err: + if (alg == NULL) + ASN1_STRING_free(param_str); + OPENSSL_free(param_der); + OSSL_CMP_KEMBMPARAMETER_free(param); + return alg; +} + +/* return -1 in case of error */ +int ossl_cmp_kem_BasedMac_required(OSSL_CMP_CTX *ctx) +{ + uint32_t ex_kusage = 0; + + /* Secret is provided for PBM or unprotected msg is allowed */ + if (ctx == NULL) + return -1; + if (ctx->unprotectedSend + || ctx->secretValue != NULL) + return 0; + + /* Client have certificate for KEM or DS */ + if (ctx->cert != NULL && ctx->pkey != NULL) { + if (!X509_check_private_key(ctx->cert, ctx->pkey)) { + ERR_raise(ERR_LIB_CMP, CMP_R_CERT_AND_KEY_DO_NOT_MATCH); + return -1; + } + ex_kusage = X509_get_key_usage(ctx->cert); + if (ex_kusage == UINT32_MAX) { + ossl_cmp_debug(ctx, + "key usage absent in CMP signer cert"); + } else if (ex_kusage & X509v3_KU_DIGITAL_SIGNATURE) { + return 0; + } else if (ex_kusage & X509v3_KU_KEY_ENCIPHERMENT) { + OSSL_CMP_CTX_set_option(ctx, OSSL_CMP_OPT_KEM_STATUS, + KBM_SSK_USING_CLIENT_KEM_KEY); + return 1; + } + } + /* Server certificate with KEM is known to client */ + if (ctx->srvCert != NULL) { + ex_kusage = X509_get_key_usage(ctx->srvCert); + + if (ex_kusage == UINT32_MAX) { + ossl_cmp_debug(ctx, + "key usage absent in server cert"); + } else if (ex_kusage & X509v3_KU_KEY_ENCIPHERMENT) { + OSSL_CMP_CTX_set_option(ctx, OSSL_CMP_OPT_KEM_STATUS, + KBM_SSK_USING_SERVER_KEM_KEY); + return 1; + } + } + return 0; +} + +static int kem_decapsulation(OSSL_CMP_CTX *ctx, EVP_PKEY *pkey, int is_EC, + const unsigned char *ct, size_t ct_len, + unsigned char **secret, size_t *secret_len) +{ + int ret = 0; + EVP_PKEY_CTX *kem_decaps_ctx; + + if (ctx == NULL || pkey == NULL + || ct == NULL + || secret == NULL || secret_len == NULL) + return 0; + + kem_decaps_ctx = EVP_PKEY_CTX_new_from_pkey(ctx->libctx, + pkey, + ctx->propq); + + if (kem_decaps_ctx == NULL + || EVP_PKEY_decapsulate_init(kem_decaps_ctx, NULL) <= 0 + || (is_EC && EVP_PKEY_CTX_set_kem_op(kem_decaps_ctx, "DHKEM") <= 0) + || EVP_PKEY_decapsulate(kem_decaps_ctx, NULL, secret_len, + ct, ct_len) <= 0) { + goto err; + } + + *secret = OPENSSL_malloc(*secret_len); + if (*secret == NULL) + goto err; + + if (EVP_PKEY_decapsulate(kem_decaps_ctx, + *secret, secret_len, + ct, ct_len) <= 0) { + OPENSSL_free(*secret); + goto err; + } + print_buf("\nct", ct, ct_len); + print_buf("\nsecret", *secret, *secret_len); + ret = 1; + err: + EVP_PKEY_CTX_free(kem_decaps_ctx); + return ret; +} + +static int performKemDecapsulation(OSSL_CMP_CTX *ctx, EVP_PKEY *pkey, + const unsigned char *ct, size_t ct_len, + unsigned char **secret, size_t *secret_len) +{ + int pknid = get_pknid(pkey); + + if (pknid <= 0) + return 0; + + if (pknid == EVP_PKEY_EC + || pknid == EVP_PKEY_X25519 + || pknid == EVP_PKEY_X448) { + return kem_decapsulation(ctx, pkey, 1, ct, ct_len, secret, secret_len); + } else if (pknid == EVP_PKEY_RSA) { + return ossl_cmp_kemrsa_decapsulation(ctx, pkey, + ct, ct_len, secret, secret_len); + } else { + return kem_decapsulation(ctx, pkey, 0, ct, ct_len, secret, secret_len); + } + return 0; +} + +static int derive_ssk_HKDF(OSSL_CMP_CTX *ctx, + unsigned char *key, int keylen, + unsigned char *salt, int saltlen, + unsigned char *info, int infolen, + unsigned char **ssk, int *ssklen) +{ + EVP_KDF *kdf; + EVP_KDF_CTX *kdfctx; + OSSL_PARAM params[5], *p = params; + int rv; + + if (ctx == NULL || ssk == NULL || ssklen == NULL + || key == NULL || info == NULL) + return 0; + + *ssklen = ctx->kem_ssklen; + *ssk = OPENSSL_zalloc(*ssklen); + if (*ssk == NULL + || (kdf = EVP_KDF_fetch(ctx->libctx, "HKDF", ctx->propq)) == NULL) + return 0; + + kdfctx = EVP_KDF_CTX_new(kdf); + EVP_KDF_free(kdf); + if (ctx == NULL) + return 0; + + *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, + "SHA256", 0); + *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, key, + keylen); + *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_INFO, info, + infolen); + + if (salt != NULL) + *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SALT, salt, + saltlen); + + *p = OSSL_PARAM_construct_end(); + rv = EVP_KDF_derive(kdfctx, *ssk, *ssklen, params); + EVP_KDF_CTX_free(kdfctx); + return rv; +} + +int ossl_cmp_kem_derivessk(OSSL_CMP_CTX *ctx, + unsigned char *secret, int secret_len, + unsigned char **out, int *len) +{ + int info_len = 0; + unsigned char *salt = NULL, *info = NULL; + + if (!ossl_cmp_kem_KemOtherInfo_new(ctx, &info, &info_len)) { + return 0; + } + + derive_ssk_HKDF(ctx, secret, secret_len, + salt, sizeof(salt), info, info_len, + out, len); + print_buf("\nsecret", secret, secret_len); + print_buf("\ninfo", info, info_len); + print_buf("\nssk", *out, *len); + + OPENSSL_clear_free(info, info_len); + OPENSSL_free(salt); + return 1; +} + +int ossl_cmp_kem_derivessk_using_kemctinfo(OSSL_CMP_CTX *ctx, + OSSL_CMP_ITAV *KemCiphertextInfo, + EVP_PKEY *pkey) +{ + ASN1_OCTET_STRING *ct; + size_t secret_len = 0; + unsigned char *secret = NULL, *ssk = NULL; + int ssk_len = 0, ret = 0; + + if (ctx == NULL || KemCiphertextInfo == NULL || pkey == NULL) + return 0; + + if (NID_id_it_KemCiphertextInfo != + OBJ_obj2nid(OSSL_CMP_ITAV_get0_type(KemCiphertextInfo))) + return 0; + + ct = KemCiphertextInfo->infoValue.KemCiphertextInfoValue->ct; + if (!ossl_cmp_ctx_set1_kem_ct(ctx, ct)) + return 0; + + if (!performKemDecapsulation(ctx, pkey, + ASN1_STRING_get0_data(ct), + ASN1_STRING_length(ct), + &secret, &secret_len)) + goto err; + + if (!ossl_cmp_kem_derivessk(ctx, secret, secret_len, &ssk, &ssk_len)) + goto err; + + ossl_cmp_ctx_set1_kem_ssk(ctx, ssk, ssk_len); + ret = 1; + err: + OPENSSL_clear_free(secret, secret_len); + OPENSSL_clear_free(ssk, ssk_len); + return ret; +} + +int OSSL_CMP_get_ssk(OSSL_CMP_CTX *ctx) +{ + OSSL_CMP_ITAV *req, *itav; + int ret = 0; + + if (ctx == NULL) { + ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT); + return 0; + } + if ((req = OSSL_CMP_ITAV_create(OBJ_nid2obj(NID_id_it_KemCiphertextInfo), + NULL)) == NULL) + return 0; + if ((itav = ossl_cmp_genm_get_itav(ctx, req, NID_id_it_KemCiphertextInfo, + "KemCiphertextInfo")) == NULL) + return 0; + + if (!ossl_cmp_kem_derivessk_using_kemctinfo(ctx, itav, ctx->pkey)) + goto err; + + OSSL_CMP_CTX_set_option(ctx, OSSL_CMP_OPT_KEM_STATUS, + KBM_SSK_ESTABLISHED_USING_CLIENT); + ret = 1; + err: + OSSL_CMP_ITAV_free(itav); + return ret; +} + +static int kem_encapsulation(OSSL_CMP_CTX *ctx, + const EVP_PKEY *pubkey, + int is_EC, + size_t *secret_len, unsigned char **secret, + size_t *ct_len, unsigned char **ct) +{ + int ret = 0; + EVP_PKEY_CTX *kem_encaps_ctx = NULL; + + if (ctx == NULL || pubkey == NULL + || ct == NULL + || secret == NULL || secret_len == NULL) + return 0; + + kem_encaps_ctx = EVP_PKEY_CTX_new_from_pkey(ctx->libctx, + (EVP_PKEY *)pubkey, + ctx->propq); + + if (kem_encaps_ctx == NULL + || EVP_PKEY_encapsulate_init(kem_encaps_ctx, NULL) <= 0 + || (is_EC && EVP_PKEY_CTX_set_kem_op(kem_encaps_ctx, "DHKEM") <= 0) + || EVP_PKEY_encapsulate(kem_encaps_ctx, NULL, ct_len, + NULL, secret_len) <= 0) { + goto err; + } + + *ct = OPENSSL_malloc(*ct_len); + if (*ct == NULL) + goto err; + + *secret = OPENSSL_malloc(*secret_len); + if (*secret == NULL) { + OPENSSL_free(*ct); + goto err; + } + + if (EVP_PKEY_encapsulate(kem_encaps_ctx, *ct, ct_len, + *secret, secret_len) <= 0) { + OPENSSL_free(*ct); + OPENSSL_free(*secret); + goto err; + } + print_buf("\nct", *ct, *ct_len); + print_buf("\nsecret", *secret, *secret_len); + ret = 1; + err: + EVP_PKEY_CTX_free(kem_encaps_ctx); + return ret; +} + +static int performKemEncapsulation(OSSL_CMP_CTX *ctx, + const EVP_PKEY *pubkey, + size_t *secret_len, unsigned char **secret, + size_t *ct_len, unsigned char **ct) +{ + int pknid; + + if (secret_len == NULL || secret == NULL + || ct_len == NULL || ct == NULL + || pubkey == NULL) + return 0; + + pknid = get_pknid(pubkey); + if (pknid <= 0) + return 0; + + if (pknid == EVP_PKEY_EC + || pknid == EVP_PKEY_X25519 + || pknid == EVP_PKEY_X448) { + return kem_encapsulation(ctx, pubkey, 1, secret_len, + secret, ct_len, ct); + } else if (pknid == EVP_PKEY_RSA) { + return ossl_cmp_kemrsa_encapsulation(ctx, pubkey, secret_len, + secret, ct_len, ct); + } else { + return kem_encapsulation(ctx, pubkey, 0, secret_len, + secret, ct_len, ct); + } +} + +OSSL_CMP_ITAV *ossl_cmp_kem_get_KemCiphertext(OSSL_CMP_CTX *ctx, + const EVP_PKEY *pubkey) +{ + size_t secret_len, ct_len; + unsigned char *secret = NULL, *ct = NULL; + OSSL_CMP_ITAV *kem_itav = NULL; + ASN1_OCTET_STRING *asn1ct = NULL; + X509_ALGOR *kem_algo; + + if (ctx == NULL || pubkey == NULL) + return NULL; + + if (!performKemEncapsulation(ctx, pubkey, &secret_len, &secret, + &ct_len, &ct)) + return NULL; + + if (!ossl_cmp_ctx_set1_kem_secret(ctx, secret, secret_len)) + goto err; + if (!ossl_cmp_asn1_octet_string_set1_bytes(&asn1ct, ct, ct_len)) + goto err; + if (!ossl_cmp_ctx_set1_kem_ct(ctx, asn1ct)) + goto err; + + kem_algo = kem_algor(ctx, pubkey); + kem_itav = ossl_cmp_itav_new_KemCiphertext(kem_algo, + ct, ct_len); + if (kem_itav == NULL) + goto err; + + err: + if (secret != NULL) + OPENSSL_clear_free(secret, secret_len); + if (ct != NULL) + OPENSSL_clear_free(ct, ct_len); + ASN1_OCTET_STRING_free(asn1ct); + return kem_itav; +} + +int ossl_cmp_kem_get_ss_using_srvcert(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg) +{ + OSSL_CMP_ITAV *kem_itav = NULL; + int ret = 0; + EVP_PKEY *pubkey = X509_get0_pubkey(ctx->srvCert); + + if ((kem_itav = ossl_cmp_kem_get_KemCiphertext(ctx, pubkey)) + == NULL) + goto err; + + if (msg->header == NULL + || !ossl_cmp_hdr_generalInfo_push0_item(msg->header, kem_itav)) { + OSSL_CMP_ITAV_free(kem_itav); + goto err; + } + + ossl_cmp_ctx_set1_kem_senderNonce(ctx, + msg->header->senderNonce); + ossl_cmp_ctx_set1_kem_recipNonce(ctx, + msg->header->recipNonce); + + OSSL_CMP_CTX_set_option(ctx, OSSL_CMP_OPT_KEM_STATUS, + KBM_SSK_USING_SERVER_KEM_KEY_1); + ret = 1; + err: + return ret; +} + +static OSSL_CMP_KEMBMPARAMETER *decode_KEMBMPARAMETER(X509_ALGOR *protectionAlg) +{ + const ASN1_OBJECT *algorOID = NULL; + const void *ppval = NULL; + int pptype = 0; + ASN1_STRING *param_str = NULL; + const unsigned char *param_str_uc = NULL; + + X509_ALGOR_get0(&algorOID, &pptype, &ppval, protectionAlg); + if (NID_id_KemBasedMac != OBJ_obj2nid(algorOID) + || ppval == NULL) + return NULL; + + param_str = (ASN1_STRING *)ppval; + param_str_uc = param_str->data; + return d2i_OSSL_CMP_KEMBMPARAMETER(NULL, ¶m_str_uc, + param_str->length); +} + +int ossl_cmp_kem_derive_ssk_using_srvcert(OSSL_CMP_CTX *ctx, + const OSSL_CMP_MSG *msg) +{ + unsigned char *ssk; + int len; + OSSL_CMP_KEMBMPARAMETER *param = NULL; + + if (ctx == NULL || msg == NULL) + return 0; + + param = decode_KEMBMPARAMETER(msg->header->protectionAlg); + if (param == NULL) { + ERR_raise(ERR_LIB_CMP, CMP_R_WRONG_ALGORITHM_OID); + return 0; + } + ctx->kem_kdf = OBJ_obj2nid(param->kdf->algorithm); + ctx->kem_mac = OBJ_obj2nid(param->mac->algorithm); + ctx->kem_ssklen = ASN1_INTEGER_get(param->len); + + if (ctx->kem_status != KBM_SSK_USING_SERVER_KEM_KEY_1 + || ctx->kem_secret == NULL + || !ossl_cmp_kem_derivessk(ctx, + (unsigned char *) + ASN1_STRING_get0_data(ctx->kem_secret), + ASN1_STRING_length(ctx->kem_secret), + &ssk, &len)) + return 0; + ossl_cmp_ctx_set1_kem_ssk(ctx, ssk, len); + OSSL_CMP_CTX_set_option(ctx, + OSSL_CMP_OPT_KEM_STATUS, + KBM_SSK_ESTABLISHED_USING_SERVER); + OPENSSL_free(ssk); + OSSL_CMP_KEMBMPARAMETER_free(param); + return 1; +} diff --git a/crypto/cmp/cmp_kemrsa.c b/crypto/cmp/cmp_kemrsa.c new file mode 100644 index 0000000000000..6e46a21f14d0f --- /dev/null +++ b/crypto/cmp/cmp_kemrsa.c @@ -0,0 +1,199 @@ +/* + * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. + * Copyright Siemens AG 2023 + * + * 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 + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ +#include "cmp_local.h" +#include "crypto/asn1.h" +#include +#include +#include +#include +#include + +#define RSAKEM_KEYLENGTH 32 + +/* using X963KDF without info */ +static int kdf2(OSSL_CMP_CTX *ctx, + unsigned char *secret, size_t secret_len, + unsigned char *out, int out_len) +{ + EVP_KDF *kdf; + EVP_KDF_CTX *kctx; + OSSL_PARAM params[4], *p = params; + + if (out == NULL) + return 0; + + kdf = EVP_KDF_fetch(ctx->libctx, "X963KDF", ctx->propq); + kctx = EVP_KDF_CTX_new(kdf); + EVP_KDF_free(kdf); + + *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, + SN_sha256, strlen(SN_sha256)); + *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SECRET, + secret, (size_t)secret_len); + *p = OSSL_PARAM_construct_end(); + if (EVP_KDF_derive(kctx, out, out_len, params) <= 0) { + return 0; + } + EVP_KDF_CTX_free(kctx); + return 1; +} + +X509_ALGOR *ossl_cmp_rsakem_algor(OSSL_CMP_CTX *ctx) +{ + X509_ALGOR *kemrsa_algo = NULL; + OSSL_CMP_RSAKEMPARAMETERS *param = NULL; + ASN1_STRING *stmp = NULL; + + if ((param = OSSL_CMP_RSAKEMPARAMETERS_new()) == NULL + || !ossl_cmp_x509_algor_set0(¶m->KeyDerivationFunction, + ossl_cmp_kem_kdf_algor(ctx, + NID_id_kdf_kdf2)) + || !ASN1_INTEGER_set(param->KeyLength, RSAKEM_KEYLENGTH)) + goto err; + + if (ASN1_item_pack(param, ASN1_ITEM_rptr(OSSL_CMP_RSAKEMPARAMETERS), + &stmp) == NULL) + goto err; + kemrsa_algo = ossl_X509_ALGOR_from_nid(NID_id_kem_rsa, + V_ASN1_SEQUENCE, stmp); + if (kemrsa_algo == NULL) + goto err; + stmp = NULL; + err: + OSSL_CMP_RSAKEMPARAMETERS_free(param); + ASN1_STRING_free(stmp); + return kemrsa_algo; +} + +int ossl_cmp_kemrsa_decapsulation(OSSL_CMP_CTX *ctx, EVP_PKEY *pkey, + const unsigned char *ct, size_t ct_len, + unsigned char **secret, size_t *secret_len) +{ + int ret = 0; + size_t sec_len; + unsigned char *sec; + EVP_PKEY_CTX *kem_decaps_ctx; + + if (ctx == NULL || pkey == NULL + || ct == NULL + || secret == NULL || secret_len == NULL) + return 0; + + if (EVP_PKEY_get_base_id(pkey) != EVP_PKEY_RSA) + return 0; + + kem_decaps_ctx = EVP_PKEY_CTX_new_from_pkey(ctx->libctx, + pkey, + ctx->propq); + + if (kem_decaps_ctx == NULL + || EVP_PKEY_decapsulate_init(kem_decaps_ctx, NULL) <= 0 + || EVP_PKEY_CTX_set_kem_op(kem_decaps_ctx, "RSASVE") <= 0 + || EVP_PKEY_decapsulate(kem_decaps_ctx, NULL, &sec_len, + ct, ct_len) <= 0) { + goto err; + } + + sec = OPENSSL_malloc(sec_len); + if (sec == NULL) + goto err; + + if (EVP_PKEY_decapsulate(kem_decaps_ctx, + sec, &sec_len, + ct, ct_len) <= 0) { + OPENSSL_free(sec); + goto err; + } + + *secret_len = RSAKEM_KEYLENGTH; + *secret = OPENSSL_malloc(*secret_len); + if (*secret == NULL) { + OPENSSL_clear_free(sec, sec_len); + goto err; + } + + if (!kdf2(ctx, sec, sec_len, *secret, *secret_len)) { + OPENSSL_clear_free(sec, sec_len); + OPENSSL_clear_free(*secret, *secret_len); + goto err; + } + OPENSSL_clear_free(sec, sec_len); + ret = 1; + err: + EVP_PKEY_CTX_free(kem_decaps_ctx); + return ret; +} + +int ossl_cmp_kemrsa_encapsulation(OSSL_CMP_CTX *ctx, + const EVP_PKEY *pubkey, + size_t *secret_len, unsigned char **secret, + size_t *ct_len, unsigned char **ct) +{ + int ret = 0; + size_t sec_len; + unsigned char *sec; + EVP_PKEY_CTX *kem_encaps_ctx; + + if (ctx == NULL || pubkey == NULL + || ct == NULL + || secret == NULL || secret_len == NULL) + return 0; + + if (EVP_PKEY_get_base_id(pubkey) != EVP_PKEY_RSA) + return 0; + + kem_encaps_ctx = EVP_PKEY_CTX_new_from_pkey(ctx->libctx, + (EVP_PKEY *)pubkey, + ctx->propq); + + if (kem_encaps_ctx == NULL + || EVP_PKEY_encapsulate_init(kem_encaps_ctx, NULL) <= 0 + || EVP_PKEY_CTX_set_kem_op(kem_encaps_ctx, "RSASVE") <= 0 + || EVP_PKEY_encapsulate(kem_encaps_ctx, NULL, ct_len, + NULL, &sec_len) <= 0) { + goto err; + } + + *ct = OPENSSL_malloc(*ct_len); + if (*ct == NULL) + goto err; + + sec = OPENSSL_malloc(sec_len); + if (sec == NULL) { + OPENSSL_free(*ct); + goto err; + } + + if (EVP_PKEY_encapsulate(kem_encaps_ctx, *ct, ct_len, + sec, &sec_len) <= 0) { + OPENSSL_free(*ct); + OPENSSL_free(sec); + goto err; + } + + *secret_len = RSAKEM_KEYLENGTH; + *secret = OPENSSL_malloc(*secret_len); + if (*secret == NULL) { + OPENSSL_clear_free(sec, sec_len); + goto err; + } + + if (!kdf2(ctx, sec, sec_len, *secret, *secret_len)) { + OPENSSL_clear_free(sec, sec_len); + OPENSSL_clear_free(*secret, *secret_len); + OPENSSL_clear_free(*ct, *ct_len); + goto err; + } + OPENSSL_clear_free(sec, sec_len); + ret = 1; + err: + EVP_PKEY_CTX_free(kem_encaps_ctx); + return ret; +} diff --git a/crypto/cmp/cmp_local.h b/crypto/cmp/cmp_local.h index edec8808a78de..76c3d80cd50e7 100644 --- a/crypto/cmp/cmp_local.h +++ b/crypto/cmp/cmp_local.h @@ -136,6 +136,17 @@ struct ossl_cmp_ctx_st { /* certificate confirmation */ OSSL_CMP_certConf_cb_t certConf_cb; /* callback for app checking new cert */ void *certConf_cb_arg; /* allows to store an argument individual to cb */ + + /* Key Encapsulation */ + int kem_status; /* KEM status */ + ASN1_OCTET_STRING *kem_senderNonce; /* senderNonce for kemOtherInfo */ + ASN1_OCTET_STRING *kem_recipNonce; /* recipNonce for kemOtherInfo */ + ASN1_OCTET_STRING *kem_ct; /* ciphertext for kemOtherInfo */ + int kem_ssklen; /* shared secret key length, default 32 */ + ASN1_OCTET_STRING *kem_ssk; /* TODO: can use secretValue field */ + ASN1_OCTET_STRING *kem_secret; /* secret to be used with KDF */ + int kem_mac; /* TODO: cam use pbm_mac field , default to HMAC-SHA256 */ + int kem_kdf; /* Key derivation function */ } /* OSSL_CMP_CTX */; /* @@ -211,6 +222,68 @@ DECLARE_ASN1_FUNCTIONS(OSSL_CMP_CAKEYUPDANNCONTENT) typedef struct ossl_cmp_rootcakeyupdate_st OSSL_CMP_ROOTCAKEYUPDATE; DECLARE_ASN1_FUNCTIONS(OSSL_CMP_ROOTCAKEYUPDATE) +/* + * RsaKemParameters ::= SEQUENCE { + * keyDerivationFunction KeyDerivationFunction, + * keyLength KeyLength + * } + * KeyDerivationFunction ::= + * AlgorithmIdentifier {{KDFAlgorithms}} + * KeyLength ::= INTEGER (1..MAX) + */ +typedef struct ossl_cmp_RsaKemParameters_st { + X509_ALGOR *KeyDerivationFunction; + ASN1_INTEGER *KeyLength; +} OSSL_CMP_RSAKEMPARAMETERS; +DECLARE_ASN1_FUNCTIONS(OSSL_CMP_RSAKEMPARAMETERS) +/* + * KemCiphertextInfoValue :== KemCiphertextInfo + * KemCiphertextInfo ::= SEQUENCE { + * kem AlgorithmIdentifier{KEM-ALGORITHM, {...}}, + * ct OCTET STRING} + */ +typedef struct ossl_cmp_KemCiphertextInfo_st { + X509_ALGOR *kem; + ASN1_OCTET_STRING *ct; +} OSSL_CMP_KEMCIPHERTEXTINFO; +DECLARE_ASN1_FUNCTIONS(OSSL_CMP_KEMCIPHERTEXTINFO) + +/* + * KemOtherInfo ::= SEQUENCE { + * staticString PKIFreeText, + * transactionID [0] OCTET STRING OPTIONAL, + * senderNonce [1] OCTET STRING OPTIONAL, + * recipNonce [2] OCTET STRING OPTIONAL, + * len INTEGER (1..MAX), + * mac AlgorithmIdentifier{MAC-ALGORITHM, {...}} + * ct OCTET STRING + * } + */ +struct ossl_cmp_KemOtherInfo_st { + OSSL_CMP_PKIFREETEXT *staticString; + ASN1_OCTET_STRING *transactionID; + ASN1_OCTET_STRING *senderNonce; + ASN1_OCTET_STRING *recipNonce; + ASN1_INTEGER *len; + X509_ALGOR *mac; + ASN1_OCTET_STRING *ct; +} /* OSSL_CMP_KEMOTHERINFO */; +DECLARE_ASN1_FUNCTIONS(OSSL_CMP_KEMOTHERINFO) + +/* + * KemBMParameter ::= SEQUENCE { + * kdf AlgorithmIdentifier{KEY-DERIVATION, {...}}, + * len INTEGER (1..MAX), + * mac AlgorithmIdentifier{MAC-ALGORITHM, {...}} + * } + */ +typedef struct ossl_cmp_KemBMParameter_st { + X509_ALGOR *kdf; + ASN1_INTEGER *len; + X509_ALGOR *mac; +} OSSL_CMP_KEMBMPARAMETER; +DECLARE_ASN1_FUNCTIONS(OSSL_CMP_KEMBMPARAMETER) + /*- * declared already here as it will be used in OSSL_CMP_MSG (nested) and * infoType and infoValue @@ -264,6 +337,8 @@ struct ossl_cmp_itav_st { X509 *rootCaCert; /* NID_id_it_rootCaKeyUpdate - Root CA Certificate Update */ OSSL_CMP_ROOTCAKEYUPDATE *rootCaKeyUpdate; + /* NID_id_it_KemCiphertextInfo - KEM ciphertext */ + OSSL_CMP_KEMCIPHERTEXTINFO *KemCiphertextInfoValue; /* this is to be used for so far undeclared objects */ ASN1_TYPE *other; } infoValue; @@ -767,6 +842,11 @@ DECLARE_ASN1_FUNCTIONS(OSSL_CMP_ROOTCAKEYUPDATE) /* from cmp_asn.c */ int ossl_cmp_asn1_get_int(const ASN1_INTEGER *a); +OSSL_CMP_ITAV *ossl_cmp_itav_new_KemCiphertext(X509_ALGOR *kem, + unsigned char *in_ct, + int len); +int ossl_cmp_kem_KemOtherInfo_new(OSSL_CMP_CTX *ctx, + unsigned char **out, int *len); /* from cmp_util.c */ const char *ossl_cmp_log_parse_metadata(const char *buf, @@ -784,8 +864,15 @@ int ossl_cmp_asn1_octet_string_set1(ASN1_OCTET_STRING **tgt, const ASN1_OCTET_STRING *src); int ossl_cmp_asn1_octet_string_set1_bytes(ASN1_OCTET_STRING **tgt, const unsigned char *bytes, int len); +int ossl_cmp_x509_algor_set0(X509_ALGOR **tgt, X509_ALGOR *src); /* from cmp_ctx.c */ +# define KBM_SSK_USING_CLIENT_KEM_KEY 1 +# define KBM_SSK_USING_SERVER_KEM_KEY 2 +# define KBM_SSK_USING_SERVER_KEM_KEY_1 3 +# define KBM_SSK_ESTABLISHED_USING_CLIENT 4 +# define KBM_SSK_ESTABLISHED_USING_SERVER 5 + int ossl_cmp_print_log(OSSL_CMP_severity level, const OSSL_CMP_CTX *ctx, const char *func, const char *file, int line, const char *level_str, const char *format, ...); @@ -824,9 +911,23 @@ int ossl_cmp_ctx_set1_extraCertsIn(OSSL_CMP_CTX *ctx, STACK_OF(X509) *extraCertsIn); int ossl_cmp_ctx_set1_recipNonce(OSSL_CMP_CTX *ctx, const ASN1_OCTET_STRING *nonce); +int ossl_cmp_ctx_set1_kem_recipNonce(OSSL_CMP_CTX *ctx, + const ASN1_OCTET_STRING *nonce); +int ossl_cmp_ctx_set1_kem_senderNonce(OSSL_CMP_CTX *ctx, + const ASN1_OCTET_STRING *nonce); +int ossl_cmp_ctx_set1_kem_ct(OSSL_CMP_CTX *ctx, + const ASN1_OCTET_STRING *ct); EVP_PKEY *ossl_cmp_ctx_get0_newPubkey(const OSSL_CMP_CTX *ctx); int ossl_cmp_ctx_set1_first_senderNonce(OSSL_CMP_CTX *ctx, const ASN1_OCTET_STRING *nonce); +ASN1_OCTET_STRING *ossl_cmp_ctx_get0_transactionID(const OSSL_CMP_CTX *ctx); +ASN1_OCTET_STRING *ossl_cmp_ctx_get_kem_recipNonce(const OSSL_CMP_CTX *ctx); +ASN1_OCTET_STRING *ossl_cmp_ctx_get_kem_senderNonce(const OSSL_CMP_CTX *ctx); +ASN1_OCTET_STRING *ossl_cmp_ctx_get_kem_ct(const OSSL_CMP_CTX *ctx); +int ossl_cmp_ctx_set1_kem_ssk(OSSL_CMP_CTX *ctx, const unsigned char *sec, + int len); +int ossl_cmp_ctx_set1_kem_secret(OSSL_CMP_CTX *ctx, + const unsigned char *sec, int len); /* from cmp_status.c */ int ossl_cmp_pkisi_get_status(const OSSL_CMP_PKISI *si); @@ -854,6 +955,8 @@ int ossl_cmp_hdr_generalInfo_push1_items(OSSL_CMP_PKIHEADER *hdr, const STACK_OF(OSSL_CMP_ITAV) *itavs); int ossl_cmp_hdr_set_implicitConfirm(OSSL_CMP_PKIHEADER *hdr); int ossl_cmp_hdr_has_implicitConfirm(const OSSL_CMP_PKIHEADER *hdr); +int ossl_cmp_hdr_has_KemCiphertextInfo(const OSSL_CMP_PKIHEADER *hdr, + OSSL_CMP_ITAV **kemctinfo); # define OSSL_CMP_TRANSACTIONID_LENGTH 16 # define OSSL_CMP_SENDERNONCE_LENGTH 16 int ossl_cmp_hdr_set_transactionID(OSSL_CMP_CTX *ctx, OSSL_CMP_PKIHEADER *hdr); @@ -970,4 +1073,35 @@ int ossl_cmp_exchange_certConf(OSSL_CMP_CTX *ctx, int certReqId, int ossl_cmp_exchange_error(OSSL_CMP_CTX *ctx, int status, int fail_info, const char *txt, int errorCode, const char *detail); +/* from cmp_kem.c */ +X509_ALGOR *ossl_cmp_kem_BasedMac_algor(const OSSL_CMP_CTX *ctx); +X509_ALGOR *ossl_cmp_kem_kdf_algor(const OSSL_CMP_CTX *ctx, int nid_kdf); +int ossl_cmp_kem_BasedMac_required(OSSL_CMP_CTX *ctx); +int ossl_cmp_kem_derivessk(OSSL_CMP_CTX *ctx, + unsigned char *secret, int secret_len, + unsigned char **out, int *len); +int ossl_cmp_kem_derivessk_using_kemctinfo(OSSL_CMP_CTX *ctx, + OSSL_CMP_ITAV *KemCiphertextInfo, + EVP_PKEY *pkey); +int ossl_cmp_kem_get_ss_using_srvcert(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg); +int ossl_cmp_kem_derive_ssk_using_srvcert(OSSL_CMP_CTX *ctx, + const OSSL_CMP_MSG *msg); +OSSL_CMP_ITAV *ossl_cmp_kem_get_KemCiphertext(OSSL_CMP_CTX *ctx, + const EVP_PKEY *pubkey); + +/* from cmp_kemrsa.c */ +X509_ALGOR *ossl_cmp_rsakem_algor(OSSL_CMP_CTX *ctx); +int ossl_cmp_kemrsa_decapsulation(OSSL_CMP_CTX *ctx, EVP_PKEY *pkey, + const unsigned char *ct, size_t ct_len, + unsigned char **secret, size_t *secret_len); +int ossl_cmp_kemrsa_encapsulation(OSSL_CMP_CTX *ctx, + const EVP_PKEY *pubkey, + size_t *secret_len, unsigned char **secret, + size_t *ct_len, unsigned char **ct); + +/* from cmp_genm.c */ +OSSL_CMP_ITAV *ossl_cmp_genm_get_itav(OSSL_CMP_CTX *ctx, + OSSL_CMP_ITAV *req, /* gets consumed */ + int expected, const char *desc); + #endif /* !defined(OSSL_CRYPTO_CMP_LOCAL_H) */ diff --git a/crypto/cmp/cmp_msg.c b/crypto/cmp/cmp_msg.c index a7e22d874ade5..56bf31257045f 100644 --- a/crypto/cmp/cmp_msg.c +++ b/crypto/cmp/cmp_msg.c @@ -100,6 +100,14 @@ int OSSL_CMP_MSG_get_bodytype(const OSSL_CMP_MSG *msg) return msg->body->type; } +STACK_OF(X509)* OSSL_CMP_MSG_get_extraCerts(const OSSL_CMP_MSG *msg) +{ + if (!ossl_assert(msg != NULL)) + return NULL; + + return msg->extraCerts; +} + /* Add an extension to the referenced extension stack, which may be NULL */ static int add1_extension(X509_EXTENSIONS **pexts, int nid, int crit, void *ex) { diff --git a/crypto/cmp/cmp_protect.c b/crypto/cmp/cmp_protect.c index f59fee44ec26c..3cd4793cbb05a 100644 --- a/crypto/cmp/cmp_protect.c +++ b/crypto/cmp/cmp_protect.c @@ -18,6 +18,7 @@ #include #include #include +#include "internal/sizes.h" /* * This function is also used by the internal verify_PBMAC() in cmp_vfy.c. @@ -37,7 +38,7 @@ ASN1_BIT_STRING *ossl_cmp_calc_protection(const OSSL_CMP_CTX *ctx, OSSL_CMP_PROTECTEDPART prot_part; const ASN1_OBJECT *algorOID = NULL; const void *ppval = NULL; - int pptype = 0; + int pptype = 0, nid; if (!ossl_assert(ctx != NULL && msg != NULL)) return NULL; @@ -52,17 +53,21 @@ ASN1_BIT_STRING *ossl_cmp_calc_protection(const OSSL_CMP_CTX *ctx, } X509_ALGOR_get0(&algorOID, &pptype, &ppval, msg->header->protectionAlg); - if (OBJ_obj2nid(algorOID) == NID_id_PasswordBasedMAC) { - int len; - size_t prot_part_der_len; + nid = OBJ_obj2nid(algorOID); + if (nid == NID_id_PasswordBasedMAC + || nid == NID_id_KemBasedMac) { + int len, hmac_md_nid; + size_t prot_part_der_len, sig_len; unsigned char *prot_part_der = NULL; - size_t sig_len; unsigned char *protection = NULL; + char hmac_mdname[OSSL_MAX_NAME_SIZE]; OSSL_CRMF_PBMPARAMETER *pbm = NULL; - ASN1_STRING *pbm_str = NULL; - const unsigned char *pbm_str_uc = NULL; + OSSL_CMP_KEMBMPARAMETER *kbm = NULL; + ASN1_STRING *param_str = NULL; + const unsigned char *param_str_uc = NULL; - if (ctx->secretValue == NULL) { + if (ctx->secretValue == NULL + && ctx->kem_ssk == NULL) { ERR_raise(ERR_LIB_CMP, CMP_R_MISSING_PBM_SECRET); return NULL; } @@ -70,6 +75,8 @@ ASN1_BIT_STRING *ossl_cmp_calc_protection(const OSSL_CMP_CTX *ctx, ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_CALCULATING_PROTECTION); return NULL; } + param_str = (ASN1_STRING *)ppval; + param_str_uc = param_str->data; len = i2d_OSSL_CMP_PROTECTEDPART(&prot_part, &prot_part_der); if (len < 0 || prot_part_der == NULL) { @@ -78,19 +85,47 @@ ASN1_BIT_STRING *ossl_cmp_calc_protection(const OSSL_CMP_CTX *ctx, } prot_part_der_len = (size_t)len; - pbm_str = (ASN1_STRING *)ppval; - pbm_str_uc = pbm_str->data; - pbm = d2i_OSSL_CRMF_PBMPARAMETER(NULL, &pbm_str_uc, pbm_str->length); - if (pbm == NULL) { - ERR_raise(ERR_LIB_CMP, CMP_R_WRONG_ALGORITHM_OID); - goto end; - } + if (nid == NID_id_PasswordBasedMAC) { - if (!OSSL_CRMF_pbm_new(ctx->libctx, ctx->propq, - pbm, prot_part_der, prot_part_der_len, - ctx->secretValue->data, ctx->secretValue->length, - &protection, &sig_len)) - goto end; + pbm = d2i_OSSL_CRMF_PBMPARAMETER(NULL, ¶m_str_uc, + param_str->length); + if (pbm == NULL) { + ERR_raise(ERR_LIB_CMP, CMP_R_WRONG_ALGORITHM_OID); + goto end; + } + + if (!OSSL_CRMF_pbm_new(ctx->libctx, ctx->propq, + pbm, prot_part_der, prot_part_der_len, + ctx->secretValue->data, + ctx->secretValue->length, + &protection, &sig_len)) + goto end; + } else { + int mac_nid; + + kbm = d2i_OSSL_CMP_KEMBMPARAMETER(NULL, ¶m_str_uc, + param_str->length); + if (kbm == NULL) { + ERR_raise(ERR_LIB_CMP, CMP_R_WRONG_ALGORITHM_OID); + goto end; + } + /* TODO - set digest name depeding on mac algorithm */ + mac_nid = OBJ_obj2nid(kbm->mac->algorithm); + + if (!EVP_PBE_find(EVP_PBE_TYPE_PRF, mac_nid, NULL, &hmac_md_nid, NULL) + || OBJ_obj2txt(hmac_mdname, sizeof(hmac_mdname), + OBJ_nid2obj(hmac_md_nid), 0) <= 0) { + ERR_raise(ERR_LIB_CMP, CMP_R_UNSUPPORTED_ALGORITHM); + goto end; + } + protection = EVP_Q_mac(ctx->libctx, "HMAC", ctx->propq, + hmac_mdname, NULL, + ctx->kem_ssk->data, ctx->kem_ssk->length, + prot_part_der, prot_part_der_len, + NULL, 0, &sig_len); + if (protection == NULL) + goto end; + } if ((prot = ASN1_BIT_STRING_new()) == NULL) goto end; @@ -102,9 +137,11 @@ ASN1_BIT_STRING *ossl_cmp_calc_protection(const OSSL_CMP_CTX *ctx, } end: OSSL_CRMF_PBMPARAMETER_free(pbm); + OSSL_CMP_KEMBMPARAMETER_free(kbm); OPENSSL_free(protection); OPENSSL_free(prot_part_der); return prot; + } else { const EVP_MD *md = ctx->digest; char name[80] = ""; @@ -138,6 +175,7 @@ int ossl_cmp_msg_add_extraCerts(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg) /* Add first ctx->cert and its chain if using signature-based protection */ if (!ctx->unprotectedSend && ctx->secretValue == NULL + && ctx->kem_status != KBM_SSK_ESTABLISHED_USING_CLIENT && ctx->cert != NULL && ctx->pkey != NULL) { int prepend = X509_ADD_FLAG_UP_REF | X509_ADD_FLAG_NO_DUP | X509_ADD_FLAG_PREPEND | X509_ADD_FLAG_NO_SS; @@ -240,7 +278,13 @@ int ossl_cmp_msg_protect(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg) ASN1_BIT_STRING_free(msg->protection); msg->protection = NULL; - if (ctx->unprotectedSend) { + if (ctx->kem_status == KBM_SSK_USING_SERVER_KEM_KEY) { + if (!ossl_cmp_kem_get_ss_using_srvcert(ctx, msg)) + goto err; + } + + if (ctx->unprotectedSend + || ctx->kem_status == KBM_SSK_USING_CLIENT_KEM_KEY) { if (!set_senderKID(ctx, msg, NULL)) goto err; } else if (ctx->secretValue != NULL) { @@ -255,6 +299,15 @@ int ossl_cmp_msg_protect(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg) * while not needed to validate the protection certificate, * the option to do this might be handy for certain use cases */ + } else if (ctx->kem_ssk != NULL + && ctx->kem_status == KBM_SSK_ESTABLISHED_USING_CLIENT) { + /* use KemBasedMac */ + if ((msg->header->protectionAlg = ossl_cmp_kem_BasedMac_algor(ctx)) + == NULL) + goto err; + if (!set_senderKID(ctx, msg, NULL)) + goto err; + } else if (ctx->cert != NULL && ctx->pkey != NULL) { /* use MSG_SIG_ALG according to 5.1.3.3 if client cert and key given */ @@ -281,6 +334,7 @@ int ossl_cmp_msg_protect(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg) } if (!ctx->unprotectedSend /* protect according to msg->header->protectionAlg partly set above */ + && ctx->kem_status != KBM_SSK_USING_CLIENT_KEM_KEY && ((msg->protection = ossl_cmp_calc_protection(ctx, msg)) == NULL)) goto err; diff --git a/crypto/cmp/cmp_server.c b/crypto/cmp/cmp_server.c index 53c41bc96eeb8..a002faa8c2731 100644 --- a/crypto/cmp/cmp_server.c +++ b/crypto/cmp/cmp_server.c @@ -272,7 +272,26 @@ static OSSL_CMP_MSG *process_cert_request(OSSL_CMP_SRV_CTX *srv_ctx, if (si == NULL) return NULL; } else { + OSSL_CMP_ITAV *kemctinfo = NULL; OSSL_CMP_PKIHEADER *hdr = OSSL_CMP_MSG_get0_header(req); + int ret; + + ret = ossl_cmp_hdr_has_KemCiphertextInfo(hdr, &kemctinfo); + if (ret == -1) { + goto err; + } else if (ret == 1) { + ossl_cmp_ctx_set1_kem_senderNonce(srv_ctx->ctx, + hdr->senderNonce); + ossl_cmp_ctx_set1_kem_recipNonce(srv_ctx->ctx, + hdr->recipNonce); + if (!ossl_cmp_kem_derivessk_using_kemctinfo(srv_ctx->ctx, kemctinfo, + srv_ctx->ctx->pkey)) { + ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_DERIVING_KBM_SSK); + goto err; + } + OSSL_CMP_CTX_set_option(srv_ctx->ctx, OSSL_CMP_OPT_KEM_STATUS, + KBM_SSK_ESTABLISHED_USING_CLIENT); + } si = srv_ctx->process_cert_request(srv_ctx, req, certReqId, crm, p10cr, &certOut, &chainOut, &caPubs); @@ -348,6 +367,27 @@ static OSSL_CMP_MSG *process_rr(OSSL_CMP_SRV_CTX *srv_ctx, return msg; } +OSSL_CMP_ITAV *OSSL_CMP_SRV_kem_get_ss(OSSL_CMP_SRV_CTX *srv_ctx, + const EVP_PKEY *pubkey) +{ + OSSL_CMP_ITAV *kem_itav = NULL; + OSSL_CMP_CTX *ctx; + + if (srv_ctx == NULL || pubkey == NULL) + return NULL; + + ctx = OSSL_CMP_SRV_CTX_get0_cmp_ctx(srv_ctx); + if ((kem_itav = ossl_cmp_kem_get_KemCiphertext(ctx, pubkey)) + == NULL) + return NULL; + + OSSL_CMP_CTX_set_option(ctx, + OSSL_CMP_OPT_KEM_STATUS, + KBM_SSK_USING_SERVER_KEM_KEY_1); + + return kem_itav; + +} /* * Processes genm and creates a genp message mirroring the contents of the * incoming message @@ -365,6 +405,14 @@ static OSSL_CMP_MSG *process_genm(OSSL_CMP_SRV_CTX *srv_ctx, return NULL; msg = ossl_cmp_genp_new(srv_ctx->ctx, itavs); + + if (msg != NULL && msg->header != NULL + && srv_ctx->ctx->kem_status == KBM_SSK_USING_SERVER_KEM_KEY_1) { + ossl_cmp_ctx_set1_kem_senderNonce(srv_ctx->ctx, + msg->header->senderNonce); + ossl_cmp_ctx_set1_kem_recipNonce(srv_ctx->ctx, + msg->header->recipNonce); + } sk_OSSL_CMP_ITAV_pop_free(itavs, OSSL_CMP_ITAV_free); return msg; } @@ -564,6 +612,18 @@ static int unprotected_exception(const OSSL_CMP_CTX *ctx, ossl_cmp_warn(ctx, "ignoring missing protection of error message"); return 1; } + + if (OSSL_CMP_MSG_get_bodytype(req) == OSSL_CMP_PKIBODY_GENM + && sk_OSSL_CMP_ITAV_num(req->body->value.genm) == 1) { + OSSL_CMP_ITAV *req_itav = sk_OSSL_CMP_ITAV_value(req->body->value.genm, + 0); + ASN1_OBJECT *obj = OSSL_CMP_ITAV_get0_type(req_itav); + + if (OBJ_obj2nid(obj) == NID_id_it_KemCiphertextInfo + && OSSL_CMP_ITAV_get0_value(req_itav) == NULL) { + return 1; + } + } return 0; } @@ -617,6 +677,8 @@ OSSL_CMP_MSG *OSSL_CMP_SRV_process_request(OSSL_CMP_SRV_CTX *srv_ctx, case OSSL_CMP_PKIBODY_RR: case OSSL_CMP_PKIBODY_GENM: case OSSL_CMP_PKIBODY_ERROR: + if (ctx->kem_status == KBM_SSK_USING_SERVER_KEM_KEY_1) + break; if (ctx->transactionID != NULL) { char *tid = i2s_ASN1_OCTET_STRING(NULL, ctx->transactionID); @@ -630,6 +692,10 @@ OSSL_CMP_MSG *OSSL_CMP_SRV_process_request(OSSL_CMP_SRV_CTX *srv_ctx, if (!OSSL_CMP_CTX_set1_transactionID(ctx, NULL) || !OSSL_CMP_CTX_set1_senderNonce(ctx, NULL)) goto err; + /* TODO: Need to check */ + OSSL_CMP_CTX_set_option(ctx, + OSSL_CMP_OPT_KEM_STATUS, + 0); if (srv_ctx->clean_transaction != NULL && !srv_ctx->clean_transaction(srv_ctx, NULL)) { @@ -721,15 +787,19 @@ OSSL_CMP_MSG *OSSL_CMP_SRV_process_request(OSSL_CMP_SRV_CTX *srv_ctx, if (OSSL_CMP_CTX_get_option(ctx, OSSL_CMP_OPT_IMPLICIT_CONFIRM) == 0) break; /* fall through */ - case OSSL_CMP_PKIBODY_ERROR: if (rsp != NULL && ossl_cmp_is_error_with_waiting(rsp)) break; /* fall through */ + case OSSL_CMP_PKIBODY_GENP: + if (rsp_type == OSSL_CMP_PKIBODY_GENP + && ctx->kem_status == KBM_SSK_USING_SERVER_KEM_KEY_1) + break; + /* fall through */ + case OSSL_CMP_PKIBODY_RP: case OSSL_CMP_PKIBODY_PKICONF: - case OSSL_CMP_PKIBODY_GENP: /* Other terminating response message types are not supported */ srv_ctx->certReqId = OSSL_CMP_CERTREQID_INVALID; /* Prepare for next transaction, ignoring any errors here: */ @@ -737,6 +807,10 @@ OSSL_CMP_MSG *OSSL_CMP_SRV_process_request(OSSL_CMP_SRV_CTX *srv_ctx, (void)srv_ctx->clean_transaction(srv_ctx, ctx->transactionID); (void)OSSL_CMP_CTX_set1_transactionID(ctx, NULL); (void)OSSL_CMP_CTX_set1_senderNonce(ctx, NULL); + (void)OSSL_CMP_CTX_reinit(ctx); + OSSL_CMP_CTX_set_option(ctx, + OSSL_CMP_OPT_KEM_STATUS, + 0); ctx->status = OSSL_CMP_PKISTATUS_unspecified; /* transaction closed */ default: /* not closing transaction in other cases */ diff --git a/crypto/cmp/cmp_util.c b/crypto/cmp/cmp_util.c index f3c21c5d914cd..b1817ff9b1654 100644 --- a/crypto/cmp/cmp_util.c +++ b/crypto/cmp/cmp_util.c @@ -284,3 +284,17 @@ int ossl_cmp_asn1_octet_string_set1_bytes(ASN1_OCTET_STRING **tgt, *tgt = new; return 1; } + +int ossl_cmp_x509_algor_set0(X509_ALGOR **tgt, X509_ALGOR *src) +{ + if (tgt == NULL || src == NULL) { + ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT); + return 0; + } + if (*tgt == src) /* self-assignment */ + return 1; + + X509_ALGOR_free(*tgt); + *tgt = src; + return 1; +} diff --git a/crypto/cmp/cmp_vfy.c b/crypto/cmp/cmp_vfy.c index cfbd3d830032e..4911083add714 100644 --- a/crypto/cmp/cmp_vfy.c +++ b/crypto/cmp/cmp_vfy.c @@ -96,6 +96,28 @@ static int verify_PBMAC(OSSL_CMP_CTX *ctx, const OSSL_CMP_MSG *msg) return valid; } +/* Verify a message protected with KBMAC */ +static int verify_KBMAC(OSSL_CMP_CTX *ctx, const OSSL_CMP_MSG *msg) +{ + ASN1_BIT_STRING *protection = NULL; + int valid = 0; + + /* generate expected protection for the message */ + if ((protection = ossl_cmp_calc_protection(ctx, msg)) == NULL) + return 0; /* failed to generate protection string! */ + + valid = msg->protection != NULL && msg->protection->length >= 0 + && msg->protection->type == protection->type + && msg->protection->length == protection->length + && CRYPTO_memcmp(msg->protection->data, protection->data, + protection->length) == 0; + ASN1_BIT_STRING_free(protection); + if (!valid) + ERR_raise(ERR_LIB_CMP, CMP_R_WRONG_PBM_VALUE); + + return valid; +} + /*- * Attempt to validate certificate and path using any given store with trusted * certs (possibly including CRLs and a cert verification callback function) @@ -578,6 +600,20 @@ int OSSL_CMP_validate_msg(OSSL_CMP_CTX *ctx, const OSSL_CMP_MSG *msg) } switch (ossl_cmp_hdr_get_protection_nid(msg->header)) { + /* TODO: merge it with pbm as most code are same */ + case NID_id_KemBasedMac: + if (ctx->kem_ssk == NULL + && !ossl_cmp_kem_derive_ssk_using_srvcert(ctx, msg)) { + ossl_cmp_info(ctx, "no ssk available for verifying KEM-based CMP message protection"); + ERR_raise(ERR_LIB_CMP, CMP_R_MISSING_SECRET); + return 0; + } + + if (ctx->kem_status == KBM_SSK_ESTABLISHED_USING_SERVER + && verify_KBMAC(ctx, msg)) { + return 1; + } + return 0; /* 5.1.3.1. Shared Secret Information */ case NID_id_PasswordBasedMAC: if (ctx->secretValue == NULL) { diff --git a/crypto/err/openssl.txt b/crypto/err/openssl.txt index a20c136114bb5..e154ffe057b81 100644 --- a/crypto/err/openssl.txt +++ b/crypto/err/openssl.txt @@ -228,6 +228,7 @@ CMP_R_ERROR_UNEXPECTED_CERTCONF:160:error unexpected certconf CMP_R_ERROR_VALIDATING_PROTECTION:140:error validating protection CMP_R_ERROR_VALIDATING_SIGNATURE:171:error validating signature CMP_R_EXPECTED_POLLREQ:104:expected pollreq +CMP_R_ERROR_DERIVING_KBM_SSK:198:error deriving ssk CMP_R_FAILED_BUILDING_OWN_CHAIN:164:failed building own chain CMP_R_FAILED_EXTRACTING_PUBKEY:141:failed extracting pubkey CMP_R_FAILURE_OBTAINING_RANDOM:110:failure obtaining random @@ -293,6 +294,7 @@ CMP_R_WRONG_ALGORITHM_OID:138:wrong algorithm oid CMP_R_WRONG_CERTID:189:wrong certid CMP_R_WRONG_CERTID_IN_RP:187:wrong certid in rp CMP_R_WRONG_PBM_VALUE:155:wrong pbm value +CMP_R_WRONG_KBM_VALUE:197:wrong kbm value CMP_R_WRONG_RP_COMPONENT_COUNT:188:wrong rp component count CMP_R_WRONG_SERIAL_IN_RP:173:wrong serial in rp CMS_R_ADD_SIGNER_ERROR:99:add signer error diff --git a/crypto/objects/obj_dat.h b/crypto/objects/obj_dat.h index 5292db3f0785f..78e690aa59e0b 100644 --- a/crypto/objects/obj_dat.h +++ b/crypto/objects/obj_dat.h @@ -10,7 +10,7 @@ */ /* Serialized OID's */ -static const unsigned char so[8476] = { +static const unsigned char so[8518] = { 0x2A,0x86,0x48,0x86,0xF7,0x0D, /* [ 0] OBJ_rsadsi */ 0x2A,0x86,0x48,0x86,0xF7,0x0D,0x01, /* [ 6] OBJ_pkcs */ 0x2A,0x86,0x48,0x86,0xF7,0x0D,0x02,0x02, /* [ 13] OBJ_md2 */ @@ -1182,9 +1182,14 @@ static const unsigned char so[8476] = { 0x55,0x1D,0x49, /* [ 8466] OBJ_alt_signature_algorithm */ 0x55,0x1D,0x4A, /* [ 8469] OBJ_alt_signature_value */ 0x55,0x1D,0x4B, /* [ 8472] OBJ_associated_information */ + 0x2B,0x06,0x01,0x05,0x05,0x07,0x04,0x18, /* [ 8475] OBJ_id_it_KemCiphertextInfo */ + 0x2A,0x86,0x48,0x86,0xF6,0x7D,0x07,0x42,0x10, /* [ 8483] OBJ_id_KemBasedMac */ + 0x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x09,0x10,0x03,0x1C, /* [ 8492] OBJ_hkdfWithSHA256 */ + 0x28,0x81,0x8C,0x71,0x02,0x02,0x04, /* [ 8503] OBJ_id_kem_rsa */ + 0x28,0x81,0x8C,0x71,0x02,0x05,0x02, /* [ 8510] OBJ_id_kdf_kdf2 */ }; -#define NUM_NID 1320 +#define NUM_NID 1325 static const ASN1_OBJECT nid_objs[NUM_NID] = { {"UNDEF", "undefined", NID_undef}, {"rsadsi", "RSA Data Security, Inc.", NID_rsadsi, 6, &so[0]}, @@ -2506,9 +2511,14 @@ static const ASN1_OBJECT nid_objs[NUM_NID] = { {"altSignatureAlgorithm", "X509v3 Alternative Signature Algorithm", NID_alt_signature_algorithm, 3, &so[8466]}, {"altSignatureValue", "X509v3 Alternative Signature Value", NID_alt_signature_value, 3, &so[8469]}, {"associatedInformation", "X509v3 Associated Information", NID_associated_information, 3, &so[8472]}, + {"id-it-KemCiphertextInfo", "id-it-KemCiphertextInfo", NID_id_it_KemCiphertextInfo, 8, &so[8475]}, + {"id-KemBasedMac", "KEM based MAC", NID_id_KemBasedMac, 9, &so[8483]}, + {"hkdfWithSHA256", "HKDF with SHA256", NID_hkdfWithSHA256, 11, &so[8492]}, + {"id-kem-rsa", "id-kem-rsa", NID_id_kem_rsa, 7, &so[8503]}, + {"id-kdf-kdf2", "id-kdf-kdf2", NID_id_kdf_kdf2, 7, &so[8510]}, }; -#define NUM_SN 1311 +#define NUM_SN 1316 static const unsigned int sn_objs[NUM_SN] = { 364, /* "AD_DVCS" */ 419, /* "AES-128-CBC" */ @@ -3029,6 +3039,7 @@ static const unsigned int sn_objs[NUM_SN] = { 812, /* "gost94" */ 850, /* "gost94cc" */ 1310, /* "groupAC" */ + 1322, /* "hkdfWithSHA256" */ 1156, /* "hmacWithDstu34311" */ 797, /* "hmacWithMD5" */ 163, /* "hmacWithSHA1" */ @@ -3089,6 +3100,7 @@ static const unsigned int sn_objs[NUM_SN] = { 808, /* "id-GostR3411-94-with-GostR3410-94" */ 852, /* "id-GostR3411-94-with-GostR3410-94-cc" */ 810, /* "id-HMACGostR3411-94" */ + 1321, /* "id-KemBasedMac" */ 782, /* "id-PasswordBasedMAC" */ 1272, /* "id-aa-ATSHashIndex" */ 1277, /* "id-aa-ATSHashIndex-v2" */ @@ -3188,6 +3200,7 @@ static const unsigned int sn_objs[NUM_SN] = { 1104, /* "id-hmacWithSHA3-384" */ 1105, /* "id-hmacWithSHA3-512" */ 260, /* "id-it" */ + 1320, /* "id-it-KemCiphertextInfo" */ 1223, /* "id-it-caCerts" */ 302, /* "id-it-caKeyUpdateInfo" */ 298, /* "id-it-caProtEncCert" */ @@ -3211,6 +3224,8 @@ static const unsigned int sn_objs[NUM_SN] = { 306, /* "id-it-subscriptionResponse" */ 784, /* "id-it-suppLangTags" */ 304, /* "id-it-unsupportedOIDs" */ + 1324, /* "id-kdf-kdf2" */ + 1323, /* "id-kem-rsa" */ 128, /* "id-kp" */ 1221, /* "id-kp-BrandIndicatorforMessageIdentification" */ 1220, /* "id-kp-bgpsec-router" */ @@ -3823,7 +3838,7 @@ static const unsigned int sn_objs[NUM_SN] = { 1289, /* "zstd" */ }; -#define NUM_LN 1311 +#define NUM_LN 1316 static const unsigned int ln_objs[NUM_LN] = { 363, /* "AD Time Stamping" */ 405, /* "ANSI X9.62" */ @@ -3914,6 +3929,7 @@ static const unsigned int ln_objs[NUM_LN] = { 808, /* "GOST R 34.11-94 with GOST R 34.10-94" */ 852, /* "GOST R 34.11-94 with GOST R 34.10-94 Cryptocom" */ 854, /* "GOST R 3410-2001 Parameter Set Cryptocom" */ + 1322, /* "HKDF with SHA256" */ 1156, /* "HMAC DSTU Gost 34311-95" */ 988, /* "HMAC GOST 34.11-2012 256 bit" */ 989, /* "HMAC GOST 34.11-2012 512 bit" */ @@ -3936,6 +3952,7 @@ static const unsigned int ln_objs[NUM_LN] = { 665, /* "Inherit all" */ 647, /* "International Organizations" */ 142, /* "Invalidity Date" */ + 1321, /* "KEM based MAC" */ 504, /* "MIME MHS" */ 388, /* "Mail" */ 383, /* "Management" */ @@ -4521,6 +4538,7 @@ static const unsigned int ln_objs[NUM_LN] = { 508, /* "id-hex-multipart-message" */ 507, /* "id-hex-partial-message" */ 260, /* "id-it" */ + 1320, /* "id-it-KemCiphertextInfo" */ 1223, /* "id-it-caCerts" */ 302, /* "id-it-caKeyUpdateInfo" */ 298, /* "id-it-caProtEncCert" */ @@ -4544,6 +4562,8 @@ static const unsigned int ln_objs[NUM_LN] = { 306, /* "id-it-subscriptionResponse" */ 784, /* "id-it-suppLangTags" */ 304, /* "id-it-unsupportedOIDs" */ + 1324, /* "id-kdf-kdf2" */ + 1323, /* "id-kem-rsa" */ 128, /* "id-kp" */ 280, /* "id-mod-attribute-cert" */ 274, /* "id-mod-cmc" */ @@ -5138,7 +5158,7 @@ static const unsigned int ln_objs[NUM_LN] = { 125, /* "zlib compression" */ }; -#define NUM_OBJ 1177 +#define NUM_OBJ 1182 static const unsigned int obj_objs[NUM_OBJ] = { 0, /* OBJ_undef 0 */ 181, /* OBJ_iso 1 */ @@ -5552,6 +5572,8 @@ static const unsigned int obj_objs[NUM_OBJ] = { 1278, /* OBJ_id_aa_ATSHashIndex_v3 0 4 0 19122 1 5 */ 1279, /* OBJ_signedAssertion 0 4 0 19122 1 6 */ 436, /* OBJ_ucl 0 9 2342 19200300 */ + 1323, /* OBJ_id_kem_rsa 1 0 18033 2 2 4 */ + 1324, /* OBJ_id_kdf_kdf2 1 0 18033 2 5 2 */ 820, /* OBJ_id_Gost28147_89_None_KeyMeshing 1 2 643 2 2 14 0 */ 819, /* OBJ_id_Gost28147_89_CryptoPro_KeyMeshing 1 2 643 2 2 14 1 */ 845, /* OBJ_id_GostR3410_94_a 1 2 643 2 2 20 1 */ @@ -5830,6 +5852,7 @@ static const unsigned int obj_objs[NUM_OBJ] = { 1255, /* OBJ_id_it_certProfile 1 3 6 1 5 5 7 4 21 */ 1256, /* OBJ_id_it_crlStatusList 1 3 6 1 5 5 7 4 22 */ 1257, /* OBJ_id_it_crls 1 3 6 1 5 5 7 4 23 */ + 1320, /* OBJ_id_it_KemCiphertextInfo 1 3 6 1 5 5 7 4 24 */ 313, /* OBJ_id_regCtrl 1 3 6 1 5 5 7 5 1 */ 314, /* OBJ_id_regInfo 1 3 6 1 5 5 7 5 2 */ 323, /* OBJ_id_alg_des40 1 3 6 1 5 5 7 6 1 */ @@ -5939,6 +5962,7 @@ static const unsigned int obj_objs[NUM_OBJ] = { 108, /* OBJ_cast5_cbc 1 2 840 113533 7 66 10 */ 112, /* OBJ_pbeWithMD5AndCast5_CBC 1 2 840 113533 7 66 12 */ 782, /* OBJ_id_PasswordBasedMAC 1 2 840 113533 7 66 13 */ + 1321, /* OBJ_id_KemBasedMac 1 2 840 113533 7 66 16 */ 783, /* OBJ_id_DHBasedMac 1 2 840 113533 7 66 30 */ 6, /* OBJ_rsaEncryption 1 2 840 113549 1 1 1 */ 7, /* OBJ_md2WithRSAEncryption 1 2 840 113549 1 1 2 */ @@ -6284,6 +6308,7 @@ static const unsigned int obj_objs[NUM_OBJ] = { 247, /* OBJ_id_smime_alg_CMSRC2wrap 1 2 840 113549 1 9 16 3 7 */ 125, /* OBJ_zlib_compression 1 2 840 113549 1 9 16 3 8 */ 893, /* OBJ_id_alg_PWRI_KEK 1 2 840 113549 1 9 16 3 9 */ + 1322, /* OBJ_hkdfWithSHA256 1 2 840 113549 1 9 16 3 28 */ 248, /* OBJ_id_smime_cd_ldap 1 2 840 113549 1 9 16 4 1 */ 249, /* OBJ_id_smime_spq_ets_sqt_uri 1 2 840 113549 1 9 16 5 1 */ 250, /* OBJ_id_smime_spq_ets_sqt_unotice 1 2 840 113549 1 9 16 5 2 */ diff --git a/crypto/objects/obj_mac.num b/crypto/objects/obj_mac.num index 9deaf2a5a94ec..36d45cb5e68bc 100644 --- a/crypto/objects/obj_mac.num +++ b/crypto/objects/obj_mac.num @@ -1317,3 +1317,8 @@ subject_alt_public_key_info 1316 alt_signature_algorithm 1317 alt_signature_value 1318 associated_information 1319 +id_it_KemCiphertextInfo 1320 +id_KemBasedMac 1321 +hkdfWithSHA256 1322 +id_kem_rsa 1323 +id_kdf_kdf2 1324 diff --git a/crypto/objects/objects.txt b/crypto/objects/objects.txt index 305b89c016227..fccd47767ee8a 100644 --- a/crypto/objects/objects.txt +++ b/crypto/objects/objects.txt @@ -14,6 +14,10 @@ iso 3 : identified-organization # GMAC OID iso 0 9797 3 4 : GMAC : gmac +# RSA key encapsulation mechanism +iso 0 18033 2 2 4 : id-kem-rsa +iso 0 18033 2 5 2 : id-kdf-kdf2 + # HMAC OIDs identified-organization 6 1 5 5 8 1 1 : HMAC-MD5 : hmac-md5 identified-organization 6 1 5 5 8 1 2 : HMAC-SHA1 : hmac-sha1 @@ -167,6 +171,8 @@ ISO-US 113533 7 66 12 : : pbeWithMD5AndCast5CBC # Macs for CMP and CRMF ISO-US 113533 7 66 13 : id-PasswordBasedMAC : password based MAC ISO-US 113533 7 66 30 : id-DHBasedMac : Diffie-Hellman based MAC +# preliminary value for prototyping (TBD4 by IANA) +ISO-US 113533 7 66 16 : id-KemBasedMac : KEM based MAC ISO-US 113549 : rsadsi : RSA Data Security, Inc. @@ -602,6 +608,8 @@ id-it 20 : id-it-rootCaCert id-it 21 : id-it-certProfile id-it 22 : id-it-crlStatusList id-it 23 : id-it-crls +# preliminary value for prototyping (TBD by IANA) +id-it 24 : id-it-KemCiphertextInfo # CRMF registration id-pkip 1 : id-regCtrl @@ -1758,6 +1766,8 @@ ms-corp 60 2 1 3 : jurisdictionC : jurisdictionCountryName # NID for SSHKDF : SSHKDF : sshkdf +# NID for hkdf with sha256 +id-smime-alg 28 : hkdfWithSHA256 : HKDF with SHA256 # NID for SSKDF : SSKDF : sskdf diff --git a/fuzz/oids.txt b/fuzz/oids.txt index bae6272f09591..9e01c6b66f2a1 100644 --- a/fuzz/oids.txt +++ b/fuzz/oids.txt @@ -1178,3 +1178,8 @@ OBJ_subject_alt_public_key_info="\x55\x1D\x48" OBJ_alt_signature_algorithm="\x55\x1D\x49" OBJ_alt_signature_value="\x55\x1D\x4A" OBJ_associated_information="\x55\x1D\x4B" +OBJ_id_it_KemCiphertextInfo="\x2B\x06\x01\x05\x05\x07\x04\x18" +OBJ_id_KemBasedMac="\x2A\x86\x48\x86\xF6\x7D\x07\x42\x10" +OBJ_hkdfWithSHA256="\x2A\x86\x48\x86\xF7\x0D\x01\x09\x10\x03\x1C" +OBJ_id_kem_rsa="\x28\x81\x8C\x71\x02\x02\x04" +OBJ_id_kdf_kdf2="\x28\x81\x8C\x71\x02\x05\x02" diff --git a/include/openssl/cmp.h.in b/include/openssl/cmp.h.in index 3eb6a95324004..705848af2f88a 100644 --- a/include/openssl/cmp.h.in +++ b/include/openssl/cmp.h.in @@ -246,6 +246,7 @@ typedef struct ossl_cmp_certresponse_st OSSL_CMP_CERTRESPONSE; generate_stack_macros("OSSL_CMP_CERTRESPONSE"); -} typedef STACK_OF(ASN1_UTF8STRING) OSSL_CMP_PKIFREETEXT; +typedef struct ossl_cmp_KemOtherInfo_st OSSL_CMP_KEMOTHERINFO; /* * function DECLARATIONS @@ -260,7 +261,6 @@ ASN1_TYPE *OSSL_CMP_ITAV_get0_value(const OSSL_CMP_ITAV *itav); int OSSL_CMP_ITAV_push0_stack_item(STACK_OF(OSSL_CMP_ITAV) **itav_sk_p, OSSL_CMP_ITAV *itav); void OSSL_CMP_ITAV_free(OSSL_CMP_ITAV *itav); - OSSL_CMP_ITAV *OSSL_CMP_ITAV_new0_certProfile(STACK_OF(ASN1_UTF8STRING) *certProfile); int OSSL_CMP_ITAV_get0_certProfile(const OSSL_CMP_ITAV *itav, @@ -311,6 +311,9 @@ const char *OSSL_CMP_CTX_get0_propq(const OSSL_CMP_CTX *ctx); # define OSSL_CMP_OPT_IGNORE_KEYUSAGE 35 # define OSSL_CMP_OPT_PERMIT_TA_IN_EXTRACERTS_FOR_IR 36 # define OSSL_CMP_OPT_NO_CACHE_EXTRACERTS 37 +# define OSSL_CMP_OPT_SSK_LEN 38 +# define OSSL_CMP_OPT_KEM_MAC_ALGNID 39 +# define OSSL_CMP_OPT_KEM_STATUS 40 int OSSL_CMP_CTX_set_option(OSSL_CMP_CTX *ctx, int opt, int val); int OSSL_CMP_CTX_get_option(const OSSL_CMP_CTX *ctx, int opt); /* CMP-specific callback for logging and outputting the error queue: */ @@ -416,6 +419,7 @@ STACK_OF(OSSL_CMP_ITAV) /* from cmp_msg.c */ OSSL_CMP_PKIHEADER *OSSL_CMP_MSG_get0_header(const OSSL_CMP_MSG *msg); int OSSL_CMP_MSG_get_bodytype(const OSSL_CMP_MSG *msg); +STACK_OF(X509)* OSSL_CMP_MSG_get_extraCerts(const OSSL_CMP_MSG *msg); int OSSL_CMP_MSG_update_transactionID(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg); int OSSL_CMP_MSG_update_recipNonce(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg); OSSL_CRMF_MSG *OSSL_CMP_CTX_setup_CRM(OSSL_CMP_CTX *ctx, int for_KUR, int rid); @@ -492,6 +496,8 @@ int OSSL_CMP_SRV_CTX_set_accept_unprotected(OSSL_CMP_SRV_CTX *srv_ctx, int val); int OSSL_CMP_SRV_CTX_set_accept_raverified(OSSL_CMP_SRV_CTX *srv_ctx, int val); int OSSL_CMP_SRV_CTX_set_grant_implicit_confirm(OSSL_CMP_SRV_CTX *srv_ctx, int val); +OSSL_CMP_ITAV *OSSL_CMP_SRV_kem_get_ss(OSSL_CMP_SRV_CTX *srv_ctx, + const EVP_PKEY *pubkey); /* from cmp_client.c */ X509 *OSSL_CMP_exec_certreq(OSSL_CMP_CTX *ctx, int req_type, @@ -521,6 +527,9 @@ int OSSL_CMP_get1_rootCaKeyUpdate(OSSL_CMP_CTX *ctx, const X509 *oldWithOld, X509 **newWithNew, X509 **newWithOld, X509 **oldWithNew); +/* from cmp_kem.c */ +int OSSL_CMP_get_ssk(OSSL_CMP_CTX *ctx); + # ifdef __cplusplus } # endif diff --git a/include/openssl/cmperr.h b/include/openssl/cmperr.h index aba6a9352ed39..9b0c9cdfa24ab 100644 --- a/include/openssl/cmperr.h +++ b/include/openssl/cmperr.h @@ -56,6 +56,7 @@ # define CMP_R_ERROR_VALIDATING_PROTECTION 140 # define CMP_R_ERROR_VALIDATING_SIGNATURE 171 # define CMP_R_EXPECTED_POLLREQ 104 +# define CMP_R_ERROR_DERIVING_KBM_SSK 196 # define CMP_R_FAILED_BUILDING_OWN_CHAIN 164 # define CMP_R_FAILED_EXTRACTING_PUBKEY 141 # define CMP_R_FAILURE_OBTAINING_RANDOM 110 @@ -118,6 +119,7 @@ # define CMP_R_WRONG_CERTID 189 # define CMP_R_WRONG_CERTID_IN_RP 187 # define CMP_R_WRONG_PBM_VALUE 155 +# define CMP_R_WRONG_KBM_VALUE 197 # define CMP_R_WRONG_RP_COMPONENT_COUNT 188 # define CMP_R_WRONG_SERIAL_IN_RP 173 diff --git a/include/openssl/obj_mac.h b/include/openssl/obj_mac.h index e1b441b313df4..27ee80f7c5372 100644 --- a/include/openssl/obj_mac.h +++ b/include/openssl/obj_mac.h @@ -53,6 +53,14 @@ #define NID_gmac 1195 #define OBJ_gmac OBJ_iso,0L,9797L,3L,4L +#define SN_id_kem_rsa "id-kem-rsa" +#define NID_id_kem_rsa 1323 +#define OBJ_id_kem_rsa OBJ_iso,0L,18033L,2L,2L,4L + +#define SN_id_kdf_kdf2 "id-kdf-kdf2" +#define NID_id_kdf_kdf2 1324 +#define OBJ_id_kdf_kdf2 OBJ_iso,0L,18033L,2L,5L,2L + #define SN_hmac_md5 "HMAC-MD5" #define LN_hmac_md5 "hmac-md5" #define NID_hmac_md5 780 @@ -525,6 +533,11 @@ #define NID_id_DHBasedMac 783 #define OBJ_id_DHBasedMac OBJ_ISO_US,113533L,7L,66L,30L +#define SN_id_KemBasedMac "id-KemBasedMac" +#define LN_id_KemBasedMac "KEM based MAC" +#define NID_id_KemBasedMac 1321 +#define OBJ_id_KemBasedMac OBJ_ISO_US,113533L,7L,66L,16L + #define SN_rsadsi "rsadsi" #define LN_rsadsi "RSA Data Security, Inc." #define NID_rsadsi 1 @@ -1861,6 +1874,10 @@ #define NID_id_it_crls 1257 #define OBJ_id_it_crls OBJ_id_it,23L +#define SN_id_it_KemCiphertextInfo "id-it-KemCiphertextInfo" +#define NID_id_it_KemCiphertextInfo 1320 +#define OBJ_id_it_KemCiphertextInfo OBJ_id_it,24L + #define SN_id_regCtrl "id-regCtrl" #define NID_id_regCtrl 313 #define OBJ_id_regCtrl OBJ_id_pkip,1L @@ -5462,6 +5479,11 @@ #define LN_sshkdf "sshkdf" #define NID_sshkdf 1203 +#define SN_hkdfWithSHA256 "hkdfWithSHA256" +#define LN_hkdfWithSHA256 "HKDF with SHA256" +#define NID_hkdfWithSHA256 1322 +#define OBJ_hkdfWithSHA256 OBJ_id_smime_alg,28L + #define SN_sskdf "SSKDF" #define LN_sskdf "sskdf" #define NID_sskdf 1205 diff --git a/test/recipes/80-test_cmp_http_data/Mock/kem.crt b/test/recipes/80-test_cmp_http_data/Mock/kem.crt new file mode 100644 index 0000000000000..682e062f13809 --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/kem.crt @@ -0,0 +1,22 @@ +-----BEGIN CERTIFICATE----- +MIIDkjCCAnqgAwIBAgIUCIoReKKPB6Yh4B0HEeykhscAQ68wDQYJKoZIhvcNAQEL +BQAwWjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClNvbWUtU3RhdGUxITAfBgNVBAoT +GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDETMBEGA1UEAxMKc3ViaW50ZXJDQTAe +Fw0yMzA3MTMxNDM5NDVaFw0zMzA3MTAxNDM5NDVaMFgxCzAJBgNVBAYTAkFVMRMw +EQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0 +eSBMdGQxETAPBgNVBAMMCGxlYWYtS0VNMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAw9GYW2QMjkZ3UJOJL3y65cQoXD9/1J5BEPGjuJKBETnxK8xnRMta +FQiDAg5qwxvRilPk38hYmvbVbvGmrGwWpwC4y9eHeF0GL39wGzWW4oY7kqi+D9jv +y5knBpvB6dn0DQjAm01uigU26YtCAZ7Va8+/Ankwp41+sVKzwgKBn19oBMHU1YNd +UCFEPR5d2yM72MEeHGhjTZybBm4+ueCNSNzyC/jZMpy3oHXlmlJE2mvEsOQZA4n6 +xIUe+RwokfAXlwYFl19pbdj5G42IhLzr9ZSu6uvjm5RvCxoPdmtQZ6FxaBUNfRMG +jqEOkYuwCJ2718yaURgbRqfmlKNdECyy4QIDAQABo1IwUDAOBgNVHQ8BAf8EBAMC +BSAwHQYDVR0OBBYEFEQ91872uHULE2j0VfkvlMW56822MB8GA1UdIwQYMBaAFOln +fRB0wZquuEw/CT4ccBXdHxpPMA0GCSqGSIb3DQEBCwUAA4IBAQBZIyZsem85ca5U +Fzz88Bvvl2oKsIW8ixlhXkc4fA4pzcuXmgt0l31dO6NTEkxfDWfIinENB7kEmNmE +XD6Cll/uvtKICViAZMdrYZZZYkToyrN6Jkrf+svdjfk4Bjr1ufixYSzj6NIb1KIa +9vgyG0LGLEzDbUH3XCnmgYHc/c/6nt6ZoN/iVROmgcTafOv3S9/2ertAFPEpdRxX +Axj3V2qgguBJCyhJ7VuaBhJhpWgHUjtzH61etyLoCMVKTaR9L8ocS217LeGCHKto +d3tuL7nQctvpTqG7jvvujUlPs2uKY0Fzsqw66ez51mWVyop9rkvudkZIZ0ftMYli +DcOpACyZ +-----END CERTIFICATE----- diff --git a/test/recipes/80-test_cmp_http_data/Mock/kem.key b/test/recipes/80-test_cmp_http_data/Mock/kem.key new file mode 100644 index 0000000000000..deb103ad68826 --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/kem.key @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDD0ZhbZAyORndQ +k4kvfLrlxChcP3/UnkEQ8aO4koEROfErzGdEy1oVCIMCDmrDG9GKU+TfyFia9tVu +8aasbBanALjL14d4XQYvf3AbNZbihjuSqL4P2O/LmScGm8Hp2fQNCMCbTW6KBTbp +i0IBntVrz78CeTCnjX6xUrPCAoGfX2gEwdTVg11QIUQ9Hl3bIzvYwR4caGNNnJsG +bj654I1I3PIL+NkynLegdeWaUkTaa8Sw5BkDifrEhR75HCiR8BeXBgWXX2lt2Pkb +jYiEvOv1lK7q6+OblG8LGg92a1BnoXFoFQ19EwaOoQ6Ri7AInbvXzJpRGBtGp+aU +o10QLLLhAgMBAAECggEAJQLhnCx93wpclOM947bckH8R7dWmsKY0wCIcAs/WC057 +Uf7xaeRRo3YXZPUaosQIR+/xa4avkKKk1rJgAWjwoyIUy5pyJYLXn3Sj2NC5MxmR ++vdf7Rjgwgexg6M+9JdYdHo6BWCOSxIPPfcvQ6Uky5rZjHshghnRX2y1Qy88FsYZ +5TUMa7qQjbtzZPM7dePCvHy0Euw3ggjyzwN4n/TUm9U9AlEUfNWvjP56RjLHrUBc +kiBbdMgvipu5/MMq5V63WpWxUrCOFnyofOsfuZ632CVfxy4d6fiBX0KrD0I96A1Z +GrelDpuyq7/GL6khiO3IBkOUJgsZO/lgTCq/gd4iEQKBgQDqlv82MGDWaX2tSszW +l/tvTR1y1aV9IcqLi32r9cuLIVNA7aJoWQLAtt5KRiE7pT6BZ4OEGbhAS+t+jXON +UTqc8ixa9/TRhEA4aVrhevLfOIJfaT2TNCivuuAHXKmXPM8IqArfnZyat7p8Xfp6 +vNxYxWIga8CZ0ogLB+RUmqhx7QKBgQDVsL4Z8q1XF6kgL8oRyiA+IA81Jw1qL4f5 +Hpg1nJlY29ajQqBz6RPJmMN/X5Pt5/xD9WOGZwFxATkUXzwSQw1hfHdggOonVuNc +SONCBinUtq5TdpB4H7LFqbaVgSrU1YZPiQekTyv+hfsYN4IOLCDuQxgxZ4moiHf5 +sQP7+/Y2RQKBgGyWeIwc2LZnHkWY2jh7IWfjyj3dpzzE53ywlPuESzObuW3Ukdi7 +WwrZmwvGapuxYb2ErNv5C9C3U8rArzw63WbIsr9pB2n0TcXO/sJgpwusnKyNinMZ +MbwmRI0j11yqSSs4nc/kpRj48tmeptMpmNV+iG15cy3AxjhU7tw6ur4BAoGBAIU8 ++Zs2PCyEnThrc8QZ0nbKCJFssymVT2PeVqt+5AKKuE79eQwstODLNoJR9uus7Rb2 +h0LDMRvj1lJEezEry8kQEWMDnnw+6e6dp82ACE8QRKvXzoaHxTEH+8dGTY19QYyP +9UrW7qh5o7Fa0uXBUBsfjJMpaqTByoTOgZx5YvA9AoGAUsqA4GdiBt+HCJv+uwP3 +21XcxdhwmT9PYMh7MdONpe9kEZUu1o/MVuCSascsF5qIewIlynqnACoS/E3yILxy +/Q4IyxJpvaocvO94xvHYa1T//FQG+JO7gOjLyF5c8IK7V3O+luxRy1I99Y87ePlq +aPBrRRPu2ZIxrPmdPmdNp1s= +-----END PRIVATE KEY----- diff --git a/test/recipes/80-test_cmp_http_data/Mock/kem_RSA.crt b/test/recipes/80-test_cmp_http_data/Mock/kem_RSA.crt new file mode 100644 index 0000000000000..682e062f13809 --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/kem_RSA.crt @@ -0,0 +1,22 @@ +-----BEGIN CERTIFICATE----- +MIIDkjCCAnqgAwIBAgIUCIoReKKPB6Yh4B0HEeykhscAQ68wDQYJKoZIhvcNAQEL +BQAwWjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClNvbWUtU3RhdGUxITAfBgNVBAoT +GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDETMBEGA1UEAxMKc3ViaW50ZXJDQTAe +Fw0yMzA3MTMxNDM5NDVaFw0zMzA3MTAxNDM5NDVaMFgxCzAJBgNVBAYTAkFVMRMw +EQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0 +eSBMdGQxETAPBgNVBAMMCGxlYWYtS0VNMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAw9GYW2QMjkZ3UJOJL3y65cQoXD9/1J5BEPGjuJKBETnxK8xnRMta +FQiDAg5qwxvRilPk38hYmvbVbvGmrGwWpwC4y9eHeF0GL39wGzWW4oY7kqi+D9jv +y5knBpvB6dn0DQjAm01uigU26YtCAZ7Va8+/Ankwp41+sVKzwgKBn19oBMHU1YNd +UCFEPR5d2yM72MEeHGhjTZybBm4+ueCNSNzyC/jZMpy3oHXlmlJE2mvEsOQZA4n6 +xIUe+RwokfAXlwYFl19pbdj5G42IhLzr9ZSu6uvjm5RvCxoPdmtQZ6FxaBUNfRMG +jqEOkYuwCJ2718yaURgbRqfmlKNdECyy4QIDAQABo1IwUDAOBgNVHQ8BAf8EBAMC +BSAwHQYDVR0OBBYEFEQ91872uHULE2j0VfkvlMW56822MB8GA1UdIwQYMBaAFOln +fRB0wZquuEw/CT4ccBXdHxpPMA0GCSqGSIb3DQEBCwUAA4IBAQBZIyZsem85ca5U +Fzz88Bvvl2oKsIW8ixlhXkc4fA4pzcuXmgt0l31dO6NTEkxfDWfIinENB7kEmNmE +XD6Cll/uvtKICViAZMdrYZZZYkToyrN6Jkrf+svdjfk4Bjr1ufixYSzj6NIb1KIa +9vgyG0LGLEzDbUH3XCnmgYHc/c/6nt6ZoN/iVROmgcTafOv3S9/2ertAFPEpdRxX +Axj3V2qgguBJCyhJ7VuaBhJhpWgHUjtzH61etyLoCMVKTaR9L8ocS217LeGCHKto +d3tuL7nQctvpTqG7jvvujUlPs2uKY0Fzsqw66ez51mWVyop9rkvudkZIZ0ftMYli +DcOpACyZ +-----END CERTIFICATE----- diff --git a/test/recipes/80-test_cmp_http_data/Mock/kem_RSA.key b/test/recipes/80-test_cmp_http_data/Mock/kem_RSA.key new file mode 100644 index 0000000000000..deb103ad68826 --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/kem_RSA.key @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDD0ZhbZAyORndQ +k4kvfLrlxChcP3/UnkEQ8aO4koEROfErzGdEy1oVCIMCDmrDG9GKU+TfyFia9tVu +8aasbBanALjL14d4XQYvf3AbNZbihjuSqL4P2O/LmScGm8Hp2fQNCMCbTW6KBTbp +i0IBntVrz78CeTCnjX6xUrPCAoGfX2gEwdTVg11QIUQ9Hl3bIzvYwR4caGNNnJsG +bj654I1I3PIL+NkynLegdeWaUkTaa8Sw5BkDifrEhR75HCiR8BeXBgWXX2lt2Pkb +jYiEvOv1lK7q6+OblG8LGg92a1BnoXFoFQ19EwaOoQ6Ri7AInbvXzJpRGBtGp+aU +o10QLLLhAgMBAAECggEAJQLhnCx93wpclOM947bckH8R7dWmsKY0wCIcAs/WC057 +Uf7xaeRRo3YXZPUaosQIR+/xa4avkKKk1rJgAWjwoyIUy5pyJYLXn3Sj2NC5MxmR ++vdf7Rjgwgexg6M+9JdYdHo6BWCOSxIPPfcvQ6Uky5rZjHshghnRX2y1Qy88FsYZ +5TUMa7qQjbtzZPM7dePCvHy0Euw3ggjyzwN4n/TUm9U9AlEUfNWvjP56RjLHrUBc +kiBbdMgvipu5/MMq5V63WpWxUrCOFnyofOsfuZ632CVfxy4d6fiBX0KrD0I96A1Z +GrelDpuyq7/GL6khiO3IBkOUJgsZO/lgTCq/gd4iEQKBgQDqlv82MGDWaX2tSszW +l/tvTR1y1aV9IcqLi32r9cuLIVNA7aJoWQLAtt5KRiE7pT6BZ4OEGbhAS+t+jXON +UTqc8ixa9/TRhEA4aVrhevLfOIJfaT2TNCivuuAHXKmXPM8IqArfnZyat7p8Xfp6 +vNxYxWIga8CZ0ogLB+RUmqhx7QKBgQDVsL4Z8q1XF6kgL8oRyiA+IA81Jw1qL4f5 +Hpg1nJlY29ajQqBz6RPJmMN/X5Pt5/xD9WOGZwFxATkUXzwSQw1hfHdggOonVuNc +SONCBinUtq5TdpB4H7LFqbaVgSrU1YZPiQekTyv+hfsYN4IOLCDuQxgxZ4moiHf5 +sQP7+/Y2RQKBgGyWeIwc2LZnHkWY2jh7IWfjyj3dpzzE53ywlPuESzObuW3Ukdi7 +WwrZmwvGapuxYb2ErNv5C9C3U8rArzw63WbIsr9pB2n0TcXO/sJgpwusnKyNinMZ +MbwmRI0j11yqSSs4nc/kpRj48tmeptMpmNV+iG15cy3AxjhU7tw6ur4BAoGBAIU8 ++Zs2PCyEnThrc8QZ0nbKCJFssymVT2PeVqt+5AKKuE79eQwstODLNoJR9uus7Rb2 +h0LDMRvj1lJEezEry8kQEWMDnnw+6e6dp82ACE8QRKvXzoaHxTEH+8dGTY19QYyP +9UrW7qh5o7Fa0uXBUBsfjJMpaqTByoTOgZx5YvA9AoGAUsqA4GdiBt+HCJv+uwP3 +21XcxdhwmT9PYMh7MdONpe9kEZUu1o/MVuCSascsF5qIewIlynqnACoS/E3yILxy +/Q4IyxJpvaocvO94xvHYa1T//FQG+JO7gOjLyF5c8IK7V3O+luxRy1I99Y87ePlq +aPBrRRPu2ZIxrPmdPmdNp1s= +-----END PRIVATE KEY----- diff --git a/test/recipes/80-test_cmp_http_data/Mock/kem_kyber1024.crt b/test/recipes/80-test_cmp_http_data/Mock/kem_kyber1024.crt new file mode 100644 index 0000000000000..3af72d02f46bf --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/kem_kyber1024.crt @@ -0,0 +1,48 @@ +-----BEGIN CERTIFICATE----- +MIIIbTCCB1WgAwIBAgIUenD0adt4paVWXXt99SFndc81IlgwDQYJKoZIhvcNAQEL +BQAwWjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClNvbWUtU3RhdGUxITAfBgNVBAoT +GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDETMBEGA1UEAxMKc3ViaW50ZXJDQTAe +Fw0yNDAxMTAxMjIwMjBaFw0yNDAyMDkxMjIwMjBaMBMxETAPBgNVBAMMCEtFTV9D +RVJUMIIGNDANBgsrBgEEAYGwGgUGAwOCBiEAgnCeD2wSfUcRVHJyW3a7EkiGw3dj +IRhld6QbJOE02BYn5zyqIBWsKgYo4vVIafwA45lujTjCTQFSkLy7z3panly5u4qw +J6zINNOb5/PEuDtk07l/65OAAYW8erGwPrazaGxnwCEVIRCK5WW7tFUSoTMQ9Zef +fcNnVTVl1RIMSXvB9eIVv8J2eMN7VNrKnPcliUAALrC6lVeWMGOa1Bghs3VB1NXM ++iGKHFlqeoZ153CLNvSuqyaIGYRNv2p9q4bKKuGL97u6DbtBdFFKpCTGiqKTahcB +aRFjGBAb61S3Riun7ssgqSEv/zKGEFbOuBBaxQnGqWTBWJt9OoYg06xgSqWmE7in +JmZLdaGxCLg26rdnCCwz5lB25aCD0WBxHFIX+7d4/BXN9wmdW9aaBBpZHjnBDAcu ++AwN5suYpMScVtldFTlHLqoRzlIWEjVVAePIHBwBkQM2COYn4BSdIksLa/gtWqI8 +IjhCDxOJ/eVwPBim7Qcpnjeerjd19+arcYFuE/tresctWrVob5XFDqCFPesmTMpF +fWxpZ+CU3pqSf1ZsnmVxyKuCvbAohSxCDWCgpGygP8RQ7ySpAfRAYpUsGquS4zVK +CJKicqWjZKCOqGNCp6Ut2gKbx6w60vKsqIJL0QGklUzJxkM1cJx7kiCuXoOqlrrO +kbqAtDdVJco40eXFf1U3Dho1MrzNvTeDVLkc8mBRUMw6wXbHIqyvuAzKlrRZhPO5 +jfOrqyTI/HqzPjYbl6h11ytu28hda9wRRbLEFBgmqawWUFUXGQZCQBsX11KTpKG1 +V1Jj30YCmSJmSBZKaqK8bUVFHEkoBEuaXxCpxqJocxEtSXGuhPUJl7Y4B+NVtoN9 +UFKZQqgqQIEgYvALjGKHyKFw5ty4C1eF0/dm6Tg47Og2lpEz3IyRrNswWEWAyveh +4PXO24AIxjiJdGWjz+CZsHDOEdoouDINc3QKxvBxHQozvmQwlmC20JnIZ3OXBDIk +i3DNg+lJ/OZ6QYs4buhzHBiqRqgMSMKuJ5K1qfKN21m+RuOGAJY8LKWPpJYK9Ve8 +jToszoi3k8WpRqRHhKcTOdKcdGVXnBxcFeCfrQHQpdmG8Dme8yGpFfErV9e3mjEV +CTgx1buQLSS0bfQZeMOnGrkUkcWAl1YdO1k0NZWre5t/vzCoyrKK4fYdiEVWbGuJ +a+yEYowCC5Eiz1EhKayzMhND0roHqyeAFtIf07wezcoqYRLOPWYArlDHDFmYgCw+ +LdVvgSKZ8GpvVlVYmzh8V0Yj/0CSzlex+EMGqmKNOVd+uUF5KFvBSDZgcSZzrVgN +SKlmskNrVTlR5jRJ9IcqpUIYaDq6AgR5GGOTLqFfIHbFMxglTfBXTptzunNqTUsQ +8BqDuhCHgqmgH5uPPUHLRBtNaHUh7Gkk/1QrHeEL/TUucOx1U8l/aYEr3FhYkKZU +exYSXrrLItOylKyxW6BOESeSUaq3ofp6KcuBS2oCdJVqoYGlZyCbssqYWiqKshWS +B6Ua15FgPchlJ8iyNxqK9hlASBkMsKvDntPCpmuFK/R0QycNlMR/m2dnIHdESQiu +N5mJQhoL/kusDcGGtVuV56axRbXEw6ACoShY/lBReIJzurO1sUqLAoO3bWrGOvqJ +hnQGsgBSUZs0jqA73NHJzrd9bvlI3TOYdEgzdqZVabnKPzR8qTuxDglnFBiQiJmO +4jefp+fB3XALNJh379OTH0Wngppt15SxOAEk+guTPDEy4pNUxFW9IrzFWiKZmVdb ++tQdVXBb4lSGxugP3fUyKjEaEnCy6tbHCopcPsi126RK4QnKmqlwaSHHyvyYTQgD +/2pnf2IpPJFB3IS0Bcm5TQE3PfcLSkPOopF17DrGoWmW/SiTT2dJbOky7pgHA9xX +VEF2NCtMWMgJ4PmC8ci58hFJyLmmNZBSy9LC/NSs9JYHAYJ0HmGpUoSBV8E7OHB3 +ZACsxwMkwzYxfjtmpiyvUSlAgdjOXGcamLhsMaxbk4MDC0xSZzRLQ3i6emOPt6NY +7JMq6jhb6Uu/k2COZleIUsQ6G0rBQSeJECVW3vdWHxK6zsDsbCzn8yj5gwOPEHNv +aIB6gLtYUaoe7bGjYDBeMAwGA1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgUgMB0G +A1UdDgQWBBTIXhEhWdEMkDP+XTfpHgk5OT4PEzAfBgNVHSMEGDAWgBTpZ30QdMGa +rrhMPwk+HHAV3R8aTzANBgkqhkiG9w0BAQsFAAOCAQEAwOJPi4A9GoKmo3oOSRkQ +clW+16bFPPpmyi5cmdxDgG1fJPRAj25dk7qGIY2dMIZIOJBNuQz4D/VboIx53dqG +b6jJ2G1fsXbOqrcsn5AngHJOr4zHuEO1q3737MQ8wIBRX15cPyLPBiAFEqmR902N +STvD/XbAJmuIqRAOZKa1iyS6CLu9/Z768YaaM/hS6mS3/9r8upefO4rUbFt+3na9 +D+NSHpAvgmA6DOQWdPiDChdqW2UPBeoif7jqbBUKwR55HiCWcSxhRsXACY7FlHBk +6VFF+DO+pfjxONgC5q1eu0ELzfWBNdzuW/csRY9nOyCMnqm+U4Ait4Zrw0WcE1Ps +Cg== +-----END CERTIFICATE----- diff --git a/test/recipes/80-test_cmp_http_data/Mock/kem_kyber512.crt b/test/recipes/80-test_cmp_http_data/Mock/kem_kyber512.crt new file mode 100644 index 0000000000000..c74ce11855ac0 --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/kem_kyber512.crt @@ -0,0 +1,32 @@ +-----BEGIN CERTIFICATE----- +MIIFbTCCBFWgAwIBAgIUfA690OmMhl3gMNStJ68TUY2MyCUwDQYJKoZIhvcNAQEL +BQAwWjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClNvbWUtU3RhdGUxITAfBgNVBAoT +GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDETMBEGA1UEAxMKc3ViaW50ZXJDQTAe +Fw0yNDAxMDQxMTI0MTZaFw0yNDAyMDMxMTI0MTZaMBMxETAPBgNVBAMMCEtFTV9D +RVJUMIIDNDANBgsrBgEEAYGwGgUGAQOCAyEAZ/CNJhMFqCo/bsOHD5gCS4Vf5OUW +ZatuBZs89vmIV2ZoJEWuVCqLD8JqGNXHgtwNZcQBpgydpyRPU0a6iXhS86YNrGAf +0gdAuDihRKoALsumXpZMBLcZlzkA85tC2ht4QtU3jNjPzaZQDyM8AfrAVGe2jzUF +fgJg+1aRYqyM+5h12FePkddG6cYmYXWA/Vc2KEsI1PAxwlab+PxIc/I6VOiSj+gI +ivkWurSvQIqL6/gvhJE2LOQ1+BRPYlm9orayXMNWskFp0XGlFnM2+PPFycuE2fGo +KxhO7zEhhkEA2/VgNuGWUImtHpWv95ukMLYAH5NTFDuWlyMhBALB58mhcLaA8yUn +VlBex/PPx3wBp/ITV6VRQqe6lGOGK4zNZwVP1nO0eiuc1GRJm2KfCvJ2vtWPioFG +9+Gs7XuMzxYT4yKN+erH1jUYmzYgPQeeNbrK2pMTYAg8KBgsJMuXkuGKYWCkUnrG +7bwv8ztl9MpfMmu8oBk9Upw5RzucV9gWNTpQDPqfvMNwerm3r1ioGXgKDROnR9U7 +/sk9xgrFheUH2hzIO5oFAgHJpeBFjiM2XGCtjSYDvkIsleg2gwxyFIjHWfoE6ml9 +eByvBToTPPZDOynNIUtGgTVyyMZxYHV+l8k9qbwmEPQHt1MD7gujb8pDMuMALdGN +hPEZPFUrLsuvbzkeNtS+8GsHdeSQVKeutwlUt4vAVsBtdcVPGZhmcAe+6xViVtVW +BMHIY3K0ymzEiwtNvsoA+tRESEu2KDYuLTqxUYZI8KRQTFpTidOhwMnA8yCoDcgh +OVVg/HxlRfDO1Rln2NUG4qERl7Ct49BJ85pbrPlKsXQJ8PCNRPIDavAzqbZD+7E6 +Zzl6b2VRs1Yeh/wW8ZJwDFExFwbG9JFEi0g193kPv+lN7fKKQBUmn9SayblYNrgv +2XWVCKS9IJmvF0dTYDIiQTyacox78mYj5eE5Pjc218N7btzAZ3g48IOaPQMSMdyx +8pcuRKlhyXe6adSyunItRKeRKcRP33e/K7da/9PPYf/q0YwKv7p3/p5o2dX2A3tW +2oEYnj9TF1DLdbmjYDBeMAwGA1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgUgMB0G +A1UdDgQWBBRBOTsoMHl1ufkf08tCY2MYzdqT+zAfBgNVHSMEGDAWgBTpZ30QdMGa +rrhMPwk+HHAV3R8aTzANBgkqhkiG9w0BAQsFAAOCAQEAVGCzVF2up6jGwXahQ3AU +78SC4JDcq8DbkwKtgXy2mcybvvmyBYnOckLVjqfrUg5KHmZjvo1NBeQn8+a+o6IP +KcAqpwxCeYLM5znkb4ZGM5wL/mIk4oJpaW+Rk2fZ0gREzHiBnHw5B7qEyHhTLdy/ +cGi9v1d/YRdcWhBkbgKgkAcCmTPk7TNec8AUoi14IF3/dONq3i3XfXEQDqioKbA9 +2EPWJvst4amh985lnxGqeXGaXv4GmAq4dxGWHVOzaQN77b37ZqCUSyhWVLb1/GRd +yDffUHEq3nELIVsiDqDcTOAHo5LeBkTl7y4MFAvnc8sM3x8SLXz+MMzPDl5iM8ky +HQ== +-----END CERTIFICATE----- diff --git a/test/recipes/80-test_cmp_http_data/Mock/kem_kyber512.key b/test/recipes/80-test_cmp_http_data/Mock/kem_kyber512.key new file mode 100644 index 0000000000000..d744acc09ea3e --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/kem_kyber512.key @@ -0,0 +1,54 @@ +-----BEGIN PRIVATE KEY----- +MIIJmgIBADANBgsrBgEEAYGwGgUGAQSCCYQEggmA3siLORoUTyZkXnxyGrrBunCf +5emZcxZT0iZgZgBl0Fwpi8mRc3ODTjh0WNDHNBzKNyBnYiC/cdnNg2xjjNY/sTcR +0Cw3VZByNYiGwwkkbqVIfodX1aBUuoBBmFvANEAbLJizw+ZY0ZilQvyNp4psfiN8 +ESI2NCEqamgA8RWbPfQ5rLQNzQlg17KTByldGJylw8SKg0aauQEfswS9j8NcUxMz +BAKeQYKv9xI+pgNSx6wAlfq4VnyLT5oGYcAUF2tYb1xlj8hkTIQAz1lf0Mg0d1h1 +U0kyD+NxzvsVjhYy7+fAakQX+WV9S+xXBRg8zAkQZjNu0gdX5tpAcAwY44wmj/ps +BdAy0ycUVehXgKMmvyW3h3En9Eaeq5tJwirChnnM7cQ04hiJsBZXLmO3cTy7lFMv +8YVmCuenmWKcS+EpPlR59XZxvSTA8JRhkolc9TbIyrCuq5Mb5TujpQFpy+ex9KGr +AKCkcmlvuWkaOfJIFTg/MtxietM7b/lIuHaj+tMWBeh8UnEbLhMKAxNupZxVYXgU +vUh/59Mhw9NqmPEKtfxHlbcd4GlnBYeOlGY1G3crdWnFwCI8orYKUSxkoGt5GpNP +xvWnuJom9Zo+GFK6gBsrC0ka5nYtYTp74dOjZnOG/xupAVmuHpmY2tnBNQyebhkX +vhGG/jK+yNeMVPc4rYPLqKAhsUudzVdkUOYhuEfBjAQ+kiqI3yxzk2adRmKmwYOD +YUBZY2ye8VYaiycNyry9zktTZoApRTODkshg+ARDNjKyMQJvHRZzF3V6SIwnEHA+ +T1zF8obArGifmCAU9sMRtAOIoYNocGGJPesSKEq3PSKn57U309uyYNEi1XGFCLBT +m+uvngYRT1QhG8rF+QsQWuOCUvA1u7zBQVLFd4dq/HCP20EqZcFNLRJNc6KPMFNY +t4BnKvePVNlVV4m04LyQFkOeIERPhws+WQcIj0QnYnYJlyNt1iM56nRyd+PIkvAP +56YflcJ9V2t+m8AnJVgbzQBdrZc3RgMn5pSdO/JZZ/CNJhMFqCo/bsOHD5gCS4Vf +5OUWZatuBZs89vmIV2ZoJEWuVCqLD8JqGNXHgtwNZcQBpgydpyRPU0a6iXhS86YN +rGAf0gdAuDihRKoALsumXpZMBLcZlzkA85tC2ht4QtU3jNjPzaZQDyM8AfrAVGe2 +jzUFfgJg+1aRYqyM+5h12FePkddG6cYmYXWA/Vc2KEsI1PAxwlab+PxIc/I6VOiS +j+gIivkWurSvQIqL6/gvhJE2LOQ1+BRPYlm9orayXMNWskFp0XGlFnM2+PPFycuE +2fGoKxhO7zEhhkEA2/VgNuGWUImtHpWv95ukMLYAH5NTFDuWlyMhBALB58mhcLaA +8yUnVlBex/PPx3wBp/ITV6VRQqe6lGOGK4zNZwVP1nO0eiuc1GRJm2KfCvJ2vtWP +ioFG9+Gs7XuMzxYT4yKN+erH1jUYmzYgPQeeNbrK2pMTYAg8KBgsJMuXkuGKYWCk +UnrG7bwv8ztl9MpfMmu8oBk9Upw5RzucV9gWNTpQDPqfvMNwerm3r1ioGXgKDROn +R9U7/sk9xgrFheUH2hzIO5oFAgHJpeBFjiM2XGCtjSYDvkIsleg2gwxyFIjHWfoE +6ml9eByvBToTPPZDOynNIUtGgTVyyMZxYHV+l8k9qbwmEPQHt1MD7gujb8pDMuMA +LdGNhPEZPFUrLsuvbzkeNtS+8GsHdeSQVKeutwlUt4vAVsBtdcVPGZhmcAe+6xVi +VtVWBMHIY3K0ymzEiwtNvsoA+tRESEu2KDYuLTqxUYZI8KRQTFpTidOhwMnA8yCo +DcghOVVg/HxlRfDO1Rln2NUG4qERl7Ct49BJ85pbrPlKsXQJ8PCNRPIDavAzqbZD ++7E6Zzl6b2VRs1Yeh/wW8ZJwDFExFwbG9JFEi0g193kPv+lN7fKKQBUmn9SayblY +Nrgv2XWVCKS9IJmvF0dTYDIiQTyacox78mYj5eE5Pjc218N7btzAZ3g48IOaPQMS +Mdyx8pcuRKlhyXe6adSyunItRKeRKcRP33e/K7da/9PPYf/q0YwKv7p3/p5o2dX2 +A3tW2oEYnj9TF1DLdbkS5Puj8svmiVL8D5+4t/et+e3JgoPwFRXw9qOhqjmzR8Fo +v/gvZUoVIJ6UD+BBbW+EtsTQQu0mS6MQkaqXmT2AZ/CNJhMFqCo/bsOHD5gCS4Vf +5OUWZatuBZs89vmIV2ZoJEWuVCqLD8JqGNXHgtwNZcQBpgydpyRPU0a6iXhS86YN +rGAf0gdAuDihRKoALsumXpZMBLcZlzkA85tC2ht4QtU3jNjPzaZQDyM8AfrAVGe2 +jzUFfgJg+1aRYqyM+5h12FePkddG6cYmYXWA/Vc2KEsI1PAxwlab+PxIc/I6VOiS +j+gIivkWurSvQIqL6/gvhJE2LOQ1+BRPYlm9orayXMNWskFp0XGlFnM2+PPFycuE +2fGoKxhO7zEhhkEA2/VgNuGWUImtHpWv95ukMLYAH5NTFDuWlyMhBALB58mhcLaA +8yUnVlBex/PPx3wBp/ITV6VRQqe6lGOGK4zNZwVP1nO0eiuc1GRJm2KfCvJ2vtWP +ioFG9+Gs7XuMzxYT4yKN+erH1jUYmzYgPQeeNbrK2pMTYAg8KBgsJMuXkuGKYWCk +UnrG7bwv8ztl9MpfMmu8oBk9Upw5RzucV9gWNTpQDPqfvMNwerm3r1ioGXgKDROn +R9U7/sk9xgrFheUH2hzIO5oFAgHJpeBFjiM2XGCtjSYDvkIsleg2gwxyFIjHWfoE +6ml9eByvBToTPPZDOynNIUtGgTVyyMZxYHV+l8k9qbwmEPQHt1MD7gujb8pDMuMA +LdGNhPEZPFUrLsuvbzkeNtS+8GsHdeSQVKeutwlUt4vAVsBtdcVPGZhmcAe+6xVi +VtVWBMHIY3K0ymzEiwtNvsoA+tRESEu2KDYuLTqxUYZI8KRQTFpTidOhwMnA8yCo +DcghOVVg/HxlRfDO1Rln2NUG4qERl7Ct49BJ85pbrPlKsXQJ8PCNRPIDavAzqbZD ++7E6Zzl6b2VRs1Yeh/wW8ZJwDFExFwbG9JFEi0g193kPv+lN7fKKQBUmn9SayblY +Nrgv2XWVCKS9IJmvF0dTYDIiQTyacox78mYj5eE5Pjc218N7btzAZ3g48IOaPQMS +Mdyx8pcuRKlhyXe6adSyunItRKeRKcRP33e/K7da/9PPYf/q0YwKv7p3/p5o2dX2 +A3tW2oEYnj9TF1DLdbk= +-----END PRIVATE KEY----- diff --git a/test/recipes/80-test_cmp_http_data/Mock/kem_only.crt b/test/recipes/80-test_cmp_http_data/Mock/kem_only.crt new file mode 100644 index 0000000000000..682e062f13809 --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/kem_only.crt @@ -0,0 +1,22 @@ +-----BEGIN CERTIFICATE----- +MIIDkjCCAnqgAwIBAgIUCIoReKKPB6Yh4B0HEeykhscAQ68wDQYJKoZIhvcNAQEL +BQAwWjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClNvbWUtU3RhdGUxITAfBgNVBAoT +GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDETMBEGA1UEAxMKc3ViaW50ZXJDQTAe +Fw0yMzA3MTMxNDM5NDVaFw0zMzA3MTAxNDM5NDVaMFgxCzAJBgNVBAYTAkFVMRMw +EQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0 +eSBMdGQxETAPBgNVBAMMCGxlYWYtS0VNMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAw9GYW2QMjkZ3UJOJL3y65cQoXD9/1J5BEPGjuJKBETnxK8xnRMta +FQiDAg5qwxvRilPk38hYmvbVbvGmrGwWpwC4y9eHeF0GL39wGzWW4oY7kqi+D9jv +y5knBpvB6dn0DQjAm01uigU26YtCAZ7Va8+/Ankwp41+sVKzwgKBn19oBMHU1YNd +UCFEPR5d2yM72MEeHGhjTZybBm4+ueCNSNzyC/jZMpy3oHXlmlJE2mvEsOQZA4n6 +xIUe+RwokfAXlwYFl19pbdj5G42IhLzr9ZSu6uvjm5RvCxoPdmtQZ6FxaBUNfRMG +jqEOkYuwCJ2718yaURgbRqfmlKNdECyy4QIDAQABo1IwUDAOBgNVHQ8BAf8EBAMC +BSAwHQYDVR0OBBYEFEQ91872uHULE2j0VfkvlMW56822MB8GA1UdIwQYMBaAFOln +fRB0wZquuEw/CT4ccBXdHxpPMA0GCSqGSIb3DQEBCwUAA4IBAQBZIyZsem85ca5U +Fzz88Bvvl2oKsIW8ixlhXkc4fA4pzcuXmgt0l31dO6NTEkxfDWfIinENB7kEmNmE +XD6Cll/uvtKICViAZMdrYZZZYkToyrN6Jkrf+svdjfk4Bjr1ufixYSzj6NIb1KIa +9vgyG0LGLEzDbUH3XCnmgYHc/c/6nt6ZoN/iVROmgcTafOv3S9/2ertAFPEpdRxX +Axj3V2qgguBJCyhJ7VuaBhJhpWgHUjtzH61etyLoCMVKTaR9L8ocS217LeGCHKto +d3tuL7nQctvpTqG7jvvujUlPs2uKY0Fzsqw66ez51mWVyop9rkvudkZIZ0ftMYli +DcOpACyZ +-----END CERTIFICATE----- diff --git a/test/recipes/80-test_cmp_http_data/Mock/kyber1024.priv b/test/recipes/80-test_cmp_http_data/Mock/kyber1024.priv new file mode 100644 index 0000000000000..1977ebf10b552 --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/kyber1024.priv @@ -0,0 +1,102 @@ +-----BEGIN PRIVATE KEY----- +MIISmgIBADANBgsrBgEEAYGwGgUGAwSCEoQEghKAKPxbIfWzBZUJDKBIVLpE9cax +8qFDRMlyeNeZyohP4sdaM4k4uOtWxkeTqGGobsVeLMMtiuCeRvRIL0zOKWCKyeKD +5mPA8JDPbmM8EjpX98uv30Cq6hwRuOxQPJxMnNWMveY2B6WiFEiSvaVDMBHA2/Fa +BokxdLOB0wqLnJpEuHxPRQKOWRaPmIy0p9q9P6sXUdW+rwE6Qwp8F6pNWmRW++gq +DixKc6ZtSKEijDVRWfgqZJixo5yL10SS2lNrRyFi3IsARpJriznNhejDcrYAufEg +8gWwMEAn49sRLrwU3JBGk4tfE0F5OcE+nvrAy3a+fjOkSytnmPeL1/RzrMZ5QmOL +rtIOLtugTJYJGxlArKAEtKiZyrOUa2Y0ltpyINap9RhZ4wg/k8CqBUlIetddZ5BN +fzDB9gEHETl3HHmVychszoovpOqi0xkifeK1z+sDgBPNsFZF2AGMqLzJ1ntWRKGa +9tAlrfWJL6AvXvAb7KKCqOZeXYJFLThQVNxD3+Z01KbA4GFKteOiMUKHmYS89QNW +/NskyiYMJduP/3SlwQS5Hix2PsCyZwR2dVIXdfGZX1EJ9IJFBik/LSRSdLlD2WUJ +zoRqSUUI0mYG3nd8fKq5iLkCYBCWhdQOODzNkQupKsV94vg++SOee+cfrXvNuoxN +blUsVsYgWSyegJAFkYsBfVyz83pkphpLzmJiQyoogkYVu9SI8hA2fBU+QbNRCiOe +aKVRzftFN4pEbFmVnNNkA8SyUzBqUmwYAGgl5cY4YHAkorpdMteRkRWjxGGxAHY7 +BOy658ixCNJtFPAG+7ptD0m/FrTEI+tx+fQnp+liS8lbcxBqIVI4vEe4H6msmqF7 +U9kfzbBkBUuF+NG7yLkJ/QKkmuQfAM1og/UNtJtLj4moKmeNzRnE/EaaSdxIBCxT +xpIATAcRXtCPPxV2z3kMLqZAiwEMSwo9r9lqxGLIWNso22tSf7gcObd2LKrOoflX +zdrPqXymWZqEHnCf1BlKzBlT1JMDZtaw1XUlMmQDsHNZFGC1wuRS7juWjOYkm5hn +3KNFw6cCVznCsrWxosjF2SAAdkoGJsG423tmRCvLggl5xyGqCbR63BkiXedDI7y5 +FDhLK7Z3zGm87oAsPxGVlAqt+XpCHLBQ9hKCAWHFaNQ13dIv72CIxEYg72eCDHGp +FpJJIfKwBAabnrpu9mWMrrpoiSE2vUZ3fQSBxzhm+XmsGaB0nRELh+XCoRsEfdYb +Y3WQZrolXIIfIKsR9tnCn6VGrQjLgkyB7bCAuhSVkPzPA2S5oVqAszxigeawHJaG +9SUnvLtffvie10A5sRISz0R5U6qui1kSyNJ5VQy9i5ZhCWUuyDbAz7MyvPITgTzK +PmIcLbxPAdgkb5aMovi377EKFTVhflw8dFQ2AlWPrWyBZIc66YNPs6Krd8Fozpab +AEFjCDg66WwDquIkcNVIOFJOXJszotkSEDoBUIGobsEYdilNKyMeIPU4ZFu/oDbE +gNSVorahT1WwdIt2BbgpJfhFOsF4k0WH8ONCThizPTOH5hiyHfdbhJBZmtFVNLM4 +YfzHxXU/blm6A8KBPjQo3VgyqhsLgXdQjlvJOTeA2kw8MWIatyFdW1PJsuVM79sH +NRHFTlu1K8M/FrnNLPMyqobPzleqK+N1ujaJFzeyimh3WPl23qkIXjZ9HbO38dFD +l6J4xSdZ9iMwbPZjZ4DO62c0IQZkqQwqB9OLRoBxh9h/p2QHaAE9EhLF+3YYXkYy +GXaE7atMBkQSahNnGkgMQolkLAGPcxIwyDKx+3vBpYLFbpB7MRC7qRddJ4mMziuk +kHvNoVIvReBGVbCh2ByLLiM1O/lU8ZNeKwEMwlF9BBLDjnafhFXD3Bm2xStu9Xqf +i+YLlVpYxuwqNNlvOLKAx7o8GFubTqlFqaNrj6S+GgwKgjs256JlUmIF7mAn9pKY +t4xDp9qrOkUp4vqCnpUZgowg0HE2JqJn3hzLPoRBP7M8XzwjJGl2+TJUKAEl90m2 +DLqRwwEDG4EB5AuKhHSe1Qcqned6FQSGIxmh9GeXgnCeD2wSfUcRVHJyW3a7EkiG +w3djIRhld6QbJOE02BYn5zyqIBWsKgYo4vVIafwA45lujTjCTQFSkLy7z3panly5 +u4qwJ6zINNOb5/PEuDtk07l/65OAAYW8erGwPrazaGxnwCEVIRCK5WW7tFUSoTMQ +9ZeffcNnVTVl1RIMSXvB9eIVv8J2eMN7VNrKnPcliUAALrC6lVeWMGOa1Bghs3VB +1NXM+iGKHFlqeoZ153CLNvSuqyaIGYRNv2p9q4bKKuGL97u6DbtBdFFKpCTGiqKT +ahcBaRFjGBAb61S3Riun7ssgqSEv/zKGEFbOuBBaxQnGqWTBWJt9OoYg06xgSqWm +E7inJmZLdaGxCLg26rdnCCwz5lB25aCD0WBxHFIX+7d4/BXN9wmdW9aaBBpZHjnB +DAcu+AwN5suYpMScVtldFTlHLqoRzlIWEjVVAePIHBwBkQM2COYn4BSdIksLa/gt +WqI8IjhCDxOJ/eVwPBim7Qcpnjeerjd19+arcYFuE/tresctWrVob5XFDqCFPesm +TMpFfWxpZ+CU3pqSf1ZsnmVxyKuCvbAohSxCDWCgpGygP8RQ7ySpAfRAYpUsGquS +4zVKCJKicqWjZKCOqGNCp6Ut2gKbx6w60vKsqIJL0QGklUzJxkM1cJx7kiCuXoOq +lrrOkbqAtDdVJco40eXFf1U3Dho1MrzNvTeDVLkc8mBRUMw6wXbHIqyvuAzKlrRZ +hPO5jfOrqyTI/HqzPjYbl6h11ytu28hda9wRRbLEFBgmqawWUFUXGQZCQBsX11KT +pKG1V1Jj30YCmSJmSBZKaqK8bUVFHEkoBEuaXxCpxqJocxEtSXGuhPUJl7Y4B+NV +toN9UFKZQqgqQIEgYvALjGKHyKFw5ty4C1eF0/dm6Tg47Og2lpEz3IyRrNswWEWA +yveh4PXO24AIxjiJdGWjz+CZsHDOEdoouDINc3QKxvBxHQozvmQwlmC20JnIZ3OX +BDIki3DNg+lJ/OZ6QYs4buhzHBiqRqgMSMKuJ5K1qfKN21m+RuOGAJY8LKWPpJYK +9Ve8jToszoi3k8WpRqRHhKcTOdKcdGVXnBxcFeCfrQHQpdmG8Dme8yGpFfErV9e3 +mjEVCTgx1buQLSS0bfQZeMOnGrkUkcWAl1YdO1k0NZWre5t/vzCoyrKK4fYdiEVW +bGuJa+yEYowCC5Eiz1EhKayzMhND0roHqyeAFtIf07wezcoqYRLOPWYArlDHDFmY +gCw+LdVvgSKZ8GpvVlVYmzh8V0Yj/0CSzlex+EMGqmKNOVd+uUF5KFvBSDZgcSZz +rVgNSKlmskNrVTlR5jRJ9IcqpUIYaDq6AgR5GGOTLqFfIHbFMxglTfBXTptzunNq +TUsQ8BqDuhCHgqmgH5uPPUHLRBtNaHUh7Gkk/1QrHeEL/TUucOx1U8l/aYEr3FhY +kKZUexYSXrrLItOylKyxW6BOESeSUaq3ofp6KcuBS2oCdJVqoYGlZyCbssqYWiqK +shWSB6Ua15FgPchlJ8iyNxqK9hlASBkMsKvDntPCpmuFK/R0QycNlMR/m2dnIHdE +SQiuN5mJQhoL/kusDcGGtVuV56axRbXEw6ACoShY/lBReIJzurO1sUqLAoO3bWrG +OvqJhnQGsgBSUZs0jqA73NHJzrd9bvlI3TOYdEgzdqZVabnKPzR8qTuxDglnFBiQ +iJmO4jefp+fB3XALNJh379OTH0Wngppt15SxOAEk+guTPDEy4pNUxFW9IrzFWiKZ +mVdb+tQdVXBb4lSGxugP3fUyKjEaEnCy6tbHCopcPsi126RK4QnKmqlwaSHHyvyY +TQgD/2pnf2IpPJFB3IS0Bcm5TQE3PfcLSkPOopF17DrGoWmW/SiTT2dJbOky7pgH +A9xXVEF2NCtMWMgJ4PmC8ci58hFJyLmmNZBSy9LC/NSs9JYHAYJ0HmGpUoSBV8E7 +OHB3ZACsxwMkwzYxfjtmpiyvUSlAgdjOXGcamLhsMaxbk4MDC0xSZzRLQ3i6emOP +t6NY7JMq6jhb6Uu/k2COZleIUsQ6G0rBQSeJECVW3vdWHxK6zsDsbCzn8yj5gwOP +EHNvaIB6gLtYUaoe7bEdH/Mi3ixboZPkdqNBb8PmY2dQkaypdNCOLWGUE2AWAOQJ +dhdBHk3xbolBhviBIdMUhH6svdfNP4+YD7Hz+MsggnCeD2wSfUcRVHJyW3a7EkiG +w3djIRhld6QbJOE02BYn5zyqIBWsKgYo4vVIafwA45lujTjCTQFSkLy7z3panly5 +u4qwJ6zINNOb5/PEuDtk07l/65OAAYW8erGwPrazaGxnwCEVIRCK5WW7tFUSoTMQ +9ZeffcNnVTVl1RIMSXvB9eIVv8J2eMN7VNrKnPcliUAALrC6lVeWMGOa1Bghs3VB +1NXM+iGKHFlqeoZ153CLNvSuqyaIGYRNv2p9q4bKKuGL97u6DbtBdFFKpCTGiqKT +ahcBaRFjGBAb61S3Riun7ssgqSEv/zKGEFbOuBBaxQnGqWTBWJt9OoYg06xgSqWm +E7inJmZLdaGxCLg26rdnCCwz5lB25aCD0WBxHFIX+7d4/BXN9wmdW9aaBBpZHjnB +DAcu+AwN5suYpMScVtldFTlHLqoRzlIWEjVVAePIHBwBkQM2COYn4BSdIksLa/gt +WqI8IjhCDxOJ/eVwPBim7Qcpnjeerjd19+arcYFuE/tresctWrVob5XFDqCFPesm +TMpFfWxpZ+CU3pqSf1ZsnmVxyKuCvbAohSxCDWCgpGygP8RQ7ySpAfRAYpUsGquS +4zVKCJKicqWjZKCOqGNCp6Ut2gKbx6w60vKsqIJL0QGklUzJxkM1cJx7kiCuXoOq +lrrOkbqAtDdVJco40eXFf1U3Dho1MrzNvTeDVLkc8mBRUMw6wXbHIqyvuAzKlrRZ +hPO5jfOrqyTI/HqzPjYbl6h11ytu28hda9wRRbLEFBgmqawWUFUXGQZCQBsX11KT +pKG1V1Jj30YCmSJmSBZKaqK8bUVFHEkoBEuaXxCpxqJocxEtSXGuhPUJl7Y4B+NV +toN9UFKZQqgqQIEgYvALjGKHyKFw5ty4C1eF0/dm6Tg47Og2lpEz3IyRrNswWEWA +yveh4PXO24AIxjiJdGWjz+CZsHDOEdoouDINc3QKxvBxHQozvmQwlmC20JnIZ3OX +BDIki3DNg+lJ/OZ6QYs4buhzHBiqRqgMSMKuJ5K1qfKN21m+RuOGAJY8LKWPpJYK +9Ve8jToszoi3k8WpRqRHhKcTOdKcdGVXnBxcFeCfrQHQpdmG8Dme8yGpFfErV9e3 +mjEVCTgx1buQLSS0bfQZeMOnGrkUkcWAl1YdO1k0NZWre5t/vzCoyrKK4fYdiEVW +bGuJa+yEYowCC5Eiz1EhKayzMhND0roHqyeAFtIf07wezcoqYRLOPWYArlDHDFmY +gCw+LdVvgSKZ8GpvVlVYmzh8V0Yj/0CSzlex+EMGqmKNOVd+uUF5KFvBSDZgcSZz +rVgNSKlmskNrVTlR5jRJ9IcqpUIYaDq6AgR5GGOTLqFfIHbFMxglTfBXTptzunNq +TUsQ8BqDuhCHgqmgH5uPPUHLRBtNaHUh7Gkk/1QrHeEL/TUucOx1U8l/aYEr3FhY +kKZUexYSXrrLItOylKyxW6BOESeSUaq3ofp6KcuBS2oCdJVqoYGlZyCbssqYWiqK +shWSB6Ua15FgPchlJ8iyNxqK9hlASBkMsKvDntPCpmuFK/R0QycNlMR/m2dnIHdE +SQiuN5mJQhoL/kusDcGGtVuV56axRbXEw6ACoShY/lBReIJzurO1sUqLAoO3bWrG +OvqJhnQGsgBSUZs0jqA73NHJzrd9bvlI3TOYdEgzdqZVabnKPzR8qTuxDglnFBiQ +iJmO4jefp+fB3XALNJh379OTH0Wngppt15SxOAEk+guTPDEy4pNUxFW9IrzFWiKZ +mVdb+tQdVXBb4lSGxugP3fUyKjEaEnCy6tbHCopcPsi126RK4QnKmqlwaSHHyvyY +TQgD/2pnf2IpPJFB3IS0Bcm5TQE3PfcLSkPOopF17DrGoWmW/SiTT2dJbOky7pgH +A9xXVEF2NCtMWMgJ4PmC8ci58hFJyLmmNZBSy9LC/NSs9JYHAYJ0HmGpUoSBV8E7 +OHB3ZACsxwMkwzYxfjtmpiyvUSlAgdjOXGcamLhsMaxbk4MDC0xSZzRLQ3i6emOP +t6NY7JMq6jhb6Uu/k2COZleIUsQ6G0rBQSeJECVW3vdWHxK6zsDsbCzn8yj5gwOP +EHNvaIB6gLtYUaoe7bE= +-----END PRIVATE KEY----- diff --git a/test/recipes/80-test_cmp_http_data/Mock/kyber1024.pub b/test/recipes/80-test_cmp_http_data/Mock/kyber1024.pub new file mode 100644 index 0000000000000..27e44365814d8 --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/kyber1024.pub @@ -0,0 +1,36 @@ +-----BEGIN PUBLIC KEY----- +MIIGNDANBgsrBgEEAYGwGgUGAwOCBiEAgnCeD2wSfUcRVHJyW3a7EkiGw3djIRhl +d6QbJOE02BYn5zyqIBWsKgYo4vVIafwA45lujTjCTQFSkLy7z3panly5u4qwJ6zI +NNOb5/PEuDtk07l/65OAAYW8erGwPrazaGxnwCEVIRCK5WW7tFUSoTMQ9ZeffcNn +VTVl1RIMSXvB9eIVv8J2eMN7VNrKnPcliUAALrC6lVeWMGOa1Bghs3VB1NXM+iGK +HFlqeoZ153CLNvSuqyaIGYRNv2p9q4bKKuGL97u6DbtBdFFKpCTGiqKTahcBaRFj +GBAb61S3Riun7ssgqSEv/zKGEFbOuBBaxQnGqWTBWJt9OoYg06xgSqWmE7inJmZL +daGxCLg26rdnCCwz5lB25aCD0WBxHFIX+7d4/BXN9wmdW9aaBBpZHjnBDAcu+AwN +5suYpMScVtldFTlHLqoRzlIWEjVVAePIHBwBkQM2COYn4BSdIksLa/gtWqI8IjhC +DxOJ/eVwPBim7Qcpnjeerjd19+arcYFuE/tresctWrVob5XFDqCFPesmTMpFfWxp +Z+CU3pqSf1ZsnmVxyKuCvbAohSxCDWCgpGygP8RQ7ySpAfRAYpUsGquS4zVKCJKi +cqWjZKCOqGNCp6Ut2gKbx6w60vKsqIJL0QGklUzJxkM1cJx7kiCuXoOqlrrOkbqA +tDdVJco40eXFf1U3Dho1MrzNvTeDVLkc8mBRUMw6wXbHIqyvuAzKlrRZhPO5jfOr +qyTI/HqzPjYbl6h11ytu28hda9wRRbLEFBgmqawWUFUXGQZCQBsX11KTpKG1V1Jj +30YCmSJmSBZKaqK8bUVFHEkoBEuaXxCpxqJocxEtSXGuhPUJl7Y4B+NVtoN9UFKZ +QqgqQIEgYvALjGKHyKFw5ty4C1eF0/dm6Tg47Og2lpEz3IyRrNswWEWAyveh4PXO +24AIxjiJdGWjz+CZsHDOEdoouDINc3QKxvBxHQozvmQwlmC20JnIZ3OXBDIki3DN +g+lJ/OZ6QYs4buhzHBiqRqgMSMKuJ5K1qfKN21m+RuOGAJY8LKWPpJYK9Ve8jTos +zoi3k8WpRqRHhKcTOdKcdGVXnBxcFeCfrQHQpdmG8Dme8yGpFfErV9e3mjEVCTgx +1buQLSS0bfQZeMOnGrkUkcWAl1YdO1k0NZWre5t/vzCoyrKK4fYdiEVWbGuJa+yE +YowCC5Eiz1EhKayzMhND0roHqyeAFtIf07wezcoqYRLOPWYArlDHDFmYgCw+LdVv +gSKZ8GpvVlVYmzh8V0Yj/0CSzlex+EMGqmKNOVd+uUF5KFvBSDZgcSZzrVgNSKlm +skNrVTlR5jRJ9IcqpUIYaDq6AgR5GGOTLqFfIHbFMxglTfBXTptzunNqTUsQ8BqD +uhCHgqmgH5uPPUHLRBtNaHUh7Gkk/1QrHeEL/TUucOx1U8l/aYEr3FhYkKZUexYS +XrrLItOylKyxW6BOESeSUaq3ofp6KcuBS2oCdJVqoYGlZyCbssqYWiqKshWSB6Ua +15FgPchlJ8iyNxqK9hlASBkMsKvDntPCpmuFK/R0QycNlMR/m2dnIHdESQiuN5mJ +QhoL/kusDcGGtVuV56axRbXEw6ACoShY/lBReIJzurO1sUqLAoO3bWrGOvqJhnQG +sgBSUZs0jqA73NHJzrd9bvlI3TOYdEgzdqZVabnKPzR8qTuxDglnFBiQiJmO4jef +p+fB3XALNJh379OTH0Wngppt15SxOAEk+guTPDEy4pNUxFW9IrzFWiKZmVdb+tQd +VXBb4lSGxugP3fUyKjEaEnCy6tbHCopcPsi126RK4QnKmqlwaSHHyvyYTQgD/2pn +f2IpPJFB3IS0Bcm5TQE3PfcLSkPOopF17DrGoWmW/SiTT2dJbOky7pgHA9xXVEF2 +NCtMWMgJ4PmC8ci58hFJyLmmNZBSy9LC/NSs9JYHAYJ0HmGpUoSBV8E7OHB3ZACs +xwMkwzYxfjtmpiyvUSlAgdjOXGcamLhsMaxbk4MDC0xSZzRLQ3i6emOPt6NY7JMq +6jhb6Uu/k2COZleIUsQ6G0rBQSeJECVW3vdWHxK6zsDsbCzn8yj5gwOPEHNvaIB6 +gLtYUaoe7bE= +-----END PUBLIC KEY----- diff --git a/test/recipes/80-test_cmp_http_data/Mock/server_kem.crt b/test/recipes/80-test_cmp_http_data/Mock/server_kem.crt new file mode 100644 index 0000000000000..0f181fc1cc3e5 --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/server_kem.crt @@ -0,0 +1,20 @@ +-----BEGIN CERTIFICATE----- +MIIDUTCCAjmgAwIBAgIUY18xWBn+yA7iONUUgVwZI8ion8YwDQYJKoZIhvcNAQEL +BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM +GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGcm9vdENBMCAXDTIz +MDgyMzExMzAyOVoYDzIwNTAwNzE3MTEzMDI5WjAZMRcwFQYDVQQDDA5zZXJ2ZXIu +ZXhhbXBsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANVdYGrf/GHu +SKqMEUhDpW22Ul2qmEmxYZI1sfw6BCUMbXn/tNXJ6VwcO+Crs7h9o95tveDd11q/ +FEcRQl6mgtBhwX/dE0bmCYUHDvLU/Bpk0gqtIKsga5bwrczEGVNV3AEdpLPvirRJ +U12KBRzx3OFEv8XX4ncZV1yXC3XuiENxD8pswbSyUKd3RmxYDxG/8XYkWq45QrdR +Zynh0FUwbxfkkeqt+CjCQ2+iZKn7nZiSYkg+6w1PgkqK/z9y7pa1rqHBmLrvfZB1 +bf9aUp6r9cB+0IdD24UHBw99OHr90dPuZR3T6jlqhzfuStPgDW71cKzCvfFu85KV +XqnwoWWVk40CAwEAAaNSMFAwDgYDVR0PAQH/BAQDAgUgMB0GA1UdDgQWBBTA54S/ +6FknMxCwUk9RUi8G1sB6zTAfBgNVHSMEGDAWgBSFVok14p8AGuGGAwtLr3YSazNt +/TANBgkqhkiG9w0BAQsFAAOCAQEAfxROf0sO5hj4rqA2Eozz0XCjb7zUKFfiGa0J +Ic0GPmfxsv0IPgG/hdBr8Vx3TU33if3DCnRNrzoo5/hYK5IHyfGwVt/TFb3w7OAl +xLCDh8Vck/G20efxRjwPwZ/hVvxFHN1/eJeh9VCsLezaU+fYKa6OJKYc2X+ciw33 +Ej8NSHWNFuqCawFHBeD39RFJTRxMxZI2ONXX+ZWMP4ixg8+L5Ky6VZpcmiI13vii +teadqT+BjCLQolDPH8qZYtjf5tycbLh1bL4VM1oRqHr5p6RpIk2YTHQHUiCkLjlr +TzkZhCzm8S/+5u45EXHB69XRcFTeHIH4ChtZPnIMTZcuGLe7iQ== +-----END CERTIFICATE----- diff --git a/test/recipes/80-test_cmp_http_data/Mock/server_withkem.cnf b/test/recipes/80-test_cmp_http_data/Mock/server_withkem.cnf new file mode 100644 index 0000000000000..512321c3b3f88 --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/server_withkem.cnf @@ -0,0 +1,17 @@ +[cmp] # mock server configuration + +port = 0 # 0 means that the server should choose a random available port +srv_cert = kem.crt +srv_key = kem.key +#srv_secret = pass:test + +# not needed: accept_unprotected = 1 +no_check_time = 1 +srv_trusted = signer_root.crt + +ref_cert = signer_only.crt +rsp_cert = signer_only.crt +rsp_capubs = signer_root.crt +rsp_extracerts = signer_issuing.crt + +verbosity = 7 diff --git a/test/recipes/80-test_cmp_http_data/Mock/test_withserverkem.cnf b/test/recipes/80-test_cmp_http_data/Mock/test_withserverkem.cnf new file mode 100644 index 0000000000000..23be5d90932ef --- /dev/null +++ b/test/recipes/80-test_cmp_http_data/Mock/test_withserverkem.cnf @@ -0,0 +1,141 @@ +[default] +batch = 1 # do not use stdin +total_timeout = 8 # prevent, e.g., infinite polling due to error +trusted = trusted.crt +newkey = new.key +newkeypass = +cmd = ir +out_trusted = root.crt +#certout = test.cert.pem +policies = certificatePolicies +#policy_oids = 1.2.3.4 +#policy_oids_critical = 1 +#verbosity = 7 + +############################# server-dependent configurations + +[Mock] # the built-in OpenSSL CMP mock server +# no_check_time = 1 +server_host = 127.0.0.1 # localhost +server_port = 0 # 0 means that the port is determined by the server +server_tls = $server_port +server_cert = server.crt +server = $server_host:$server_port +server_path = pkix/ +path = $server_path +ca_dn = /CN=Root CA +recipient = $ca_dn +server_dn = /CN=server.example +#expect_sender = $server_dn +subject = "/C=AU/ST=Some-State/O=Internet Widgits Pty Ltd/CN=leaf" +newkey = signer.key +out_trusted = signer_root.crt +kur_port = $server_port +pbm_port = $server_port +pbm_ref = +pbm_secret = pass:test +cert = signer.crt +key = signer.p12 +keypass = pass:12345 +ignore_keyusage = 0 +column = 0 +sleep = 0 + +############################# aspects + +[connection] +msg_timeout = 5 +total_timeout = +# reset any TLS options to default: +tls_used = +tls_cert = +tls_key = +tls_keypass = +tls_trusted = +tls_host = + +[tls] +server = +tls_used = +tls_cert = +tls_key = +tls_keypass = +tls_trusted = +tls_host = + +[credentials] +ref = +secret = +cert = +key = +keypass = +extracerts = +digest = +unprotected_requests = + +[verification] +#expect_sender = +srvcert = +trusted = +untrusted = +#unprotected_errors = +extracertsout = + +[commands] +cmd = +certout = +cacertsout = +infotype = +oldcert = +revreason = +geninfo = + +[enrollment] +cmd = +newkey = +newkeypass = +#subject = +issuer = +days = +reqexts = +sans = +san_nodefault = 0 +#popo = +implicit_confirm = 0 +disable_confirm = 0 +certout = +out_trusted = +oldcert = +csr = + +############################# extra cert template contents + +[certificatePolicies] +certificatePolicies = "critical, @pkiPolicy" + +[pkiPolicy] +policyIdentifier = 1.2.3.4 + +[reqexts] +basicConstraints = CA:FALSE +#basicConstraints = critical, CA:TRUE +keyUsage = critical, digitalSignature # keyAgreement, keyEncipherment, nonRepudiation +extendedKeyUsage = critical, clientAuth # serverAuth, codeSigning +#crlDistributionPoints = URI:http: +#authorityInfoAccess = URI:http: +subjectAltName = @alt_names + +[alt_names] +DNS.0 = localhost +IP.0 = 127.0.0.1 +IP.1 = 192.168.1.1 +URI.0 = http://192.168.0.2 + +[reqexts_invalidkey] +subjectAltName = @alt_names_3 + +[alt_names_3] +DNS.0 = localhost +DNS.1 = xn--rksmrgs-5wao1o.example.com +DNS.2 = xn--rkmacka-5wa.example.com +DNS__3 = xn--rksallad-0za.example.com diff --git a/test/recipes/80-test_cmp_http_data/test_credentials.csv b/test/recipes/80-test_cmp_http_data/test_credentials.csv index c7a977f2bfd9b..f212bc3db5d72 100644 --- a/test/recipes/80-test_cmp_http_data/test_credentials.csv +++ b/test/recipes/80-test_cmp_http_data/test_credentials.csv @@ -44,3 +44,6 @@ expected,description, -section,val, -ref,val, -secret,val, -cert,val, -key,val, 0,multiple digests, -section,,BLANK,,BLANK,, -cert,signer.crt, -key,signer.p12, -keypass,pass:12345,BLANK,,BLANK,, -digest,sha256 sha512,BLANK, ,,,,,,,,,,,,,,,,,,,,,, 0,unprotected request, -section,,BLANK,,BLANK,, -cert,"""", -key,"""", -keypass,"""",BLANK,,BLANK,,BLANK,, -unprotected_requests, +,,,,,,,,,,,,,,,,,,,,,, +1,client with KEM, -section,,,,,, -cert,kem.crt, -key,kem.key,,,BLANK,,BLANK,,BLANK,,BLANK,,,, +1,server with kem, -section,,BLANK,,-secret,"""", -cert,signer.crt, -key,signer.p12, -keypass,pass:12345,BLANK,,BLANK,,BLANK,,BLANK,,-srvcert, server_kem.crt \ No newline at end of file diff --git a/util/libcrypto.num b/util/libcrypto.num index 7373b002b7f43..6674420687ba2 100644 --- a/util/libcrypto.num +++ b/util/libcrypto.num @@ -5541,6 +5541,9 @@ OSSL_CMP_HDR_get0_geninfo_ITAVs ? 3_3_0 EXIST::FUNCTION:CMP OSSL_CMP_ITAV_new0_certProfile ? 3_3_0 EXIST::FUNCTION:CMP OSSL_CMP_ITAV_get0_certProfile ? 3_3_0 EXIST::FUNCTION:CMP OSSL_CMP_SRV_CTX_init_trans ? 3_3_0 EXIST::FUNCTION:CMP +OSSL_CMP_MSG_get_extraCerts ? 3_3_0 EXIST::FUNCTION:CMP +OSSL_CMP_get_ssk ? 3_3_0 EXIST::FUNCTION:CMP +OSSL_CMP_SRV_kem_get_ss ? 3_3_0 EXIST::FUNCTION:CMP EVP_DigestSqueeze ? 3_3_0 EXIST::FUNCTION: ERR_pop ? 3_3_0 EXIST::FUNCTION: X509_STORE_get1_objects ? 3_3_0 EXIST::FUNCTION: