Make EVP_CIPHER opaque and add creator/destructor/accessor/writer functions
[openssl.git] / crypto / include / internal / evp_int.h
1 /* evp_int.h */
2 /*
3  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
4  * 2015.
5  */
6 /* ====================================================================
7  * Copyright (c) 2015 The OpenSSL Project.  All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  *
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in
18  *    the documentation and/or other materials provided with the
19  *    distribution.
20  *
21  * 3. All advertising materials mentioning features or use of this
22  *    software must display the following acknowledgment:
23  *    "This product includes software developed by the OpenSSL Project
24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25  *
26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27  *    endorse or promote products derived from this software without
28  *    prior written permission. For written permission, please contact
29  *    licensing@OpenSSL.org.
30  *
31  * 5. Products derived from this software may not be called "OpenSSL"
32  *    nor may "OpenSSL" appear in their names without prior written
33  *    permission of the OpenSSL Project.
34  *
35  * 6. Redistributions of any form whatsoever must retain the following
36  *    acknowledgment:
37  *    "This product includes software developed by the OpenSSL Project
38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39  *
40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51  * OF THE POSSIBILITY OF SUCH DAMAGE.
52  * ====================================================================
53  *
54  * This product includes cryptographic software written by Eric Young
55  * (eay@cryptsoft.com).  This product includes software written by Tim
56  * Hudson (tjh@cryptsoft.com).
57  *
58  */
59
60 struct evp_pkey_ctx_st {
61     /* Method associated with this operation */
62     const EVP_PKEY_METHOD *pmeth;
63     /* Engine that implements this method or NULL if builtin */
64     ENGINE *engine;
65     /* Key: may be NULL */
66     EVP_PKEY *pkey;
67     /* Peer key for key agreement, may be NULL */
68     EVP_PKEY *peerkey;
69     /* Actual operation */
70     int operation;
71     /* Algorithm specific data */
72     void *data;
73     /* Application specific data */
74     void *app_data;
75     /* Keygen callback */
76     EVP_PKEY_gen_cb *pkey_gencb;
77     /* implementation specific keygen data */
78     int *keygen_info;
79     int keygen_info_count;
80 } /* EVP_PKEY_CTX */ ;
81
82 #define EVP_PKEY_FLAG_DYNAMIC   1
83
84 struct evp_pkey_method_st {
85     int pkey_id;
86     int flags;
87     int (*init) (EVP_PKEY_CTX *ctx);
88     int (*copy) (EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src);
89     void (*cleanup) (EVP_PKEY_CTX *ctx);
90     int (*paramgen_init) (EVP_PKEY_CTX *ctx);
91     int (*paramgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);
92     int (*keygen_init) (EVP_PKEY_CTX *ctx);
93     int (*keygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);
94     int (*sign_init) (EVP_PKEY_CTX *ctx);
95     int (*sign) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
96                  const unsigned char *tbs, size_t tbslen);
97     int (*verify_init) (EVP_PKEY_CTX *ctx);
98     int (*verify) (EVP_PKEY_CTX *ctx,
99                    const unsigned char *sig, size_t siglen,
100                    const unsigned char *tbs, size_t tbslen);
101     int (*verify_recover_init) (EVP_PKEY_CTX *ctx);
102     int (*verify_recover) (EVP_PKEY_CTX *ctx,
103                            unsigned char *rout, size_t *routlen,
104                            const unsigned char *sig, size_t siglen);
105     int (*signctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
106     int (*signctx) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
107                     EVP_MD_CTX *mctx);
108     int (*verifyctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
109     int (*verifyctx) (EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
110                       EVP_MD_CTX *mctx);
111     int (*encrypt_init) (EVP_PKEY_CTX *ctx);
112     int (*encrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
113                     const unsigned char *in, size_t inlen);
114     int (*decrypt_init) (EVP_PKEY_CTX *ctx);
115     int (*decrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
116                     const unsigned char *in, size_t inlen);
117     int (*derive_init) (EVP_PKEY_CTX *ctx);
118     int (*derive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
119     int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1, void *p2);
120     int (*ctrl_str) (EVP_PKEY_CTX *ctx, const char *type, const char *value);
121 } /* EVP_PKEY_METHOD */ ;
122
123 DEFINE_STACK_OF_CONST(EVP_PKEY_METHOD)
124
125 void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx);
126
127 extern const EVP_PKEY_METHOD cmac_pkey_meth;
128 extern const EVP_PKEY_METHOD dh_pkey_meth;
129 extern const EVP_PKEY_METHOD dhx_pkey_meth;
130 extern const EVP_PKEY_METHOD dsa_pkey_meth;
131 extern const EVP_PKEY_METHOD ec_pkey_meth;
132 extern const EVP_PKEY_METHOD hmac_pkey_meth;
133 extern const EVP_PKEY_METHOD rsa_pkey_meth;
134
135 struct evp_md_st {
136     int type;
137     int pkey_type;
138     int md_size;
139     unsigned long flags;
140     int (*init) (EVP_MD_CTX *ctx);
141     int (*update) (EVP_MD_CTX *ctx, const void *data, size_t count);
142     int (*final) (EVP_MD_CTX *ctx, unsigned char *md);
143     int (*copy) (EVP_MD_CTX *to, const EVP_MD_CTX *from);
144     int (*cleanup) (EVP_MD_CTX *ctx);
145     int block_size;
146     int ctx_size;               /* how big does the ctx->md_data need to be */
147     /* control function */
148     int (*md_ctrl) (EVP_MD_CTX *ctx, int cmd, int p1, void *p2);
149 } /* EVP_MD */ ;
150
151 struct evp_cipher_st {
152     int nid;
153     int block_size;
154     /* Default value for variable length ciphers */
155     int key_len;
156     int iv_len;
157     /* Various flags */
158     unsigned long flags;
159     /* init key */
160     int (*init) (EVP_CIPHER_CTX *ctx, const unsigned char *key,
161                  const unsigned char *iv, int enc);
162     /* encrypt/decrypt data */
163     int (*do_cipher) (EVP_CIPHER_CTX *ctx, unsigned char *out,
164                       const unsigned char *in, size_t inl);
165     /* cleanup ctx */
166     int (*cleanup) (EVP_CIPHER_CTX *);
167     /* how big ctx->cipher_data needs to be */
168     int ctx_size;
169     /* Populate a ASN1_TYPE with parameters */
170     int (*set_asn1_parameters) (EVP_CIPHER_CTX *, ASN1_TYPE *);
171     /* Get parameters from a ASN1_TYPE */
172     int (*get_asn1_parameters) (EVP_CIPHER_CTX *, ASN1_TYPE *);
173     /* Miscellaneous operations */
174     int (*ctrl) (EVP_CIPHER_CTX *, int type, int arg, void *ptr);
175     /* Application data */
176     void *app_data;
177 } /* EVP_CIPHER */ ;
178
179 /* Macros to code block cipher wrappers */
180
181 /* Wrapper functions for each cipher mode */
182
183 #define EVP_C_DATA(kstruct, ctx)   ((kstruct *)EVP_CIPHER_CTX_cipher_data(ctx))
184
185 #define BLOCK_CIPHER_ecb_loop() \
186         size_t i, bl; \
187         bl = EVP_CIPHER_CTX_cipher(ctx)->block_size;    \
188         if(inl < bl) return 1;\
189         inl -= bl; \
190         for(i=0; i <= inl; i+=bl)
191
192 #define BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
193 static int cname##_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
194 {\
195         BLOCK_CIPHER_ecb_loop() \
196             cprefix##_ecb_encrypt(in + i, out + i, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_encrypting(ctx)); \
197         return 1;\
198 }
199
200 #define EVP_MAXCHUNK ((size_t)1<<(sizeof(long)*8-2))
201
202 #define BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched) \
203     static int cname##_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
204 {\
205         while(inl>=EVP_MAXCHUNK) {\
206             int num = EVP_CIPHER_CTX_num(ctx);\
207             cprefix##_ofb##cbits##_encrypt(in, out, (long)EVP_MAXCHUNK, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx), &num); \
208             EVP_CIPHER_CTX_set_num(ctx, num);\
209             inl-=EVP_MAXCHUNK;\
210             in +=EVP_MAXCHUNK;\
211             out+=EVP_MAXCHUNK;\
212         }\
213         if (inl) {\
214             int num = EVP_CIPHER_CTX_num(ctx);\
215             cprefix##_ofb##cbits##_encrypt(in, out, (long)inl, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx), &num); \
216             EVP_CIPHER_CTX_set_num(ctx, num);\
217         }\
218         return 1;\
219 }
220
221 #define BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
222 static int cname##_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
223 {\
224         while(inl>=EVP_MAXCHUNK) \
225             {\
226             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));\
227             inl-=EVP_MAXCHUNK;\
228             in +=EVP_MAXCHUNK;\
229             out+=EVP_MAXCHUNK;\
230             }\
231         if (inl)\
232             cprefix##_cbc_encrypt(in, out, (long)inl, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx), EVP_CIPHER_CTX_encrypting(ctx));\
233         return 1;\
234 }
235
236 #define BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched)  \
237 static int cname##_cfb##cbits##_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
238 {\
239         size_t chunk=EVP_MAXCHUNK;\
240         if (cbits==1)  chunk>>=3;\
241         if (inl<chunk) chunk=inl;\
242         while(inl && inl>=chunk)\
243             {\
244             int num = EVP_CIPHER_CTX_num(ctx);\
245             cprefix##_cfb##cbits##_encrypt(in, out, (long)((cbits==1) && !EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS) ?inl*8:inl), &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx)); \
246             EVP_CIPHER_CTX_set_num(ctx, num);\
247             inl-=chunk;\
248             in +=chunk;\
249             out+=chunk;\
250             if(inl<chunk) chunk=inl;\
251             }\
252         return 1;\
253 }
254
255 #define BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
256         BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
257         BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \
258         BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
259         BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched)
260
261 #define BLOCK_CIPHER_def1(cname, nmode, mode, MODE, kstruct, nid, block_size, \
262                           key_len, iv_len, flags, init_key, cleanup, \
263                           set_asn1, get_asn1, ctrl) \
264 static const EVP_CIPHER cname##_##mode = { \
265         nid##_##nmode, block_size, key_len, iv_len, \
266         flags | EVP_CIPH_##MODE##_MODE, \
267         init_key, \
268         cname##_##mode##_cipher, \
269         cleanup, \
270         sizeof(kstruct), \
271         set_asn1, get_asn1,\
272         ctrl, \
273         NULL \
274 }; \
275 const EVP_CIPHER *EVP_##cname##_##mode(void) { return &cname##_##mode; }
276
277 #define BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, \
278                              iv_len, flags, init_key, cleanup, set_asn1, \
279                              get_asn1, ctrl) \
280 BLOCK_CIPHER_def1(cname, cbc, cbc, CBC, kstruct, nid, block_size, key_len, \
281                   iv_len, flags, init_key, cleanup, set_asn1, get_asn1, ctrl)
282
283 #define BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, \
284                              iv_len, cbits, flags, init_key, cleanup, \
285                              set_asn1, get_asn1, ctrl) \
286 BLOCK_CIPHER_def1(cname, cfb##cbits, cfb##cbits, CFB, kstruct, nid, 1, \
287                   key_len, iv_len, flags, init_key, cleanup, set_asn1, \
288                   get_asn1, ctrl)
289
290 #define BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, \
291                              iv_len, cbits, flags, init_key, cleanup, \
292                              set_asn1, get_asn1, ctrl) \
293 BLOCK_CIPHER_def1(cname, ofb##cbits, ofb, OFB, kstruct, nid, 1, \
294                   key_len, iv_len, flags, init_key, cleanup, set_asn1, \
295                   get_asn1, ctrl)
296
297 #define BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, \
298                              flags, init_key, cleanup, set_asn1, \
299                              get_asn1, ctrl) \
300 BLOCK_CIPHER_def1(cname, ecb, ecb, ECB, kstruct, nid, block_size, key_len, \
301                   0, flags, init_key, cleanup, set_asn1, get_asn1, ctrl)
302
303 #define BLOCK_CIPHER_defs(cname, kstruct, \
304                           nid, block_size, key_len, iv_len, cbits, flags, \
305                           init_key, cleanup, set_asn1, get_asn1, ctrl) \
306 BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, iv_len, flags, \
307                      init_key, cleanup, set_asn1, get_asn1, ctrl) \
308 BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, iv_len, cbits, \
309                      flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
310 BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, iv_len, cbits, \
311                      flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
312 BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, flags, \
313                      init_key, cleanup, set_asn1, get_asn1, ctrl)
314
315 /*-
316 #define BLOCK_CIPHER_defs(cname, kstruct, \
317                                 nid, block_size, key_len, iv_len, flags,\
318                                  init_key, cleanup, set_asn1, get_asn1, ctrl)\
319 static const EVP_CIPHER cname##_cbc = {\
320         nid##_cbc, block_size, key_len, iv_len, \
321         flags | EVP_CIPH_CBC_MODE,\
322         init_key,\
323         cname##_cbc_cipher,\
324         cleanup,\
325         sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
326                 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
327         set_asn1, get_asn1,\
328         ctrl, \
329         NULL \
330 };\
331 const EVP_CIPHER *EVP_##cname##_cbc(void) { return &cname##_cbc; }\
332 static const EVP_CIPHER cname##_cfb = {\
333         nid##_cfb64, 1, key_len, iv_len, \
334         flags | EVP_CIPH_CFB_MODE,\
335         init_key,\
336         cname##_cfb_cipher,\
337         cleanup,\
338         sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
339                 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
340         set_asn1, get_asn1,\
341         ctrl,\
342         NULL \
343 };\
344 const EVP_CIPHER *EVP_##cname##_cfb(void) { return &cname##_cfb; }\
345 static const EVP_CIPHER cname##_ofb = {\
346         nid##_ofb64, 1, key_len, iv_len, \
347         flags | EVP_CIPH_OFB_MODE,\
348         init_key,\
349         cname##_ofb_cipher,\
350         cleanup,\
351         sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
352                 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
353         set_asn1, get_asn1,\
354         ctrl,\
355         NULL \
356 };\
357 const EVP_CIPHER *EVP_##cname##_ofb(void) { return &cname##_ofb; }\
358 static const EVP_CIPHER cname##_ecb = {\
359         nid##_ecb, block_size, key_len, iv_len, \
360         flags | EVP_CIPH_ECB_MODE,\
361         init_key,\
362         cname##_ecb_cipher,\
363         cleanup,\
364         sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
365                 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
366         set_asn1, get_asn1,\
367         ctrl,\
368         NULL \
369 };\
370 const EVP_CIPHER *EVP_##cname##_ecb(void) { return &cname##_ecb; }
371 */
372
373 #define IMPLEMENT_BLOCK_CIPHER(cname, ksched, cprefix, kstruct, nid, \
374                                block_size, key_len, iv_len, cbits, \
375                                flags, init_key, \
376                                cleanup, set_asn1, get_asn1, ctrl) \
377         BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
378         BLOCK_CIPHER_defs(cname, kstruct, nid, block_size, key_len, iv_len, \
379                           cbits, flags, init_key, cleanup, set_asn1, \
380                           get_asn1, ctrl)
381
382 #define IMPLEMENT_CFBR(cipher,cprefix,kstruct,ksched,keysize,cbits,iv_len,fl) \
383         BLOCK_CIPHER_func_cfb(cipher##_##keysize,cprefix,cbits,kstruct,ksched) \
384         BLOCK_CIPHER_def_cfb(cipher##_##keysize,kstruct, \
385                              NID_##cipher##_##keysize, keysize/8, iv_len, cbits, \
386                              (fl)|EVP_CIPH_FLAG_DEFAULT_ASN1, \
387                              cipher##_init_key, NULL, NULL, NULL, NULL)
388