providers/implementations/signature/dsa.c

   1 /*
   2  * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /*
  11  * DSA low level APIs are deprecated for public use, but still ok for
  12  * internal use.
  13  */
  14 #include "internal/deprecated.h"
  15
  16 #include <string.h>
  17
  18 #include <openssl/crypto.h>
  19 #include <openssl/core_numbers.h>
  20 #include <openssl/core_names.h>
  21 #include <openssl/err.h>
  22 #include <openssl/dsa.h>
  23 #include <openssl/params.h>
  24 #include <openssl/evp.h>
  25 #include <openssl/err.h>
  26 #include "internal/nelem.h"
  27 #include "internal/sizes.h"
  28 #include "prov/providercommonerr.h"
  29 #include "prov/implementations.h"
  30 #include "prov/providercommonerr.h"
  31 #include "prov/provider_ctx.h"
  32 #include "crypto/dsa.h"
  33
  34 static OSSL_OP_signature_newctx_fn dsa_newctx;
  35 static OSSL_OP_signature_sign_init_fn dsa_signature_init;
  36 static OSSL_OP_signature_verify_init_fn dsa_signature_init;
  37 static OSSL_OP_signature_sign_fn dsa_sign;
  38 static OSSL_OP_signature_verify_fn dsa_verify;
  39 static OSSL_OP_signature_digest_sign_init_fn dsa_digest_signverify_init;
  40 static OSSL_OP_signature_digest_sign_update_fn dsa_digest_signverify_update;
  41 static OSSL_OP_signature_digest_sign_final_fn dsa_digest_sign_final;
  42 static OSSL_OP_signature_digest_verify_init_fn dsa_digest_signverify_init;
  43 static OSSL_OP_signature_digest_verify_update_fn dsa_digest_signverify_update;
  44 static OSSL_OP_signature_digest_verify_final_fn dsa_digest_verify_final;
  45 static OSSL_OP_signature_freectx_fn dsa_freectx;
  46 static OSSL_OP_signature_dupctx_fn dsa_dupctx;
  47 static OSSL_OP_signature_get_ctx_params_fn dsa_get_ctx_params;
  48 static OSSL_OP_signature_gettable_ctx_params_fn dsa_gettable_ctx_params;
  49 static OSSL_OP_signature_set_ctx_params_fn dsa_set_ctx_params;
  50 static OSSL_OP_signature_settable_ctx_params_fn dsa_settable_ctx_params;
  51 static OSSL_OP_signature_get_ctx_md_params_fn dsa_get_ctx_md_params;
  52 static OSSL_OP_signature_gettable_ctx_md_params_fn dsa_gettable_ctx_md_params;
  53 static OSSL_OP_signature_set_ctx_md_params_fn dsa_set_ctx_md_params;
  54 static OSSL_OP_signature_settable_ctx_md_params_fn dsa_settable_ctx_md_params;
  55
  56 /*
  57  * What's passed as an actual key is defined by the KEYMGMT interface.
  58  * We happen to know that our KEYMGMT simply passes DSA structures, so
  59  * we use that here too.
  60  */
  61
  62 typedef struct {
  63     OPENSSL_CTX *libctx;
  64     DSA *dsa;
  65
  66     /*
  67      * Flag to determine if the hash function can be changed (1) or not (0)
  68      * Because it's dangerous to change during a DigestSign or DigestVerify
  69      * operation, this flag is cleared by their Init function, and set again
  70      * by their Final function.
  71      */
  72     unsigned int flag_allow_md : 1;
  73
  74     char mdname[OSSL_MAX_NAME_SIZE];
  75
  76     /* The Algorithm Identifier of the combined signature agorithm */
  77     unsigned char aid[OSSL_MAX_ALGORITHM_ID_SIZE];
  78     size_t  aid_len;
  79
  80     /* main digest */
  81     EVP_MD *md;
  82     EVP_MD_CTX *mdctx;
  83     size_t mdsize;
  84 } PROV_DSA_CTX;
  85
  86 static size_t dsa_get_md_size(const PROV_DSA_CTX *pdsactx)
  87 {
  88     if (pdsactx->md != NULL)
  89         return EVP_MD_size(pdsactx->md);
  90     return 0;
  91 }
  92
  93 static int dsa_get_md_nid(const EVP_MD *md)
  94 {
  95     /*
  96      * Because the DSA library deals with NIDs, we need to translate.
  97      * We do so using EVP_MD_is_a(), and therefore need a name to NID
  98      * map.
  99      */
 100     static const OSSL_ITEM name_to_nid[] = {
 101         { NID_sha1,   OSSL_DIGEST_NAME_SHA1   },
 102         { NID_sha224, OSSL_DIGEST_NAME_SHA2_224 },
 103         { NID_sha256, OSSL_DIGEST_NAME_SHA2_256 },
 104         { NID_sha384, OSSL_DIGEST_NAME_SHA2_384 },
 105         { NID_sha512, OSSL_DIGEST_NAME_SHA2_512 },
 106         { NID_sha3_224, OSSL_DIGEST_NAME_SHA3_224 },
 107         { NID_sha3_256, OSSL_DIGEST_NAME_SHA3_256 },
 108         { NID_sha3_384, OSSL_DIGEST_NAME_SHA3_384 },
 109         { NID_sha3_512, OSSL_DIGEST_NAME_SHA3_512 },
 110     };
 111     size_t i;
 112     int mdnid = NID_undef;
 113
 114     if (md == NULL)
 115         goto end;
 116
 117     for (i = 0; i < OSSL_NELEM(name_to_nid); i++) {
 118         if (EVP_MD_is_a(md, name_to_nid[i].ptr)) {
 119             mdnid = (int)name_to_nid[i].id;
 120             break;
 121         }
 122     }
 123
 124     if (mdnid == NID_undef)
 125         ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DIGEST);
 126
 127  end:
 128     return mdnid;
 129 }
 130
 131 static void *dsa_newctx(void *provctx)
 132 {
 133     PROV_DSA_CTX *pdsactx = OPENSSL_zalloc(sizeof(PROV_DSA_CTX));
 134
 135     if (pdsactx == NULL)
 136         return NULL;
 137
 138     pdsactx->libctx = PROV_LIBRARY_CONTEXT_OF(provctx);
 139     pdsactx->flag_allow_md = 1;
 140     return pdsactx;
 141 }
 142
 143 static int dsa_setup_md(PROV_DSA_CTX *ctx,
 144                         const char *mdname, const char *mdprops)
 145 {
 146     if (mdname != NULL) {
 147         EVP_MD *md = EVP_MD_fetch(ctx->libctx, mdname, mdprops);
 148         int md_nid = dsa_get_md_nid(md);
 149         size_t algorithmidentifier_len = 0;
 150         const unsigned char *algorithmidentifier;
 151
 152         EVP_MD_free(ctx->md);
 153         ctx->md = NULL;
 154         ctx->mdname[0] = '\0';
 155
 156         algorithmidentifier =
 157             dsa_algorithmidentifier_encoding(md_nid, &algorithmidentifier_len);
 158
 159         if (algorithmidentifier == NULL) {
 160             EVP_MD_free(md);
 161             return 0;
 162         }
 163
 164         ctx->md = md;
 165         OPENSSL_strlcpy(ctx->mdname, mdname, sizeof(ctx->mdname));
 166         memcpy(ctx->aid, algorithmidentifier, algorithmidentifier_len);
 167         ctx->aid_len = algorithmidentifier_len;
 168     }
 169     return 1;
 170 }
 171
 172 static int dsa_signature_init(void *vpdsactx, void *vdsa)
 173 {
 174     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 175
 176     if (pdsactx == NULL || vdsa == NULL || !DSA_up_ref(vdsa))
 177         return 0;
 178     DSA_free(pdsactx->dsa);
 179     pdsactx->dsa = vdsa;
 180     return 1;
 181 }
 182
 183 static int dsa_sign(void *vpdsactx, unsigned char *sig, size_t *siglen,
 184                     size_t sigsize, const unsigned char *tbs, size_t tbslen)
 185 {
 186     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 187     int ret;
 188     unsigned int sltmp;
 189     size_t dsasize = DSA_size(pdsactx->dsa);
 190     size_t mdsize = dsa_get_md_size(pdsactx);
 191
 192     if (sig == NULL) {
 193         *siglen = dsasize;
 194         return 1;
 195     }
 196
 197     if (sigsize < (size_t)dsasize)
 198         return 0;
 199
 200     if (mdsize != 0 && tbslen != mdsize)
 201         return 0;
 202
 203     ret = dsa_sign_int(0, tbs, tbslen, sig, &sltmp, pdsactx->dsa);
 204     if (ret <= 0)
 205         return 0;
 206
 207     *siglen = sltmp;
 208     return 1;
 209 }
 210
 211 static int dsa_verify(void *vpdsactx, const unsigned char *sig, size_t siglen,
 212                       const unsigned char *tbs, size_t tbslen)
 213 {
 214     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 215     size_t mdsize = dsa_get_md_size(pdsactx);
 216
 217     if (mdsize != 0 && tbslen != mdsize)
 218         return 0;
 219
 220     return DSA_verify(0, tbs, tbslen, sig, siglen, pdsactx->dsa);
 221 }
 222
 223 static int dsa_digest_signverify_init(void *vpdsactx, const char *mdname,
 224                                       const char *props, void *vdsa)
 225 {
 226     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 227
 228     pdsactx->flag_allow_md = 0;
 229     if (!dsa_signature_init(vpdsactx, vdsa))
 230         return 0;
 231
 232     if (!dsa_setup_md(pdsactx, mdname, props))
 233         return 0;
 234
 235     pdsactx->mdctx = EVP_MD_CTX_new();
 236     if (pdsactx->mdctx == NULL)
 237         goto error;
 238
 239     if (!EVP_DigestInit_ex(pdsactx->mdctx, pdsactx->md, NULL))
 240         goto error;
 241
 242     return 1;
 243
 244  error:
 245     EVP_MD_CTX_free(pdsactx->mdctx);
 246     EVP_MD_free(pdsactx->md);
 247     pdsactx->mdctx = NULL;
 248     pdsactx->md = NULL;
 249     return 0;
 250 }
 251
 252 int dsa_digest_signverify_update(void *vpdsactx, const unsigned char *data,
 253                                  size_t datalen)
 254 {
 255     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 256
 257     if (pdsactx == NULL || pdsactx->mdctx == NULL)
 258         return 0;
 259
 260     return EVP_DigestUpdate(pdsactx->mdctx, data, datalen);
 261 }
 262
 263 int dsa_digest_sign_final(void *vpdsactx, unsigned char *sig, size_t *siglen,
 264                           size_t sigsize)
 265 {
 266     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 267     unsigned char digest[EVP_MAX_MD_SIZE];
 268     unsigned int dlen = 0;
 269
 270     if (pdsactx == NULL || pdsactx->mdctx == NULL)
 271         return 0;
 272
 273     /*
 274      * If sig is NULL then we're just finding out the sig size. Other fields
 275      * are ignored. Defer to dsa_sign.
 276      */
 277     if (sig != NULL) {
 278         /*
 279          * TODO(3.0): There is the possibility that some externally provided
 280          * digests exceed EVP_MAX_MD_SIZE. We should probably handle that somehow -
 281          * but that problem is much larger than just in DSA.
 282          */
 283         if (!EVP_DigestFinal_ex(pdsactx->mdctx, digest, &dlen))
 284             return 0;
 285     }
 286
 287     pdsactx->flag_allow_md = 1;
 288
 289     return dsa_sign(vpdsactx, sig, siglen, sigsize, digest, (size_t)dlen);
 290 }
 291
 292
 293 int dsa_digest_verify_final(void *vpdsactx, const unsigned char *sig,
 294                             size_t siglen)
 295 {
 296     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 297     unsigned char digest[EVP_MAX_MD_SIZE];
 298     unsigned int dlen = 0;
 299
 300     if (pdsactx == NULL || pdsactx->mdctx == NULL)
 301         return 0;
 302
 303     /*
 304      * TODO(3.0): There is the possibility that some externally provided
 305      * digests exceed EVP_MAX_MD_SIZE. We should probably handle that somehow -
 306      * but that problem is much larger than just in DSA.
 307      */
 308     if (!EVP_DigestFinal_ex(pdsactx->mdctx, digest, &dlen))
 309         return 0;
 310
 311     pdsactx->flag_allow_md = 1;
 312
 313     return dsa_verify(vpdsactx, sig, siglen, digest, (size_t)dlen);
 314 }
 315
 316 static void dsa_freectx(void *vpdsactx)
 317 {
 318     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 319
 320     DSA_free(pdsactx->dsa);
 321     EVP_MD_CTX_free(pdsactx->mdctx);
 322     EVP_MD_free(pdsactx->md);
 323
 324     OPENSSL_free(pdsactx);
 325 }
 326
 327 static void *dsa_dupctx(void *vpdsactx)
 328 {
 329     PROV_DSA_CTX *srcctx = (PROV_DSA_CTX *)vpdsactx;
 330     PROV_DSA_CTX *dstctx;
 331
 332     dstctx = OPENSSL_zalloc(sizeof(*srcctx));
 333     if (dstctx == NULL)
 334         return NULL;
 335
 336     *dstctx = *srcctx;
 337     dstctx->dsa = NULL;
 338     dstctx->md = NULL;
 339     dstctx->mdctx = NULL;
 340
 341     if (srcctx->dsa != NULL && !DSA_up_ref(srcctx->dsa))
 342         goto err;
 343     dstctx->dsa = srcctx->dsa;
 344
 345     if (srcctx->md != NULL && !EVP_MD_up_ref(srcctx->md))
 346         goto err;
 347     dstctx->md = srcctx->md;
 348
 349     if (srcctx->mdctx != NULL) {
 350         dstctx->mdctx = EVP_MD_CTX_new();
 351         if (dstctx->mdctx == NULL
 352                 || !EVP_MD_CTX_copy_ex(dstctx->mdctx, srcctx->mdctx))
 353             goto err;
 354     }
 355
 356     return dstctx;
 357  err:
 358     dsa_freectx(dstctx);
 359     return NULL;
 360 }
 361
 362 static int dsa_get_ctx_params(void *vpdsactx, OSSL_PARAM *params)
 363 {
 364     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 365     OSSL_PARAM *p;
 366
 367     if (pdsactx == NULL || params == NULL)
 368         return 0;
 369
 370     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_ALGORITHM_ID);
 371     if (p != NULL
 372         && !OSSL_PARAM_set_octet_string(p, pdsactx->aid, pdsactx->aid_len))
 373         return 0;
 374
 375     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST);
 376     if (p != NULL && !OSSL_PARAM_set_utf8_string(p, pdsactx->mdname))
 377         return 0;
 378
 379     return 1;
 380 }
 381
 382 static const OSSL_PARAM known_gettable_ctx_params[] = {
 383     OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
 384     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
 385     OSSL_PARAM_END
 386 };
 387
 388 static const OSSL_PARAM *dsa_gettable_ctx_params(void)
 389 {
 390     return known_gettable_ctx_params;
 391 }
 392
 393 static int dsa_set_ctx_params(void *vpdsactx, const OSSL_PARAM params[])
 394 {
 395     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 396     const OSSL_PARAM *p;
 397
 398     if (pdsactx == NULL || params == NULL)
 399         return 0;
 400
 401     p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST);
 402     /* Not allowed during certain operations */
 403     if (p != NULL && !pdsactx->flag_allow_md)
 404         return 0;
 405     if (p != NULL) {
 406         char mdname[OSSL_MAX_NAME_SIZE] = "", *pmdname = mdname;
 407         char mdprops[OSSL_MAX_PROPQUERY_SIZE] = "", *pmdprops = mdprops;
 408         const OSSL_PARAM *propsp =
 409             OSSL_PARAM_locate_const(params,
 410                                     OSSL_SIGNATURE_PARAM_PROPERTIES);
 411
 412         if (!OSSL_PARAM_get_utf8_string(p, &pmdname, sizeof(mdname)))
 413             return 0;
 414         if (propsp != NULL
 415             && !OSSL_PARAM_get_utf8_string(propsp, &pmdprops, sizeof(mdprops)))
 416             return 0;
 417         if (!dsa_setup_md(pdsactx, mdname, mdprops))
 418             return 0;
 419     }
 420
 421     return 1;
 422 }
 423
 424 static const OSSL_PARAM known_settable_ctx_params[] = {
 425     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
 426     OSSL_PARAM_END
 427 };
 428
 429 static const OSSL_PARAM *dsa_settable_ctx_params(void)
 430 {
 431     /*
 432      * TODO(3.0): Should this function return a different set of settable ctx
 433      * params if the ctx is being used for a DigestSign/DigestVerify? In that
 434      * case it is not allowed to set the digest size/digest name because the
 435      * digest is explicitly set as part of the init.
 436      */
 437     return known_settable_ctx_params;
 438 }
 439
 440 static int dsa_get_ctx_md_params(void *vpdsactx, OSSL_PARAM *params)
 441 {
 442     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 443
 444     if (pdsactx->mdctx == NULL)
 445         return 0;
 446
 447     return EVP_MD_CTX_get_params(pdsactx->mdctx, params);
 448 }
 449
 450 static const OSSL_PARAM *dsa_gettable_ctx_md_params(void *vpdsactx)
 451 {
 452     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 453
 454     if (pdsactx->md == NULL)
 455         return 0;
 456
 457     return EVP_MD_gettable_ctx_params(pdsactx->md);
 458 }
 459
 460 static int dsa_set_ctx_md_params(void *vpdsactx, const OSSL_PARAM params[])
 461 {
 462     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 463
 464     if (pdsactx->mdctx == NULL)
 465         return 0;
 466
 467     return EVP_MD_CTX_set_params(pdsactx->mdctx, params);
 468 }
 469
 470 static const OSSL_PARAM *dsa_settable_ctx_md_params(void *vpdsactx)
 471 {
 472     PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
 473
 474     if (pdsactx->md == NULL)
 475         return 0;
 476
 477     return EVP_MD_settable_ctx_params(pdsactx->md);
 478 }
 479
 480 const OSSL_DISPATCH dsa_signature_functions[] = {
 481     { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))dsa_newctx },
 482     { OSSL_FUNC_SIGNATURE_SIGN_INIT, (void (*)(void))dsa_signature_init },
 483     { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))dsa_sign },
 484     { OSSL_FUNC_SIGNATURE_VERIFY_INIT, (void (*)(void))dsa_signature_init },
 485     { OSSL_FUNC_SIGNATURE_VERIFY, (void (*)(void))dsa_verify },
 486     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT,
 487       (void (*)(void))dsa_digest_signverify_init },
 488     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE,
 489       (void (*)(void))dsa_digest_signverify_update },
 490     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL,
 491       (void (*)(void))dsa_digest_sign_final },
 492     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT,
 493       (void (*)(void))dsa_digest_signverify_init },
 494     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE,
 495       (void (*)(void))dsa_digest_signverify_update },
 496     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL,
 497       (void (*)(void))dsa_digest_verify_final },
 498     { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))dsa_freectx },
 499     { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))dsa_dupctx },
 500     { OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS, (void (*)(void))dsa_get_ctx_params },
 501     { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS,
 502       (void (*)(void))dsa_gettable_ctx_params },
 503     { OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, (void (*)(void))dsa_set_ctx_params },
 504     { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS,
 505       (void (*)(void))dsa_settable_ctx_params },
 506     { OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS,
 507       (void (*)(void))dsa_get_ctx_md_params },
 508     { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS,
 509       (void (*)(void))dsa_gettable_ctx_md_params },
 510     { OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS,
 511       (void (*)(void))dsa_set_ctx_md_params },
 512     { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS,
 513       (void (*)(void))dsa_settable_ctx_md_params },
 514     { 0, NULL }
 515 };