e5f9aad010e302d463b94cfee5d946ea53f0b4ac
[openssl.git] / include / crypto / evp.h
1 /*
2  * Copyright 2015-2018 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_MODE
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
561     /* == Provider attributes == */
562
563     /*
564      * Provider keydata "origin" is composed of a pointer to an EVP_KEYMGMT
565      * and a pointer to the provider side key data.  This is never used at
566      * the same time as the legacy key data above.
567      */
568     EVP_KEYMGMT *keymgmt;
569     void *keydata;
570     /*
571      * If any libcrypto code does anything that may modify the keydata
572      * contents, this dirty counter must be incremented.
573      */
574     size_t dirty_cnt;
575
576     /*
577      * To support transparent execution of operation in backends other
578      * than the "origin" key, we support transparent export/import to
579      * those providers, and maintain a cache of the imported keydata,
580      * so we don't need to redo the export/import every time we perform
581      * the same operation in that same provider.
582      * This requires that the "origin" backend (whether it's a legacy or a
583      * provider "origin") implements exports, and that the target provider
584      * has an EVP_KEYMGMT that implements import.
585      *
586      * The cache limit is set at 10 different providers using the same
587      * "origin".  It's probably over the top, but is preferable to too
588      * few.
589      */
590     struct {
591         EVP_KEYMGMT *keymgmt;
592         void *keydata;
593     } operation_cache[10];
594     /*
595      * We keep a copy of that "origin"'s dirty count, so we know if the
596      * operation cache needs flushing.
597      */
598     size_t dirty_cnt_copy;
599
600     /* Cache of key object information */
601     struct {
602         int bits;
603         int security_bits;
604         int size;
605     } cache;
606 } /* EVP_PKEY */ ;
607
608 #define EVP_PKEY_CTX_IS_SIGNATURE_OP(ctx) \
609     ((ctx)->operation == EVP_PKEY_OP_SIGN \
610      || (ctx)->operation == EVP_PKEY_OP_SIGNCTX \
611      || (ctx)->operation == EVP_PKEY_OP_VERIFY \
612      || (ctx)->operation == EVP_PKEY_OP_VERIFYCTX \
613      || (ctx)->operation == EVP_PKEY_OP_VERIFYRECOVER)
614
615 #define EVP_PKEY_CTX_IS_DERIVE_OP(ctx) \
616     ((ctx)->operation == EVP_PKEY_OP_DERIVE)
617
618 #define EVP_PKEY_CTX_IS_ASYM_CIPHER_OP(ctx) \
619     ((ctx)->operation == EVP_PKEY_OP_ENCRYPT \
620      || (ctx)->operation == EVP_PKEY_OP_DECRYPT)
621
622 #define EVP_PKEY_CTX_IS_GEN_OP(ctx) \
623     ((ctx)->operation == EVP_PKEY_OP_PARAMGEN \
624      || (ctx)->operation == EVP_PKEY_OP_KEYGEN)
625
626 void openssl_add_all_ciphers_int(void);
627 void openssl_add_all_digests_int(void);
628 void evp_cleanup_int(void);
629 void evp_app_cleanup_int(void);
630 void *evp_pkey_export_to_provider(EVP_PKEY *pk, OPENSSL_CTX *libctx,
631                                   EVP_KEYMGMT **keymgmt,
632                                   const char *propquery);
633 void *evp_pkey_upgrade_to_provider(EVP_PKEY *pk, OPENSSL_CTX *libctx,
634                                    EVP_KEYMGMT **keymgmt,
635                                    const char *propquery);
636 #ifndef FIPS_MODE
637 void evp_pkey_free_legacy(EVP_PKEY *x);
638 #endif
639
640 /*
641  * KEYMGMT utility functions
642  */
643 void *evp_keymgmt_util_export_to_provider(EVP_PKEY *pk, EVP_KEYMGMT *keymgmt);
644 size_t evp_keymgmt_util_find_operation_cache_index(EVP_PKEY *pk,
645                                                    EVP_KEYMGMT *keymgmt);
646 void evp_keymgmt_util_clear_operation_cache(EVP_PKEY *pk);
647 int evp_keymgmt_util_cache_keydata(EVP_PKEY *pk, size_t index,
648                                    EVP_KEYMGMT *keymgmt, void *keydata);
649 void evp_keymgmt_util_cache_keyinfo(EVP_PKEY *pk);
650 void *evp_keymgmt_util_fromdata(EVP_PKEY *target, EVP_KEYMGMT *keymgmt,
651                                 int selection, const OSSL_PARAM params[]);
652 int evp_keymgmt_util_has(EVP_PKEY *pk, int selection);
653 int evp_keymgmt_util_match(EVP_PKEY *pk1, EVP_PKEY *pk2, int selection);
654 int evp_keymgmt_util_copy(EVP_PKEY *to, EVP_PKEY *from, int selection);
655 void *evp_keymgmt_util_gen(EVP_PKEY *target, EVP_KEYMGMT *keymgmt,
656                            void *genctx, OSSL_CALLBACK *cb, void *cbarg);
657
658
659 /*
660  * KEYMGMT provider interface functions
661  */
662 void *evp_keymgmt_newdata(const EVP_KEYMGMT *keymgmt);
663 void evp_keymgmt_freedata(const EVP_KEYMGMT *keymgmt, void *keyddata);
664 int evp_keymgmt_get_params(const EVP_KEYMGMT *keymgmt,
665                            void *keydata, OSSL_PARAM params[]);
666 const OSSL_PARAM *evp_keymgmt_gettable_params(const EVP_KEYMGMT *keymgmt);
667 int evp_keymgmt_set_params(const EVP_KEYMGMT *keymgmt,
668                            void *keydata, const OSSL_PARAM params[]);
669 const OSSL_PARAM *evp_keymgmt_settable_params(const EVP_KEYMGMT *keymgmt);
670
671 void *evp_keymgmt_gen_init(const EVP_KEYMGMT *keymgmt, int selection);
672 int evp_keymgmt_gen_set_template(const EVP_KEYMGMT *keymgmt, void *genctx,
673                                  void *template);
674 int evp_keymgmt_gen_set_params(const EVP_KEYMGMT *keymgmt, void *genctx,
675                                const OSSL_PARAM params[]);
676 const OSSL_PARAM *
677 evp_keymgmt_gen_settable_params(const EVP_KEYMGMT *keymgmt);
678 void *evp_keymgmt_gen(const EVP_KEYMGMT *keymgmt, void *genctx,
679                       OSSL_CALLBACK *cb, void *cbarg);
680 void evp_keymgmt_gen_cleanup(const EVP_KEYMGMT *keymgmt, void *genctx);
681
682 int evp_keymgmt_has(const EVP_KEYMGMT *keymgmt, void *keyddata, int selection);
683 int evp_keymgmt_validate(const EVP_KEYMGMT *keymgmt, void *keydata,
684                          int selection);
685 int evp_keymgmt_match(const EVP_KEYMGMT *keymgmt,
686                       const void *keydata1, const void *keydata2,
687                       int selection);
688
689 int evp_keymgmt_import(const EVP_KEYMGMT *keymgmt, void *keydata,
690                        int selection, const OSSL_PARAM params[]);
691 const OSSL_PARAM *evp_keymgmt_import_types(const EVP_KEYMGMT *keymgmt,
692                                            int selection);
693 int evp_keymgmt_export(const EVP_KEYMGMT *keymgmt, void *keydata,
694                        int selection, OSSL_CALLBACK *param_cb, void *cbarg);
695 const OSSL_PARAM *evp_keymgmt_export_types(const EVP_KEYMGMT *keymgmt,
696                                            int selection);
697 int evp_keymgmt_copy(const EVP_KEYMGMT *keymgmt,
698                      void *keydata_to, const void *keydata_from,
699                      int selection);
700
701 /* Pulling defines out of C source files */
702
703 #define EVP_RC4_KEY_SIZE 16
704 #ifndef TLS1_1_VERSION
705 # define TLS1_1_VERSION   0x0302
706 #endif
707
708 void evp_encode_ctx_set_flags(EVP_ENCODE_CTX *ctx, unsigned int flags);
709
710 /* EVP_ENCODE_CTX flags */
711 /* Don't generate new lines when encoding */
712 #define EVP_ENCODE_CTX_NO_NEWLINES          1
713 /* Use the SRP base64 alphabet instead of the standard one */
714 #define EVP_ENCODE_CTX_USE_SRP_ALPHABET     2
715
716 const EVP_CIPHER *evp_get_cipherbyname_ex(OPENSSL_CTX *libctx, const char *name);
717 const EVP_MD *evp_get_digestbyname_ex(OPENSSL_CTX *libctx, const char *name);
718
719 #ifndef FIPS_MODE
720 /*
721  * Internal helpers for stricter EVP_PKEY_CTX_{set,get}_params().
722  *
723  * Return 1 on success, 0 or negative for errors.
724  *
725  * In particular they return -2 if any of the params is not supported.
726  *
727  * They are not available in FIPS_MODE as they depend on
728  *      - EVP_PKEY_CTX_{get,set}_params()
729  *      - EVP_PKEY_CTX_{gettable,settable}_params()
730  *
731  */
732 int evp_pkey_ctx_set_params_strict(EVP_PKEY_CTX *ctx, OSSL_PARAM *params);
733 int evp_pkey_ctx_get_params_strict(EVP_PKEY_CTX *ctx, OSSL_PARAM *params);
734 #endif /* !defined(FIPS_MODE) */