include/crypto/evp.h

   1 /*
   2  * Copyright 2015-2020 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 #include <openssl/evp.h>
  11 #include <openssl/core_numbers.h>
  12 #include "internal/refcount.h"
  13 #include "crypto/ecx.h"
  14
  15 /*
  16  * Don't free up md_ctx->pctx in EVP_MD_CTX_reset, use the reserved flag
  17  * values in evp.h
  18  */
  19 #define EVP_MD_CTX_FLAG_KEEP_PKEY_CTX   0x0400
  20
  21 struct evp_pkey_ctx_st {
  22     /* Actual operation */
  23     int operation;
  24
  25     /*
  26      * Library context, property query, keytype and keymgmt associated with
  27      * this context
  28      */
  29     OPENSSL_CTX *libctx;
  30     const char *propquery;
  31     const char *keytype;
  32     EVP_KEYMGMT *keymgmt;
  33
  34     union {
  35         struct {
  36             void *genctx;
  37         } keymgmt;
  38
  39         struct {
  40             EVP_KEYEXCH *exchange;
  41             void *exchprovctx;
  42         } kex;
  43
  44         struct {
  45             EVP_SIGNATURE *signature;
  46             void *sigprovctx;
  47         } sig;
  48
  49         struct {
  50             EVP_ASYM_CIPHER *cipher;
  51             void *ciphprovctx;
  52         } ciph;
  53     } op;
  54
  55     /* Application specific data, usually used by the callback */
  56     void *app_data;
  57     /* Keygen callback */
  58     EVP_PKEY_gen_cb *pkey_gencb;
  59     /* implementation specific keygen data */
  60     int *keygen_info;
  61     int keygen_info_count;
  62
  63     /* Legacy fields below */
  64
  65     /* Method associated with this operation */
  66     const EVP_PKEY_METHOD *pmeth;
  67     /* Engine that implements this method or NULL if builtin */
  68     ENGINE *engine;
  69     /* Key: may be NULL */
  70     EVP_PKEY *pkey;
  71     /* Peer key for key agreement, may be NULL */
  72     EVP_PKEY *peerkey;
  73     /* Algorithm specific data */
  74     void *data;
  75     /* Indicator if digest_custom needs to be called */
  76     unsigned int flag_call_digest_custom:1;
  77 } /* EVP_PKEY_CTX */ ;
  78
  79 #define EVP_PKEY_FLAG_DYNAMIC   1
  80
  81 struct evp_pkey_method_st {
  82     int pkey_id;
  83     int flags;
  84     int (*init) (EVP_PKEY_CTX *ctx);
  85     int (*copy) (EVP_PKEY_CTX *dst, const EVP_PKEY_CTX *src);
  86     void (*cleanup) (EVP_PKEY_CTX *ctx);
  87     int (*paramgen_init) (EVP_PKEY_CTX *ctx);
  88     int (*paramgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);
  89     int (*keygen_init) (EVP_PKEY_CTX *ctx);
  90     int (*keygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);
  91     int (*sign_init) (EVP_PKEY_CTX *ctx);
  92     int (*sign) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
  93                  const unsigned char *tbs, size_t tbslen);
  94     int (*verify_init) (EVP_PKEY_CTX *ctx);
  95     int (*verify) (EVP_PKEY_CTX *ctx,
  96                    const unsigned char *sig, size_t siglen,
  97                    const unsigned char *tbs, size_t tbslen);
  98     int (*verify_recover_init) (EVP_PKEY_CTX *ctx);
  99     int (*verify_recover) (EVP_PKEY_CTX *ctx,
 100                            unsigned char *rout, size_t *routlen,
 101                            const unsigned char *sig, size_t siglen);
 102     int (*signctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
 103     int (*signctx) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
 104                     EVP_MD_CTX *mctx);
 105     int (*verifyctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
 106     int (*verifyctx) (EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
 107                       EVP_MD_CTX *mctx);
 108     int (*encrypt_init) (EVP_PKEY_CTX *ctx);
 109     int (*encrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
 110                     const unsigned char *in, size_t inlen);
 111     int (*decrypt_init) (EVP_PKEY_CTX *ctx);
 112     int (*decrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
 113                     const unsigned char *in, size_t inlen);
 114     int (*derive_init) (EVP_PKEY_CTX *ctx);
 115     int (*derive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
 116     int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1, void *p2);
 117     int (*ctrl_str) (EVP_PKEY_CTX *ctx, const char *type, const char *value);
 118     int (*digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
 119                        const unsigned char *tbs, size_t tbslen);
 120     int (*digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig,
 121                          size_t siglen, const unsigned char *tbs,
 122                          size_t tbslen);
 123     int (*check) (EVP_PKEY *pkey);
 124     int (*public_check) (EVP_PKEY *pkey);
 125     int (*param_check) (EVP_PKEY *pkey);
 126
 127     int (*digest_custom) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
 128 } /* EVP_PKEY_METHOD */ ;
 129
 130 DEFINE_STACK_OF_CONST(EVP_PKEY_METHOD)
 131
 132 void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx);
 133
 134 const EVP_PKEY_METHOD *cmac_pkey_method(void);
 135 const EVP_PKEY_METHOD *dh_pkey_method(void);
 136 const EVP_PKEY_METHOD *dhx_pkey_method(void);
 137 const EVP_PKEY_METHOD *dsa_pkey_method(void);
 138 const EVP_PKEY_METHOD *ec_pkey_method(void);
 139 const EVP_PKEY_METHOD *sm2_pkey_method(void);
 140 const EVP_PKEY_METHOD *ecx25519_pkey_method(void);
 141 const EVP_PKEY_METHOD *ecx448_pkey_method(void);
 142 const EVP_PKEY_METHOD *ed25519_pkey_method(void);
 143 const EVP_PKEY_METHOD *ed448_pkey_method(void);
 144 const EVP_PKEY_METHOD *hmac_pkey_method(void);
 145 const EVP_PKEY_METHOD *rsa_pkey_method(void);
 146 const EVP_PKEY_METHOD *rsa_pss_pkey_method(void);
 147 const EVP_PKEY_METHOD *scrypt_pkey_method(void);
 148 const EVP_PKEY_METHOD *tls1_prf_pkey_method(void);
 149 const EVP_PKEY_METHOD *hkdf_pkey_method(void);
 150 const EVP_PKEY_METHOD *poly1305_pkey_method(void);
 151 const EVP_PKEY_METHOD *siphash_pkey_method(void);
 152
 153 struct evp_mac_st {
 154     OSSL_PROVIDER *prov;
 155     int name_id;
 156
 157     CRYPTO_REF_COUNT refcnt;
 158     CRYPTO_RWLOCK *lock;
 159
 160     OSSL_OP_mac_newctx_fn *newctx;
 161     OSSL_OP_mac_dupctx_fn *dupctx;
 162     OSSL_OP_mac_freectx_fn *freectx;
 163     OSSL_OP_mac_size_fn *size;
 164     OSSL_OP_mac_init_fn *init;
 165     OSSL_OP_mac_update_fn *update;
 166     OSSL_OP_mac_final_fn *final;
 167     OSSL_OP_mac_gettable_params_fn *gettable_params;
 168     OSSL_OP_mac_gettable_ctx_params_fn *gettable_ctx_params;
 169     OSSL_OP_mac_settable_ctx_params_fn *settable_ctx_params;
 170     OSSL_OP_mac_get_params_fn *get_params;
 171     OSSL_OP_mac_get_ctx_params_fn *get_ctx_params;
 172     OSSL_OP_mac_set_ctx_params_fn *set_ctx_params;
 173 };
 174
 175 struct evp_kdf_st {
 176     OSSL_PROVIDER *prov;
 177     int name_id;
 178     CRYPTO_REF_COUNT refcnt;
 179     CRYPTO_RWLOCK *lock;
 180
 181     OSSL_OP_kdf_newctx_fn *newctx;
 182     OSSL_OP_kdf_dupctx_fn *dupctx;
 183     OSSL_OP_kdf_freectx_fn *freectx;
 184     OSSL_OP_kdf_reset_fn *reset;
 185     OSSL_OP_kdf_derive_fn *derive;
 186     OSSL_OP_kdf_gettable_params_fn *gettable_params;
 187     OSSL_OP_kdf_gettable_ctx_params_fn *gettable_ctx_params;
 188     OSSL_OP_kdf_settable_ctx_params_fn *settable_ctx_params;
 189     OSSL_OP_kdf_get_params_fn *get_params;
 190     OSSL_OP_kdf_get_ctx_params_fn *get_ctx_params;
 191     OSSL_OP_kdf_set_ctx_params_fn *set_ctx_params;
 192 };
 193
 194 struct evp_md_st {
 195     /* nid */
 196     int type;
 197
 198     /* Legacy structure members */
 199     /* TODO(3.0): Remove these */
 200     int pkey_type;
 201     int md_size;
 202     unsigned long flags;
 203     int (*init) (EVP_MD_CTX *ctx);
 204     int (*update) (EVP_MD_CTX *ctx, const void *data, size_t count);
 205     int (*final) (EVP_MD_CTX *ctx, unsigned char *md);
 206     int (*copy) (EVP_MD_CTX *to, const EVP_MD_CTX *from);
 207     int (*cleanup) (EVP_MD_CTX *ctx);
 208     int block_size;
 209     int ctx_size;               /* how big does the ctx->md_data need to be */
 210     /* control function */
 211     int (*md_ctrl) (EVP_MD_CTX *ctx, int cmd, int p1, void *p2);
 212
 213     /* New structure members */
 214     /* TODO(3.0): Remove above comment when legacy has gone */
 215     int name_id;
 216     OSSL_PROVIDER *prov;
 217     CRYPTO_REF_COUNT refcnt;
 218     CRYPTO_RWLOCK *lock;
 219     OSSL_OP_digest_newctx_fn *newctx;
 220     OSSL_OP_digest_init_fn *dinit;
 221     OSSL_OP_digest_update_fn *dupdate;
 222     OSSL_OP_digest_final_fn *dfinal;
 223     OSSL_OP_digest_digest_fn *digest;
 224     OSSL_OP_digest_freectx_fn *freectx;
 225     OSSL_OP_digest_dupctx_fn *dupctx;
 226     OSSL_OP_digest_get_params_fn *get_params;
 227     OSSL_OP_digest_set_ctx_params_fn *set_ctx_params;
 228     OSSL_OP_digest_get_ctx_params_fn *get_ctx_params;
 229     OSSL_OP_digest_gettable_params_fn *gettable_params;
 230     OSSL_OP_digest_settable_ctx_params_fn *settable_ctx_params;
 231     OSSL_OP_digest_gettable_ctx_params_fn *gettable_ctx_params;
 232
 233 } /* EVP_MD */ ;
 234
 235 struct evp_cipher_st {
 236     int nid;
 237
 238     int block_size;
 239     /* Default value for variable length ciphers */
 240     int key_len;
 241     int iv_len;
 242
 243     /* Legacy structure members */
 244     /* TODO(3.0): Remove these */
 245     /* Various flags */
 246     unsigned long flags;
 247     /* init key */
 248     int (*init) (EVP_CIPHER_CTX *ctx, const unsigned char *key,
 249                  const unsigned char *iv, int enc);
 250     /* encrypt/decrypt data */
 251     int (*do_cipher) (EVP_CIPHER_CTX *ctx, unsigned char *out,
 252                       const unsigned char *in, size_t inl);
 253     /* cleanup ctx */
 254     int (*cleanup) (EVP_CIPHER_CTX *);
 255     /* how big ctx->cipher_data needs to be */
 256     int ctx_size;
 257     /* Populate a ASN1_TYPE with parameters */
 258     int (*set_asn1_parameters) (EVP_CIPHER_CTX *, ASN1_TYPE *);
 259     /* Get parameters from a ASN1_TYPE */
 260     int (*get_asn1_parameters) (EVP_CIPHER_CTX *, ASN1_TYPE *);
 261     /* Miscellaneous operations */
 262     int (*ctrl) (EVP_CIPHER_CTX *, int type, int arg, void *ptr);
 263     /* Application data */
 264     void *app_data;
 265
 266     /* New structure members */
 267     /* TODO(3.0): Remove above comment when legacy has gone */
 268     int name_id;
 269     OSSL_PROVIDER *prov;
 270     CRYPTO_REF_COUNT refcnt;
 271     CRYPTO_RWLOCK *lock;
 272     OSSL_OP_cipher_newctx_fn *newctx;
 273     OSSL_OP_cipher_encrypt_init_fn *einit;
 274     OSSL_OP_cipher_decrypt_init_fn *dinit;
 275     OSSL_OP_cipher_update_fn *cupdate;
 276     OSSL_OP_cipher_final_fn *cfinal;
 277     OSSL_OP_cipher_cipher_fn *ccipher;
 278     OSSL_OP_cipher_freectx_fn *freectx;
 279     OSSL_OP_cipher_dupctx_fn *dupctx;
 280     OSSL_OP_cipher_get_params_fn *get_params;
 281     OSSL_OP_cipher_get_ctx_params_fn *get_ctx_params;
 282     OSSL_OP_cipher_set_ctx_params_fn *set_ctx_params;
 283     OSSL_OP_cipher_gettable_params_fn *gettable_params;
 284     OSSL_OP_cipher_gettable_ctx_params_fn *gettable_ctx_params;
 285     OSSL_OP_cipher_settable_ctx_params_fn *settable_ctx_params;
 286 } /* EVP_CIPHER */ ;
 287
 288 /* Macros to code block cipher wrappers */
 289
 290 /* Wrapper functions for each cipher mode */
 291
 292 #define EVP_C_DATA(kstruct, ctx) \
 293         ((kstruct *)EVP_CIPHER_CTX_get_cipher_data(ctx))
 294
 295 #define BLOCK_CIPHER_ecb_loop() \
 296         size_t i, bl; \
 297         bl = EVP_CIPHER_CTX_cipher(ctx)->block_size;    \
 298         if (inl < bl) return 1;\
 299         inl -= bl; \
 300         for (i=0; i <= inl; i+=bl)
 301
 302 #define BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
 303 static int cname##_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
 304 {\
 305         BLOCK_CIPHER_ecb_loop() \
 306             cprefix##_ecb_encrypt(in + i, out + i, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_encrypting(ctx)); \
 307         return 1;\
 308 }
 309
 310 #define EVP_MAXCHUNK ((size_t)1<<(sizeof(long)*8-2))
 311
 312 #define BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched) \
 313     static int cname##_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
 314 {\
 315         while(inl>=EVP_MAXCHUNK) {\
 316             int num = EVP_CIPHER_CTX_num(ctx);\
 317             cprefix##_ofb##cbits##_encrypt(in, out, (long)EVP_MAXCHUNK, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx), &num); \
 318             EVP_CIPHER_CTX_set_num(ctx, num);\
 319             inl-=EVP_MAXCHUNK;\
 320             in +=EVP_MAXCHUNK;\
 321             out+=EVP_MAXCHUNK;\
 322         }\
 323         if (inl) {\
 324             int num = EVP_CIPHER_CTX_num(ctx);\
 325             cprefix##_ofb##cbits##_encrypt(in, out, (long)inl, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx), &num); \
 326             EVP_CIPHER_CTX_set_num(ctx, num);\
 327         }\
 328         return 1;\
 329 }
 330
 331 #define BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
 332 static int cname##_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
 333 {\
 334         while(inl>=EVP_MAXCHUNK) \
 335             {\
 336             cprefix##_cbc_encrypt(in, out, (long)EVP_MAXCHUNK, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx), EVP_CIPHER_CTX_encrypting(ctx));\
 337             inl-=EVP_MAXCHUNK;\
 338             in +=EVP_MAXCHUNK;\
 339             out+=EVP_MAXCHUNK;\
 340             }\
 341         if (inl)\
 342             cprefix##_cbc_encrypt(in, out, (long)inl, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx), EVP_CIPHER_CTX_encrypting(ctx));\
 343         return 1;\
 344 }
 345
 346 #define BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched)  \
 347 static int cname##_cfb##cbits##_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
 348 {\
 349     size_t chunk = EVP_MAXCHUNK;\
 350     if (cbits == 1)  chunk >>= 3;\
 351     if (inl < chunk) chunk = inl;\
 352     while (inl && inl >= chunk)\
 353     {\
 354         int num = EVP_CIPHER_CTX_num(ctx);\
 355         cprefix##_cfb##cbits##_encrypt(in, out, (long) \
 356             ((cbits == 1) \
 357                 && !EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS) \
 358                 ? chunk*8 : chunk), \
 359             &EVP_C_DATA(kstruct, ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx),\
 360             &num, EVP_CIPHER_CTX_encrypting(ctx));\
 361         EVP_CIPHER_CTX_set_num(ctx, num);\
 362         inl -= chunk;\
 363         in += chunk;\
 364         out += chunk;\
 365         if (inl < chunk) chunk = inl;\
 366     }\
 367     return 1;\
 368 }
 369
 370 #define BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
 371         BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
 372         BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \
 373         BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
 374         BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched)
 375
 376 #define BLOCK_CIPHER_def1(cname, nmode, mode, MODE, kstruct, nid, block_size, \
 377                           key_len, iv_len, flags, init_key, cleanup, \
 378                           set_asn1, get_asn1, ctrl) \
 379 static const EVP_CIPHER cname##_##mode = { \
 380         nid##_##nmode, block_size, key_len, iv_len, \
 381         flags | EVP_CIPH_##MODE##_MODE, \
 382         init_key, \
 383         cname##_##mode##_cipher, \
 384         cleanup, \
 385         sizeof(kstruct), \
 386         set_asn1, get_asn1,\
 387         ctrl, \
 388         NULL \
 389 }; \
 390 const EVP_CIPHER *EVP_##cname##_##mode(void) { return &cname##_##mode; }
 391
 392 #define BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, \
 393                              iv_len, flags, init_key, cleanup, set_asn1, \
 394                              get_asn1, ctrl) \
 395 BLOCK_CIPHER_def1(cname, cbc, cbc, CBC, kstruct, nid, block_size, key_len, \
 396                   iv_len, flags, init_key, cleanup, set_asn1, get_asn1, ctrl)
 397
 398 #define BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, \
 399                              iv_len, cbits, flags, init_key, cleanup, \
 400                              set_asn1, get_asn1, ctrl) \
 401 BLOCK_CIPHER_def1(cname, cfb##cbits, cfb##cbits, CFB, kstruct, nid, 1, \
 402                   key_len, iv_len, flags, init_key, cleanup, set_asn1, \
 403                   get_asn1, ctrl)
 404
 405 #define BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, \
 406                              iv_len, cbits, flags, init_key, cleanup, \
 407                              set_asn1, get_asn1, ctrl) \
 408 BLOCK_CIPHER_def1(cname, ofb##cbits, ofb, OFB, kstruct, nid, 1, \
 409                   key_len, iv_len, flags, init_key, cleanup, set_asn1, \
 410                   get_asn1, ctrl)
 411
 412 #define BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, \
 413                              flags, init_key, cleanup, set_asn1, \
 414                              get_asn1, ctrl) \
 415 BLOCK_CIPHER_def1(cname, ecb, ecb, ECB, kstruct, nid, block_size, key_len, \
 416                   0, flags, init_key, cleanup, set_asn1, get_asn1, ctrl)
 417
 418 #define BLOCK_CIPHER_defs(cname, kstruct, \
 419                           nid, block_size, key_len, iv_len, cbits, flags, \
 420                           init_key, cleanup, set_asn1, get_asn1, ctrl) \
 421 BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, iv_len, flags, \
 422                      init_key, cleanup, set_asn1, get_asn1, ctrl) \
 423 BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, iv_len, cbits, \
 424                      flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
 425 BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, iv_len, cbits, \
 426                      flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
 427 BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, flags, \
 428                      init_key, cleanup, set_asn1, get_asn1, ctrl)
 429
 430 /*-
 431 #define BLOCK_CIPHER_defs(cname, kstruct, \
 432                                 nid, block_size, key_len, iv_len, flags,\
 433                                  init_key, cleanup, set_asn1, get_asn1, ctrl)\
 434 static const EVP_CIPHER cname##_cbc = {\
 435         nid##_cbc, block_size, key_len, iv_len, \
 436         flags | EVP_CIPH_CBC_MODE,\
 437         init_key,\
 438         cname##_cbc_cipher,\
 439         cleanup,\
 440         sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
 441                 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
 442         set_asn1, get_asn1,\
 443         ctrl, \
 444         NULL \
 445 };\
 446 const EVP_CIPHER *EVP_##cname##_cbc(void) { return &cname##_cbc; }\
 447 static const EVP_CIPHER cname##_cfb = {\
 448         nid##_cfb64, 1, key_len, iv_len, \
 449         flags | EVP_CIPH_CFB_MODE,\
 450         init_key,\
 451         cname##_cfb_cipher,\
 452         cleanup,\
 453         sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
 454                 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
 455         set_asn1, get_asn1,\
 456         ctrl,\
 457         NULL \
 458 };\
 459 const EVP_CIPHER *EVP_##cname##_cfb(void) { return &cname##_cfb; }\
 460 static const EVP_CIPHER cname##_ofb = {\
 461         nid##_ofb64, 1, key_len, iv_len, \
 462         flags | EVP_CIPH_OFB_MODE,\
 463         init_key,\
 464         cname##_ofb_cipher,\
 465         cleanup,\
 466         sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
 467                 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
 468         set_asn1, get_asn1,\
 469         ctrl,\
 470         NULL \
 471 };\
 472 const EVP_CIPHER *EVP_##cname##_ofb(void) { return &cname##_ofb; }\
 473 static const EVP_CIPHER cname##_ecb = {\
 474         nid##_ecb, block_size, key_len, iv_len, \
 475         flags | EVP_CIPH_ECB_MODE,\
 476         init_key,\
 477         cname##_ecb_cipher,\
 478         cleanup,\
 479         sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
 480                 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
 481         set_asn1, get_asn1,\
 482         ctrl,\
 483         NULL \
 484 };\
 485 const EVP_CIPHER *EVP_##cname##_ecb(void) { return &cname##_ecb; }
 486 */
 487
 488 #define IMPLEMENT_BLOCK_CIPHER(cname, ksched, cprefix, kstruct, nid, \
 489                                block_size, key_len, iv_len, cbits, \
 490                                flags, init_key, \
 491                                cleanup, set_asn1, get_asn1, ctrl) \
 492         BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
 493         BLOCK_CIPHER_defs(cname, kstruct, nid, block_size, key_len, iv_len, \
 494                           cbits, flags, init_key, cleanup, set_asn1, \
 495                           get_asn1, ctrl)
 496
 497 #define IMPLEMENT_CFBR(cipher,cprefix,kstruct,ksched,keysize,cbits,iv_len,fl) \
 498         BLOCK_CIPHER_func_cfb(cipher##_##keysize,cprefix,cbits,kstruct,ksched) \
 499         BLOCK_CIPHER_def_cfb(cipher##_##keysize,kstruct, \
 500                              NID_##cipher##_##keysize, keysize/8, iv_len, cbits, \
 501                              (fl)|EVP_CIPH_FLAG_DEFAULT_ASN1, \
 502                              cipher##_init_key, NULL, NULL, NULL, NULL)
 503
 504 /*
 505  * An EVP_PKEY can have the following states:
 506  *
 507  * untyped & empty:
 508  *
 509  *     type == EVP_PKEY_NONE && keymgmt == NULL
 510  *
 511  * typed & empty:
 512  *
 513  *     (type != EVP_PKEY_NONE && pkey.ptr == NULL)      ## legacy (libcrypto only)
 514  *     || (keymgmt != NULL && keydata == NULL)          ## provider side
 515  *
 516  * fully assigned:
 517  *
 518  *     (type != EVP_PKEY_NONE && pkey.ptr != NULL)      ## legacy (libcrypto only)
 519  *     || (keymgmt != NULL && keydata != NULL)          ## provider side
 520  *
 521  * The easiest way to detect a legacy key is:           type != EVP_PKEY_NONE
 522  * The easiest way to detect a provider side key is:    keymgmt != NULL
 523  */
 524 struct evp_pkey_st {
 525     /* == Legacy attributes == */
 526     int type;
 527     int save_type;
 528
 529 # ifndef FIPS_MODULE
 530     /*
 531      * Legacy key "origin" is composed of a pointer to an EVP_PKEY_ASN1_METHOD,
 532      * a pointer to a low level key and possibly a pointer to an engine.
 533      */
 534     const EVP_PKEY_ASN1_METHOD *ameth;
 535     ENGINE *engine;
 536     ENGINE *pmeth_engine; /* If not NULL public key ENGINE to use */
 537     union {
 538         void *ptr;
 539 #  ifndef OPENSSL_NO_RSA
 540         struct rsa_st *rsa;     /* RSA */
 541 #  endif
 542 #  ifndef OPENSSL_NO_DSA
 543         struct dsa_st *dsa;     /* DSA */
 544 #  endif
 545 #  ifndef OPENSSL_NO_DH
 546         struct dh_st *dh;       /* DH */
 547 #  endif
 548 #  ifndef OPENSSL_NO_EC
 549         struct ec_key_st *ec;   /* ECC */
 550         ECX_KEY *ecx;           /* X25519, X448, Ed25519, Ed448 */
 551 #  endif
 552     } pkey;
 553 # endif
 554
 555     /* == Common attributes == */
 556     CRYPTO_REF_COUNT references;
 557     CRYPTO_RWLOCK *lock;
 558     STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */
 559     int save_parameters;
 560 #ifndef FIPS_MODULE
 561     CRYPTO_EX_DATA ex_data;
 562 #endif
 563
 564     /* == Provider attributes == */
 565
 566     /*
 567      * Provider keydata "origin" is composed of a pointer to an EVP_KEYMGMT
 568      * and a pointer to the provider side key data.  This is never used at
 569      * the same time as the legacy key data above.
 570      */
 571     EVP_KEYMGMT *keymgmt;
 572     void *keydata;
 573     /*
 574      * If any libcrypto code does anything that may modify the keydata
 575      * contents, this dirty counter must be incremented.
 576      */
 577     size_t dirty_cnt;
 578
 579     /*
 580      * To support transparent execution of operation in backends other
 581      * than the "origin" key, we support transparent export/import to
 582      * those providers, and maintain a cache of the imported keydata,
 583      * so we don't need to redo the export/import every time we perform
 584      * the same operation in that same provider.
 585      * This requires that the "origin" backend (whether it's a legacy or a
 586      * provider "origin") implements exports, and that the target provider
 587      * has an EVP_KEYMGMT that implements import.
 588      *
 589      * The cache limit is set at 10 different providers using the same
 590      * "origin".  It's probably over the top, but is preferable to too
 591      * few.
 592      */
 593     struct {
 594         EVP_KEYMGMT *keymgmt;
 595         void *keydata;
 596     } operation_cache[10];
 597     /*
 598      * We keep a copy of that "origin"'s dirty count, so we know if the
 599      * operation cache needs flushing.
 600      */
 601     size_t dirty_cnt_copy;
 602
 603     /* Cache of key object information */
 604     struct {
 605         int bits;
 606         int security_bits;
 607         int size;
 608     } cache;
 609 } /* EVP_PKEY */ ;
 610
 611 #define EVP_PKEY_CTX_IS_SIGNATURE_OP(ctx) \
 612     ((ctx)->operation == EVP_PKEY_OP_SIGN \
 613      || (ctx)->operation == EVP_PKEY_OP_SIGNCTX \
 614      || (ctx)->operation == EVP_PKEY_OP_VERIFY \
 615      || (ctx)->operation == EVP_PKEY_OP_VERIFYCTX \
 616      || (ctx)->operation == EVP_PKEY_OP_VERIFYRECOVER)
 617
 618 #define EVP_PKEY_CTX_IS_DERIVE_OP(ctx) \
 619     ((ctx)->operation == EVP_PKEY_OP_DERIVE)
 620
 621 #define EVP_PKEY_CTX_IS_ASYM_CIPHER_OP(ctx) \
 622     ((ctx)->operation == EVP_PKEY_OP_ENCRYPT \
 623      || (ctx)->operation == EVP_PKEY_OP_DECRYPT)
 624
 625 #define EVP_PKEY_CTX_IS_GEN_OP(ctx) \
 626     ((ctx)->operation == EVP_PKEY_OP_PARAMGEN \
 627      || (ctx)->operation == EVP_PKEY_OP_KEYGEN)
 628
 629 void openssl_add_all_ciphers_int(void);
 630 void openssl_add_all_digests_int(void);
 631 void evp_cleanup_int(void);
 632 void evp_app_cleanup_int(void);
 633 void *evp_pkey_export_to_provider(EVP_PKEY *pk, OPENSSL_CTX *libctx,
 634                                   EVP_KEYMGMT **keymgmt,
 635                                   const char *propquery);
 636 #ifndef FIPS_MODULE
 637 int evp_pkey_downgrade(EVP_PKEY *pk);
 638 void evp_pkey_free_legacy(EVP_PKEY *x);
 639 #endif
 640
 641 /*
 642  * KEYMGMT utility functions
 643  */
 644 void *evp_keymgmt_util_export_to_provider(EVP_PKEY *pk, EVP_KEYMGMT *keymgmt);
 645 size_t evp_keymgmt_util_find_operation_cache_index(EVP_PKEY *pk,
 646                                                    EVP_KEYMGMT *keymgmt);
 647 void evp_keymgmt_util_clear_operation_cache(EVP_PKEY *pk);
 648 int evp_keymgmt_util_cache_keydata(EVP_PKEY *pk, size_t index,
 649                                    EVP_KEYMGMT *keymgmt, void *keydata);
 650 void evp_keymgmt_util_cache_keyinfo(EVP_PKEY *pk);
 651 void *evp_keymgmt_util_fromdata(EVP_PKEY *target, EVP_KEYMGMT *keymgmt,
 652                                 int selection, const OSSL_PARAM params[]);
 653 int evp_keymgmt_util_has(EVP_PKEY *pk, int selection);
 654 int evp_keymgmt_util_match(EVP_PKEY *pk1, EVP_PKEY *pk2, int selection);
 655 int evp_keymgmt_util_copy(EVP_PKEY *to, EVP_PKEY *from, int selection);
 656 void *evp_keymgmt_util_gen(EVP_PKEY *target, EVP_KEYMGMT *keymgmt,
 657                            void *genctx, OSSL_CALLBACK *cb, void *cbarg);
 658 int evp_keymgmt_util_get_deflt_digest_name(EVP_KEYMGMT *keymgmt,
 659                                            void *keydata,
 660                                            char *mdname, size_t mdname_sz);
 661
 662 /*
 663  * KEYMGMT provider interface functions
 664  */
 665 void *evp_keymgmt_newdata(const EVP_KEYMGMT *keymgmt);
 666 void evp_keymgmt_freedata(const EVP_KEYMGMT *keymgmt, void *keyddata);
 667 int evp_keymgmt_get_params(const EVP_KEYMGMT *keymgmt,
 668                            void *keydata, OSSL_PARAM params[]);
 669 const OSSL_PARAM *evp_keymgmt_gettable_params(const EVP_KEYMGMT *keymgmt);
 670 int evp_keymgmt_set_params(const EVP_KEYMGMT *keymgmt,
 671                            void *keydata, const OSSL_PARAM params[]);
 672 const OSSL_PARAM *evp_keymgmt_settable_params(const EVP_KEYMGMT *keymgmt);
 673
 674 void *evp_keymgmt_gen_init(const EVP_KEYMGMT *keymgmt, int selection);
 675 int evp_keymgmt_gen_set_template(const EVP_KEYMGMT *keymgmt, void *genctx,
 676                                  void *template);
 677 int evp_keymgmt_gen_set_params(const EVP_KEYMGMT *keymgmt, void *genctx,
 678                                const OSSL_PARAM params[]);
 679 const OSSL_PARAM *
 680 evp_keymgmt_gen_settable_params(const EVP_KEYMGMT *keymgmt);
 681 int evp_keymgmt_gen_get_params(const EVP_KEYMGMT *keymgmt, void *genctx,
 682                                OSSL_PARAM params[]);
 683 const OSSL_PARAM *
 684 evp_keymgmt_gen_gettable_params(const EVP_KEYMGMT *keymgmt);
 685 void *evp_keymgmt_gen(const EVP_KEYMGMT *keymgmt, void *genctx,
 686                       OSSL_CALLBACK *cb, void *cbarg);
 687 void evp_keymgmt_gen_cleanup(const EVP_KEYMGMT *keymgmt, void *genctx);
 688
 689 int evp_keymgmt_has(const EVP_KEYMGMT *keymgmt, void *keyddata, int selection);
 690 int evp_keymgmt_validate(const EVP_KEYMGMT *keymgmt, void *keydata,
 691                          int selection);
 692 int evp_keymgmt_match(const EVP_KEYMGMT *keymgmt,
 693                       const void *keydata1, const void *keydata2,
 694                       int selection);
 695
 696 int evp_keymgmt_import(const EVP_KEYMGMT *keymgmt, void *keydata,
 697                        int selection, const OSSL_PARAM params[]);
 698 const OSSL_PARAM *evp_keymgmt_import_types(const EVP_KEYMGMT *keymgmt,
 699                                            int selection);
 700 int evp_keymgmt_export(const EVP_KEYMGMT *keymgmt, void *keydata,
 701                        int selection, OSSL_CALLBACK *param_cb, void *cbarg);
 702 const OSSL_PARAM *evp_keymgmt_export_types(const EVP_KEYMGMT *keymgmt,
 703                                            int selection);
 704 int evp_keymgmt_copy(const EVP_KEYMGMT *keymgmt,
 705                      void *keydata_to, const void *keydata_from,
 706                      int selection);
 707
 708 /* Pulling defines out of C source files */
 709
 710 #define EVP_RC4_KEY_SIZE 16
 711 #ifndef TLS1_1_VERSION
 712 # define TLS1_1_VERSION   0x0302
 713 #endif
 714
 715 void evp_encode_ctx_set_flags(EVP_ENCODE_CTX *ctx, unsigned int flags);
 716
 717 /* EVP_ENCODE_CTX flags */
 718 /* Don't generate new lines when encoding */
 719 #define EVP_ENCODE_CTX_NO_NEWLINES          1
 720 /* Use the SRP base64 alphabet instead of the standard one */
 721 #define EVP_ENCODE_CTX_USE_SRP_ALPHABET     2
 722
 723 const EVP_CIPHER *evp_get_cipherbyname_ex(OPENSSL_CTX *libctx, const char *name);
 724 const EVP_MD *evp_get_digestbyname_ex(OPENSSL_CTX *libctx, const char *name);
 725
 726 #ifndef FIPS_MODULE
 727 /*
 728  * Internal helpers for stricter EVP_PKEY_CTX_{set,get}_params().
 729  *
 730  * Return 1 on success, 0 or negative for errors.
 731  *
 732  * In particular they return -2 if any of the params is not supported.
 733  *
 734  * They are not available in FIPS_MODULE as they depend on
 735  *      - EVP_PKEY_CTX_{get,set}_params()
 736  *      - EVP_PKEY_CTX_{gettable,settable}_params()
 737  *
 738  */
 739 int evp_pkey_ctx_set_params_strict(EVP_PKEY_CTX *ctx, OSSL_PARAM *params);
 740 int evp_pkey_ctx_get_params_strict(EVP_PKEY_CTX *ctx, OSSL_PARAM *params);
 741
 742 EVP_PKEY *evp_pkcs82pkey_int(const PKCS8_PRIV_KEY_INFO *p8, OPENSSL_CTX *libctx,
 743                              const char *propq);
 744 #endif /* !defined(FIPS_MODULE) */