diff options
Diffstat (limited to 'providers/implementations/signature/dsa_sig.c')
| -rw-r--r-- | providers/implementations/signature/dsa_sig.c | 562 |
1 files changed, 469 insertions, 93 deletions
diff --git a/providers/implementations/signature/dsa_sig.c b/providers/implementations/signature/dsa_sig.c index ec2205aa5a..a14fa796e9 100644 --- a/providers/implementations/signature/dsa_sig.c +++ b/providers/implementations/signature/dsa_sig.c @@ -30,14 +30,18 @@ #include "prov/implementations.h" #include "prov/provider_ctx.h" #include "prov/securitycheck.h" -#include "crypto/dsa.h" #include "prov/der_dsa.h" +#include "crypto/dsa.h" static OSSL_FUNC_signature_newctx_fn dsa_newctx; static OSSL_FUNC_signature_sign_init_fn dsa_sign_init; static OSSL_FUNC_signature_verify_init_fn dsa_verify_init; static OSSL_FUNC_signature_sign_fn dsa_sign; +static OSSL_FUNC_signature_sign_message_update_fn dsa_signverify_message_update; +static OSSL_FUNC_signature_sign_message_final_fn dsa_sign_message_final; static OSSL_FUNC_signature_verify_fn dsa_verify; +static OSSL_FUNC_signature_verify_message_update_fn dsa_signverify_message_update; +static OSSL_FUNC_signature_verify_message_final_fn dsa_verify_message_final; static OSSL_FUNC_signature_digest_sign_init_fn dsa_digest_sign_init; static OSSL_FUNC_signature_digest_sign_update_fn dsa_digest_signverify_update; static OSSL_FUNC_signature_digest_sign_final_fn dsa_digest_sign_final; @@ -46,6 +50,7 @@ static OSSL_FUNC_signature_digest_verify_update_fn dsa_digest_signverify_update; static OSSL_FUNC_signature_digest_verify_final_fn dsa_digest_verify_final; static OSSL_FUNC_signature_freectx_fn dsa_freectx; static OSSL_FUNC_signature_dupctx_fn dsa_dupctx; +static OSSL_FUNC_signature_query_key_types_fn dsa_sigalg_query_key_types; static OSSL_FUNC_signature_get_ctx_params_fn dsa_get_ctx_params; static OSSL_FUNC_signature_gettable_ctx_params_fn dsa_gettable_ctx_params; static OSSL_FUNC_signature_set_ctx_params_fn dsa_set_ctx_params; @@ -54,6 +59,8 @@ static OSSL_FUNC_signature_get_ctx_md_params_fn dsa_get_ctx_md_params; static OSSL_FUNC_signature_gettable_ctx_md_params_fn dsa_gettable_ctx_md_params; static OSSL_FUNC_signature_set_ctx_md_params_fn dsa_set_ctx_md_params; static OSSL_FUNC_signature_settable_ctx_md_params_fn dsa_settable_ctx_md_params; +static OSSL_FUNC_signature_set_ctx_params_fn dsa_sigalg_set_ctx_params; +static OSSL_FUNC_signature_settable_ctx_params_fn dsa_sigalg_settable_ctx_params; /* * What's passed as an actual key is defined by the KEYMGMT interface. @@ -65,8 +72,20 @@ typedef struct { OSSL_LIB_CTX *libctx; char *propq; DSA *dsa; + /* |operation| reuses EVP's operation bitfield */ + int operation; /* + * Flag to determine if a full sigalg is run (1) or if a composable + * signature algorithm is run (0). + * + * When a full sigalg is run (1), this currently affects the following + * other flags, which are to remain untouched after their initialization: + * + * - flag_allow_md (initialized to 0) + */ + unsigned int flag_sigalg : 1; + /* * Flag to determine if the hash function can be changed (1) or not (0) * Because it's dangerous to change during a DigestSign or DigestVerify * operation, this flag is cleared by their Init function, and set again @@ -77,21 +96,23 @@ typedef struct { /* If this is set to 1 then the generated k is not random */ unsigned int nonce_type; - char mdname[OSSL_MAX_NAME_SIZE]; - /* The Algorithm Identifier of the combined signature algorithm */ unsigned char aid_buf[OSSL_MAX_ALGORITHM_ID_SIZE]; unsigned char *aid; size_t aid_len; /* main digest */ + char mdname[OSSL_MAX_NAME_SIZE]; EVP_MD *md; EVP_MD_CTX *mdctx; - int operation; + + /* Signature, for verification */ + unsigned char *sig; + size_t siglen; + OSSL_FIPS_IND_DECLARE } PROV_DSA_CTX; - static size_t dsa_get_md_size(const PROV_DSA_CTX *pdsactx) { int md_size; @@ -162,19 +183,22 @@ static int dsa_setup_md(PROV_DSA_CTX *ctx, } #ifdef FIPS_MODULE { - int sha1_allowed = (ctx->operation != EVP_PKEY_OP_SIGN); + int sha1_allowed + = ((ctx->operation + & (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_SIGNMSG)) == 0); if (!ossl_fips_ind_digest_sign_check(OSSL_FIPS_IND_GET(ctx), OSSL_FIPS_IND_SETTABLE1, - ctx->libctx, md_nid, sha1_allowed, - desc, + ctx->libctx, + md_nid, sha1_allowed, desc, ossl_fips_config_signature_digest_check)) goto err; } #endif if (!ctx->flag_allow_md) { - if (ctx->mdname[0] != '\0' && !EVP_MD_is_a(md, ctx->mdname)) { + if (ctx->mdname[0] != '\0' + && !EVP_MD_is_a(md, ctx->mdname)) { ERR_raise_data(ERR_LIB_PROV, PROV_R_DIGEST_NOT_ALLOWED, "digest %s != %s", mdname, ctx->mdname); goto err; @@ -207,8 +231,9 @@ static int dsa_setup_md(PROV_DSA_CTX *ctx, ctx->md = md; OPENSSL_strlcpy(ctx->mdname, mdname, sizeof(ctx->mdname)); } + return 1; -err: + err: EVP_MD_free(md); return 0; } @@ -243,9 +268,11 @@ static int dsa_check_key(PROV_DSA_CTX *ctx, int sign, const char *desc) } #endif -static int dsa_signverify_init(void *vpdsactx, void *vdsa, - const OSSL_PARAM params[], int operation, - const char *desc) +static int +dsa_signverify_init(void *vpdsactx, void *vdsa, + OSSL_FUNC_signature_set_ctx_params_fn *set_ctx_params, + const OSSL_PARAM params[], int operation, + const char *desc) { PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; @@ -268,32 +295,36 @@ static int dsa_signverify_init(void *vpdsactx, void *vdsa, pdsactx->operation = operation; OSSL_FIPS_IND_SET_APPROVED(pdsactx) - if (!dsa_set_ctx_params(pdsactx, params)) + if (!set_ctx_params(pdsactx, params)) return 0; #ifdef FIPS_MODULE - if (!dsa_sign_check_approved(pdsactx, operation == EVP_PKEY_OP_SIGN, desc)) - return 0; - if (!dsa_check_key(pdsactx, operation == EVP_PKEY_OP_SIGN, desc)) - return 0; + { + int operation_is_sign + = (operation & (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_SIGNMSG)) != 0; + + if (!dsa_sign_check_approved(pdsactx, operation_is_sign, desc)) + return 0; + if (!dsa_check_key(pdsactx, operation_is_sign, desc)) + return 0; + } #endif return 1; } static int dsa_sign_init(void *vpdsactx, void *vdsa, const OSSL_PARAM params[]) { - return dsa_signverify_init(vpdsactx, vdsa, params, EVP_PKEY_OP_SIGN, - "DSA Sign Init"); -} - -static int dsa_verify_init(void *vpdsactx, void *vdsa, - const OSSL_PARAM params[]) -{ - return dsa_signverify_init(vpdsactx, vdsa, params, EVP_PKEY_OP_VERIFY, - "DSA Verify Init"); + return dsa_signverify_init(vpdsactx, vdsa, dsa_set_ctx_params, params, + EVP_PKEY_OP_SIGN, "DSA Sign Init"); } -static int dsa_sign(void *vpdsactx, unsigned char *sig, size_t *siglen, - size_t sigsize, const unsigned char *tbs, size_t tbslen) +/* + * Sign tbs without digesting it first. This is suitable for "primitive" + * signing and signing the digest of a message, i.e. should be used with + * implementations of the keytype related algorithms. + */ +static int dsa_sign_directly(void *vpdsactx, + unsigned char *sig, size_t *siglen, size_t sigsize, + const unsigned char *tbs, size_t tbslen) { PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; int ret; @@ -314,7 +345,7 @@ static int dsa_sign(void *vpdsactx, unsigned char *sig, size_t *siglen, return 1; } - if (sigsize < (size_t)dsasize) + if (sigsize < dsasize) return 0; if (mdsize != 0 && tbslen != mdsize) @@ -330,8 +361,79 @@ static int dsa_sign(void *vpdsactx, unsigned char *sig, size_t *siglen, return 1; } -static int dsa_verify(void *vpdsactx, const unsigned char *sig, size_t siglen, - const unsigned char *tbs, size_t tbslen) +static int dsa_signverify_message_update(void *vpdsactx, + const unsigned char *data, + size_t datalen) +{ + PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; + + if (pdsactx == NULL) + return 0; + + return EVP_DigestUpdate(pdsactx->mdctx, data, datalen); +} + +static int dsa_sign_message_final(void *vpdsactx, unsigned char *sig, + size_t *siglen, size_t sigsize) +{ + PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; + unsigned char digest[EVP_MAX_MD_SIZE]; + unsigned int dlen = 0; + + if (!ossl_prov_is_running() || pdsactx == NULL || pdsactx->mdctx == NULL) + return 0; + /* + * If sig is NULL then we're just finding out the sig size. Other fields + * are ignored. Defer to dsa_sign. + */ + if (sig != NULL) { + /* + * When this function is used through dsa_digest_sign_final(), + * there is the possibility that some externally provided digests + * exceed EVP_MAX_MD_SIZE. We should probably handle that + * somehow but that problem is much larger than just in DSA. + */ + if (!EVP_DigestFinal_ex(pdsactx->mdctx, digest, &dlen)) + return 0; + } + + return dsa_sign_directly(vpdsactx, sig, siglen, sigsize, digest, dlen); +} + +/* + * If signing a message, digest tbs and sign the result. + * Otherwise, sign tbs directly. + */ +static int dsa_sign(void *vpdsactx, unsigned char *sig, size_t *siglen, + size_t sigsize, const unsigned char *tbs, size_t tbslen) +{ + PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; + + if (pdsactx->operation == EVP_PKEY_OP_SIGNMSG) { + /* + * If |sig| is NULL, the caller is only looking for the sig length. + * DO NOT update the input in this case. + */ + if (sig == NULL) + return dsa_sign_message_final(pdsactx, sig, siglen, sigsize); + + if (dsa_signverify_message_update(pdsactx, tbs, tbslen) <= 0) + return 0; + return dsa_sign_message_final(pdsactx, sig, siglen, sigsize); + } + return dsa_sign_directly(pdsactx, sig, siglen, sigsize, tbs, tbslen); +} + +static int dsa_verify_init(void *vpdsactx, void *vdsa, + const OSSL_PARAM params[]) +{ + return dsa_signverify_init(vpdsactx, vdsa, dsa_set_ctx_params, params, + EVP_PKEY_OP_VERIFY, "DSA Verify Init"); +} + +static int dsa_verify_directly(void *vpdsactx, + const unsigned char *sig, size_t siglen, + const unsigned char *tbs, size_t tbslen) { PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; size_t mdsize = dsa_get_md_size(pdsactx); @@ -342,6 +444,64 @@ static int dsa_verify(void *vpdsactx, const unsigned char *sig, size_t siglen, return DSA_verify(0, tbs, tbslen, sig, siglen, pdsactx->dsa); } +static int dsa_verify_set_sig(void *vpdsactx, + const unsigned char *sig, size_t siglen) +{ + PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; + OSSL_PARAM params[2]; + + params[0] = + OSSL_PARAM_construct_octet_string(OSSL_SIGNATURE_PARAM_SIGNATURE, + (unsigned char *)sig, siglen); + params[1] = OSSL_PARAM_construct_end(); + return dsa_sigalg_set_ctx_params(pdsactx, params); +} + +static int dsa_verify_message_final(void *vpdsactx) +{ + PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; + unsigned char digest[EVP_MAX_MD_SIZE]; + unsigned int dlen = 0; + + if (!ossl_prov_is_running()) + return 0; + + if (pdsactx == NULL || pdsactx->mdctx == NULL) + return 0; + + /* + * The digests used here are all known (see dsa_get_md_nid()), so they + * should not exceed the internal buffer size of EVP_MAX_MD_SIZE. + */ + if (!EVP_DigestFinal_ex(pdsactx->mdctx, digest, &dlen)) + return 0; + + return dsa_verify_directly(vpdsactx, pdsactx->sig, pdsactx->siglen, + digest, dlen); +} + +/* + * If verifying a message, digest tbs and verify the result. + * Otherwise, verify tbs directly. + */ +static int dsa_verify(void *vpdsactx, + const unsigned char *sig, size_t siglen, + const unsigned char *tbs, size_t tbslen) +{ + PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; + + if (pdsactx->operation == EVP_PKEY_OP_VERIFYMSG) { + if (dsa_verify_set_sig(pdsactx, sig, siglen) <= 0) + return 0; + if (dsa_signverify_message_update(pdsactx, tbs, tbslen) <= 0) + return 0; + return dsa_verify_message_final(pdsactx); + } + return dsa_verify_directly(pdsactx, sig, siglen, tbs, tbslen); +} + +/* DigestSign/DigestVerify wrappers */ + static int dsa_digest_signverify_init(void *vpdsactx, const char *mdname, void *vdsa, const OSSL_PARAM params[], int operation, const char *desc) @@ -351,10 +511,14 @@ static int dsa_digest_signverify_init(void *vpdsactx, const char *mdname, if (!ossl_prov_is_running()) return 0; - if (!dsa_signverify_init(vpdsactx, vdsa, params, operation, desc)) + if (!dsa_signverify_init(vpdsactx, vdsa, dsa_set_ctx_params, params, + operation, desc)) return 0; - if (!dsa_setup_md(pdsactx, mdname, NULL, desc)) + if (mdname != NULL + /* was dsa_setup_md already called in dsa_signverify_init()? */ + && (mdname[0] == '\0' || OPENSSL_strcasecmp(pdsactx->mdname, mdname) != 0) + && !dsa_setup_md(pdsactx, mdname, NULL, desc)) return 0; pdsactx->flag_allow_md = 0; @@ -380,92 +544,79 @@ static int dsa_digest_sign_init(void *vpdsactx, const char *mdname, void *vdsa, const OSSL_PARAM params[]) { return dsa_digest_signverify_init(vpdsactx, mdname, vdsa, params, - EVP_PKEY_OP_SIGN, + EVP_PKEY_OP_SIGNMSG, "DSA Digest Sign Init"); } -static int dsa_digest_verify_init(void *vpdsactx, const char *mdname, - void *vdsa, const OSSL_PARAM params[]) -{ - return dsa_digest_signverify_init(vpdsactx, mdname, vdsa, params, - EVP_PKEY_OP_VERIFY, - "DSA Digest Verify Init"); -} - -int dsa_digest_signverify_update(void *vpdsactx, const unsigned char *data, - size_t datalen) +static int dsa_digest_signverify_update(void *vpdsactx, const unsigned char *data, + size_t datalen) { PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; - if (pdsactx == NULL || pdsactx->mdctx == NULL) + if (pdsactx == NULL) + return 0; + /* Sigalg implementations shouldn't do digest_sign */ + if (pdsactx->flag_sigalg) return 0; - return EVP_DigestUpdate(pdsactx->mdctx, data, datalen); + return dsa_signverify_message_update(vpdsactx, data, datalen); } -int dsa_digest_sign_final(void *vpdsactx, unsigned char *sig, size_t *siglen, - size_t sigsize) +static int dsa_digest_sign_final(void *vpdsactx, unsigned char *sig, + size_t *siglen, size_t sigsize) { PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; - unsigned char digest[EVP_MAX_MD_SIZE]; - unsigned int dlen = 0; + int ok = 0; - if (!ossl_prov_is_running() || pdsactx == NULL || pdsactx->mdctx == NULL) + if (pdsactx == NULL) + return 0; + /* Sigalg implementations shouldn't do digest_sign */ + if (pdsactx->flag_sigalg) return 0; - /* - * If sig is NULL then we're just finding out the sig size. Other fields - * are ignored. Defer to dsa_sign. - */ - if (sig != NULL) { - /* - * There is the possibility that some externally provided - * digests exceed EVP_MAX_MD_SIZE. We should probably handle that somehow - - * but that problem is much larger than just in DSA. - */ - if (!EVP_DigestFinal_ex(pdsactx->mdctx, digest, &dlen)) - return 0; - } + ok = dsa_sign_message_final(pdsactx, sig, siglen, sigsize); pdsactx->flag_allow_md = 1; - return dsa_sign(vpdsactx, sig, siglen, sigsize, digest, (size_t)dlen); + return ok; } +static int dsa_digest_verify_init(void *vpdsactx, const char *mdname, + void *vdsa, const OSSL_PARAM params[]) +{ + return dsa_digest_signverify_init(vpdsactx, mdname, vdsa, params, + EVP_PKEY_OP_VERIFYMSG, + "DSA Digest Verify Init"); +} int dsa_digest_verify_final(void *vpdsactx, const unsigned char *sig, size_t siglen) { PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; - unsigned char digest[EVP_MAX_MD_SIZE]; - unsigned int dlen = 0; + int ok = 0; - if (!ossl_prov_is_running() || pdsactx == NULL || pdsactx->mdctx == NULL) + if (pdsactx == NULL) return 0; - - /* - * There is the possibility that some externally provided - * digests exceed EVP_MAX_MD_SIZE. We should probably handle that somehow - - * but that problem is much larger than just in DSA. - */ - if (!EVP_DigestFinal_ex(pdsactx->mdctx, digest, &dlen)) + /* Sigalg implementations shouldn't do digest_verify */ + if (pdsactx->flag_sigalg) return 0; + if (dsa_verify_set_sig(pdsactx, sig, siglen)) + ok = dsa_verify_message_final(vpdsactx); + pdsactx->flag_allow_md = 1; - return dsa_verify(vpdsactx, sig, siglen, digest, (size_t)dlen); + return ok; } static void dsa_freectx(void *vpdsactx) { PROV_DSA_CTX *ctx = (PROV_DSA_CTX *)vpdsactx; - OPENSSL_free(ctx->propq); EVP_MD_CTX_free(ctx->mdctx); EVP_MD_free(ctx->md); - ctx->propq = NULL; - ctx->mdctx = NULL; - ctx->md = NULL; + OPENSSL_free(ctx->sig); + OPENSSL_free(ctx->propq); DSA_free(ctx->dsa); OPENSSL_free(ctx); } @@ -484,8 +635,6 @@ static void *dsa_dupctx(void *vpdsactx) *dstctx = *srcctx; dstctx->dsa = NULL; - dstctx->md = NULL; - dstctx->mdctx = NULL; dstctx->propq = NULL; if (srcctx->dsa != NULL && !DSA_up_ref(srcctx->dsa)) @@ -502,6 +651,7 @@ static void *dsa_dupctx(void *vpdsactx) || !EVP_MD_CTX_copy_ex(dstctx->mdctx, srcctx->mdctx)) goto err; } + if (srcctx->propq != NULL) { dstctx->propq = OPENSSL_strdup(srcctx->propq); if (dstctx->propq == NULL) @@ -554,7 +704,8 @@ static const OSSL_PARAM *dsa_gettable_ctx_params(ossl_unused void *ctx, return known_gettable_ctx_params; } -static int dsa_set_ctx_params(void *vpdsactx, const OSSL_PARAM params[]) +/* The common params for dsa_set_ctx_params and dsa_sigalg_set_ctx_params */ +static int dsa_common_set_ctx_params(void *vpdsactx, const OSSL_PARAM params[]) { PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; const OSSL_PARAM *p; @@ -574,6 +725,32 @@ static int dsa_set_ctx_params(void *vpdsactx, const OSSL_PARAM params[]) OSSL_SIGNATURE_PARAM_FIPS_SIGN_CHECK)) return 0; + p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_NONCE_TYPE); + if (p != NULL + && !OSSL_PARAM_get_uint(p, &pdsactx->nonce_type)) + return 0; + return 1; +} + +#define DSA_COMMON_SETTABLE_CTX_PARAMS \ + OSSL_PARAM_uint(OSSL_SIGNATURE_PARAM_NONCE_TYPE, NULL), \ + OSSL_FIPS_IND_SETTABLE_CTX_PARAM(OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK) \ + OSSL_FIPS_IND_SETTABLE_CTX_PARAM(OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK) \ + OSSL_FIPS_IND_SETTABLE_CTX_PARAM(OSSL_SIGNATURE_PARAM_FIPS_SIGN_CHECK) \ + OSSL_PARAM_END + +static int dsa_set_ctx_params(void *vpdsactx, const OSSL_PARAM params[]) +{ + PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; + const OSSL_PARAM *p; + int ret; + + if ((ret = dsa_common_set_ctx_params(pdsactx, params)) <= 0) + return ret; + + if (params == NULL) + return 1; + p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST); if (p != NULL) { char mdname[OSSL_MAX_NAME_SIZE] = "", *pmdname = mdname; @@ -590,21 +767,13 @@ static int dsa_set_ctx_params(void *vpdsactx, const OSSL_PARAM params[]) if (!dsa_setup_md(pdsactx, mdname, mdprops, "DSA Set Ctx")) return 0; } - p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_NONCE_TYPE); - if (p != NULL - && !OSSL_PARAM_get_uint(p, &pdsactx->nonce_type)) - return 0; return 1; } static const OSSL_PARAM settable_ctx_params[] = { OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0), OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PROPERTIES, NULL, 0), - OSSL_PARAM_uint(OSSL_SIGNATURE_PARAM_NONCE_TYPE, NULL), - OSSL_FIPS_IND_SETTABLE_CTX_PARAM(OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK) - OSSL_FIPS_IND_SETTABLE_CTX_PARAM(OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK) - OSSL_FIPS_IND_SETTABLE_CTX_PARAM(OSSL_SIGNATURE_PARAM_FIPS_SIGN_CHECK) - OSSL_PARAM_END + DSA_COMMON_SETTABLE_CTX_PARAMS }; static const OSSL_PARAM settable_ctx_params_no_digest[] = { @@ -697,3 +866,210 @@ const OSSL_DISPATCH ossl_dsa_signature_functions[] = { (void (*)(void))dsa_settable_ctx_md_params }, OSSL_DISPATCH_END }; + +/* ------------------------------------------------------------------ */ + +/* + * So called sigalgs (composite DSA+hash) implemented below. They + * are pretty much hard coded. + */ + +static OSSL_FUNC_signature_query_key_types_fn dsa_sigalg_query_key_types; +static OSSL_FUNC_signature_settable_ctx_params_fn dsa_sigalg_settable_ctx_params; +static OSSL_FUNC_signature_set_ctx_params_fn dsa_sigalg_set_ctx_params; + +/* + * dsa_sigalg_signverify_init() is almost like dsa_digest_signverify_init(), + * just doesn't allow fetching an MD from whatever the user chooses. + */ +static int dsa_sigalg_signverify_init(void *vpdsactx, void *vdsa, + OSSL_FUNC_signature_set_ctx_params_fn *set_ctx_params, + const OSSL_PARAM params[], + const char *mdname, + int operation, const char *desc) +{ + PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; + + if (!ossl_prov_is_running()) + return 0; + + if (!dsa_signverify_init(vpdsactx, vdsa, set_ctx_params, params, operation, + desc)) + return 0; + + if (!dsa_setup_md(pdsactx, mdname, NULL, desc)) + return 0; + + pdsactx->flag_sigalg = 1; + pdsactx->flag_allow_md = 0; + + if (pdsactx->mdctx == NULL) { + pdsactx->mdctx = EVP_MD_CTX_new(); + if (pdsactx->mdctx == NULL) + goto error; + } + + if (!EVP_DigestInit_ex2(pdsactx->mdctx, pdsactx->md, params)) + goto error; + + return 1; + + error: + EVP_MD_CTX_free(pdsactx->mdctx); + pdsactx->mdctx = NULL; + return 0; +} + +static const char **dsa_sigalg_query_key_types(void) +{ + static const char *keytypes[] = { "DSA", NULL }; + + return keytypes; +} + +static const OSSL_PARAM settable_sigalg_ctx_params[] = { + OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_SIGNATURE, NULL, 0), + DSA_COMMON_SETTABLE_CTX_PARAMS +}; + +static const OSSL_PARAM *dsa_sigalg_settable_ctx_params(void *vpdsactx, + ossl_unused void *provctx) +{ + PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; + + if (pdsactx != NULL && pdsactx->operation == EVP_PKEY_OP_VERIFYMSG) + return settable_sigalg_ctx_params; + return NULL; +} + +static int dsa_sigalg_set_ctx_params(void *vpdsactx, const OSSL_PARAM params[]) +{ + PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx; + const OSSL_PARAM *p; + int ret; + + if ((ret = dsa_common_set_ctx_params(pdsactx, params)) <= 0) + return ret; + + if (params == NULL) + return 1; + + if (pdsactx->operation == EVP_PKEY_OP_VERIFYMSG) { + p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_SIGNATURE); + if (p != NULL) { + OPENSSL_free(pdsactx->sig); + pdsactx->sig = NULL; + pdsactx->siglen = 0; + if (!OSSL_PARAM_get_octet_string(p, (void **)&pdsactx->sig, + 0, &pdsactx->siglen)) + return 0; + } + } + return 1; +} + +#define IMPL_DSA_SIGALG(md, MD) \ + static OSSL_FUNC_signature_sign_init_fn dsa_##md##_sign_init; \ + static OSSL_FUNC_signature_sign_message_init_fn \ + dsa_##md##_sign_message_init; \ + static OSSL_FUNC_signature_verify_init_fn dsa_##md##_verify_init; \ + static OSSL_FUNC_signature_verify_message_init_fn \ + dsa_##md##_verify_message_init; \ + \ + static int \ + dsa_##md##_sign_init(void *vpdsactx, void *vdsa, \ + const OSSL_PARAM params[]) \ + { \ + static const char desc[] = "DSA-" #MD " Sign Init"; \ + \ + return dsa_sigalg_signverify_init(vpdsactx, vdsa, \ + dsa_sigalg_set_ctx_params, \ + params, #MD, \ + EVP_PKEY_OP_SIGN, \ + desc); \ + } \ + \ + static int \ + dsa_##md##_sign_message_init(void *vpdsactx, void *vdsa, \ + const OSSL_PARAM params[]) \ + { \ + static const char desc[] = "DSA-" #MD " Sign Message Init"; \ + \ + return dsa_sigalg_signverify_init(vpdsactx, vdsa, \ + dsa_sigalg_set_ctx_params, \ + params, #MD, \ + EVP_PKEY_OP_SIGNMSG, \ + desc); \ + } \ + \ + static int \ + dsa_##md##_verify_init(void *vpdsactx, void *vdsa, \ + const OSSL_PARAM params[]) \ + { \ + static const char desc[] = "DSA-" #MD " Verify Init"; \ + \ + return dsa_sigalg_signverify_init(vpdsactx, vdsa, \ + dsa_sigalg_set_ctx_params, \ + params, #MD, \ + EVP_PKEY_OP_VERIFY, \ + desc); \ + } \ + \ + static int \ + dsa_##md##_verify_message_init(void *vpdsactx, void *vdsa, \ + const OSSL_PARAM params[]) \ + { \ + static const char desc[] = "DSA-" #MD " Verify Message Init"; \ + \ + return dsa_sigalg_signverify_init(vpdsactx, vdsa, \ + dsa_sigalg_set_ctx_params, \ + params, #MD, \ + EVP_PKEY_OP_VERIFYMSG, \ + desc); \ + } \ + \ + const OSSL_DISPATCH ossl_dsa_##md##_signature_functions[] = { \ + { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))dsa_newctx }, \ + { OSSL_FUNC_SIGNATURE_SIGN_INIT, \ + (void (*)(void))dsa_##md##_sign_init }, \ + { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))dsa_sign }, \ + { OSSL_FUNC_SIGNATURE_SIGN_MESSAGE_INIT, \ + (void (*)(void))dsa_##md##_sign_message_init }, \ + { OSSL_FUNC_SIGNATURE_SIGN_MESSAGE_UPDATE, \ + (void (*)(void))dsa_signverify_message_update }, \ + { OSSL_FUNC_SIGNATURE_SIGN_MESSAGE_FINAL, \ + (void (*)(void))dsa_sign_message_final }, \ + { OSSL_FUNC_SIGNATURE_VERIFY_INIT, \ + (void (*)(void))dsa_##md##_verify_init }, \ + { OSSL_FUNC_SIGNATURE_VERIFY, \ + (void (*)(void))dsa_verify }, \ + { OSSL_FUNC_SIGNATURE_VERIFY_MESSAGE_INIT, \ + (void (*)(void))dsa_##md##_verify_message_init }, \ + { OSSL_FUNC_SIGNATURE_VERIFY_MESSAGE_UPDATE, \ + (void (*)(void))dsa_signverify_message_update }, \ + { OSSL_FUNC_SIGNATURE_VERIFY_MESSAGE_FINAL, \ + (void (*)(void))dsa_verify_message_final }, \ + { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))dsa_freectx }, \ + { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))dsa_dupctx }, \ + { OSSL_FUNC_SIGNATURE_QUERY_KEY_TYPES, \ + (void (*)(void))dsa_sigalg_query_key_types }, \ + { OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS, \ + (void (*)(void))dsa_get_ctx_params }, \ + { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS, \ + (void (*)(void))dsa_gettable_ctx_params }, \ + { OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, \ + (void (*)(void))dsa_sigalg_set_ctx_params }, \ + { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS, \ + (void (*)(void))dsa_sigalg_settable_ctx_params }, \ + OSSL_DISPATCH_END \ + } + +IMPL_DSA_SIGALG(sha1, SHA1); +IMPL_DSA_SIGALG(sha224, SHA2-224); +IMPL_DSA_SIGALG(sha256, SHA2-256); +IMPL_DSA_SIGALG(sha384, SHA2-384); +IMPL_DSA_SIGALG(sha512, SHA2-512); +IMPL_DSA_SIGALG(sha3_224, SHA3-224); +IMPL_DSA_SIGALG(sha3_256, SHA3-256); +IMPL_DSA_SIGALG(sha3_384, SHA3-384); +IMPL_DSA_SIGALG(sha3_512, SHA3-512); |