26000ac08b4f8f3b749bfcbd9cba116f4fbb0182
[openssl.git] / crypto / evp / evp_locl.h
1 /* evp_locl.h */
2 /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL
3  * project 2000.
4  */
5 /* ====================================================================
6  * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer. 
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    licensing@OpenSSL.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58
59 /* Macros to code block cipher wrappers */
60
61 /* Wrapper functions for each cipher mode */
62
63 #define BLOCK_CIPHER_ecb_loop() \
64         unsigned int i, bl; \
65         bl = ctx->cipher->block_size;\
66         if(inl < bl) return 1;\
67         inl -= bl; \
68         for(i=0; i <= inl; i+=bl) \
69
70 #define BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
71 static int cname##_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl) \
72 {\
73         BLOCK_CIPHER_ecb_loop() \
74                 cprefix##_ecb_encrypt(in + i, out + i, &((kstruct *)ctx->cipher_data)->ksched, ctx->encrypt);\
75         return 1;\
76 }
77
78 #define BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched) \
79 static int cname##_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl) \
80 {\
81         cprefix##_ofb##cbits##_encrypt(in, out, (long)inl, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, &ctx->num);\
82         return 1;\
83 }
84
85 #define BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
86 static int cname##_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl) \
87 {\
88         cprefix##_cbc_encrypt(in, out, (long)inl, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, ctx->encrypt);\
89         return 1;\
90 }
91
92 #define BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \
93 static int cname##_cfb##cbits##_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl) \
94 {\
95         cprefix##_cfb##cbits##_encrypt(in, out, (long)inl, &((kstruct *)ctx->cipher_data)->ksched, ctx->iv, &ctx->num, ctx->encrypt);\
96         return 1;\
97 }
98
99 #define BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
100         BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
101         BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \
102         BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
103         BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched)
104
105 #define BLOCK_CIPHER_def1(cname, nmode, mode, MODE, kstruct, nid, block_size, \
106                           key_len, iv_len, flags, init_key, cleanup, \
107                           set_asn1, get_asn1, ctrl) \
108 static const EVP_CIPHER cname##_##mode = { \
109         nid##_##nmode, block_size, key_len, iv_len, \
110         flags | EVP_CIPH_##MODE##_MODE, \
111         init_key, \
112         cname##_##mode##_cipher, \
113         cleanup, \
114         sizeof(kstruct), \
115         set_asn1, get_asn1,\
116         ctrl, \
117         NULL \
118 }; \
119 const EVP_CIPHER *EVP_##cname##_##mode(void) { return &cname##_##mode; }
120
121 #define BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, \
122                              iv_len, flags, init_key, cleanup, set_asn1, \
123                              get_asn1, ctrl) \
124 BLOCK_CIPHER_def1(cname, cbc, cbc, CBC, kstruct, nid, block_size, key_len, \
125                   iv_len, flags, init_key, cleanup, set_asn1, get_asn1, ctrl)
126
127 #define BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, \
128                              iv_len, cbits, flags, init_key, cleanup, \
129                              set_asn1, get_asn1, ctrl) \
130 BLOCK_CIPHER_def1(cname, cfb##cbits, cfb##cbits, CFB, kstruct, nid, 1, \
131                   key_len, iv_len, flags, init_key, cleanup, set_asn1, \
132                   get_asn1, ctrl)
133
134 #define BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, \
135                              iv_len, cbits, flags, init_key, cleanup, \
136                              set_asn1, get_asn1, ctrl) \
137 BLOCK_CIPHER_def1(cname, ofb##cbits, ofb, OFB, kstruct, nid, 1, \
138                   key_len, iv_len, flags, init_key, cleanup, set_asn1, \
139                   get_asn1, ctrl)
140
141 #define BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, \
142                              iv_len, flags, init_key, cleanup, set_asn1, \
143                              get_asn1, ctrl) \
144 BLOCK_CIPHER_def1(cname, ecb, ecb, ECB, kstruct, nid, block_size, key_len, \
145                   iv_len, flags, init_key, cleanup, set_asn1, get_asn1, ctrl)
146
147 #define BLOCK_CIPHER_defs(cname, kstruct, \
148                           nid, block_size, key_len, iv_len, cbits, flags, \
149                           init_key, cleanup, set_asn1, get_asn1, ctrl) \
150 BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, iv_len, flags, \
151                      init_key, cleanup, set_asn1, get_asn1, ctrl) \
152 BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, iv_len, cbits, \
153                      flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
154 BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, iv_len, cbits, \
155                      flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
156 BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, iv_len, flags, \
157                      init_key, cleanup, set_asn1, get_asn1, ctrl)
158
159
160 /*
161 #define BLOCK_CIPHER_defs(cname, kstruct, \
162                                 nid, block_size, key_len, iv_len, flags,\
163                                  init_key, cleanup, set_asn1, get_asn1, ctrl)\
164 static const EVP_CIPHER cname##_cbc = {\
165         nid##_cbc, block_size, key_len, iv_len, \
166         flags | EVP_CIPH_CBC_MODE,\
167         init_key,\
168         cname##_cbc_cipher,\
169         cleanup,\
170         sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
171                 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
172         set_asn1, get_asn1,\
173         ctrl, \
174         NULL \
175 };\
176 const EVP_CIPHER *EVP_##cname##_cbc(void) { return &cname##_cbc; }\
177 static const EVP_CIPHER cname##_cfb = {\
178         nid##_cfb64, 1, key_len, iv_len, \
179         flags | EVP_CIPH_CFB_MODE,\
180         init_key,\
181         cname##_cfb_cipher,\
182         cleanup,\
183         sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
184                 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
185         set_asn1, get_asn1,\
186         ctrl,\
187         NULL \
188 };\
189 const EVP_CIPHER *EVP_##cname##_cfb(void) { return &cname##_cfb; }\
190 static const EVP_CIPHER cname##_ofb = {\
191         nid##_ofb64, 1, key_len, iv_len, \
192         flags | EVP_CIPH_OFB_MODE,\
193         init_key,\
194         cname##_ofb_cipher,\
195         cleanup,\
196         sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
197                 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
198         set_asn1, get_asn1,\
199         ctrl,\
200         NULL \
201 };\
202 const EVP_CIPHER *EVP_##cname##_ofb(void) { return &cname##_ofb; }\
203 static const EVP_CIPHER cname##_ecb = {\
204         nid##_ecb, block_size, key_len, iv_len, \
205         flags | EVP_CIPH_ECB_MODE,\
206         init_key,\
207         cname##_ecb_cipher,\
208         cleanup,\
209         sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
210                 sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
211         set_asn1, get_asn1,\
212         ctrl,\
213         NULL \
214 };\
215 const EVP_CIPHER *EVP_##cname##_ecb(void) { return &cname##_ecb; }
216 */
217
218 #define IMPLEMENT_BLOCK_CIPHER(cname, ksched, cprefix, kstruct, nid, \
219                                block_size, key_len, iv_len, cbits, \
220                                flags, init_key, \
221                                cleanup, set_asn1, get_asn1, ctrl) \
222         BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
223         BLOCK_CIPHER_defs(cname, kstruct, nid, block_size, key_len, iv_len, \
224                           cbits, flags, init_key, cleanup, set_asn1, \
225                           get_asn1, ctrl)
226
227 #define EVP_C_DATA(kstruct, ctx)        ((kstruct *)(ctx)->cipher_data)
228
229 #define IMPLEMENT_CFBR(cipher,cprefix,kstruct,ksched,keysize,cbits,iv_len) \
230         BLOCK_CIPHER_func_cfb(cipher##_##keysize,cprefix,cbits,kstruct,ksched) \
231         BLOCK_CIPHER_def_cfb(cipher##_##keysize,kstruct, \
232                              NID_##cipher##_##keysize, keysize/8, iv_len, cbits, \
233                              0, cipher##_init_key, NULL, \
234                              EVP_CIPHER_set_asn1_iv, \
235                              EVP_CIPHER_get_asn1_iv, \
236                              NULL)
237
238
239 struct evp_pkey_ctx_st
240         {
241         /* Method associated with this operation */
242         const EVP_PKEY_METHOD *pmeth;
243         /* Key: may be NULL */
244         EVP_PKEY *pkey;
245         /* Actual operation */
246         int operation;
247         /* Algorithm specific data */
248         void *data;
249         } /* EVP_PKEY_CTX */;
250
251 #define EVP_PKEY_OP_UNDEFINED           0
252 #define EVP_PKEY_OP_PARAMGEN            1
253 #define EVP_PKEY_OP_KEYGEN              2
254 #define EVP_PKEY_OP_SIGN                3
255 #define EVP_PKEY_OP_VERIFY              4
256 #define EVP_PKEY_OP_VERIFYRECOVER       5
257 #define EVP_PKEY_OP_SIGNCTX             6
258 #define EVP_PKEY_OP_VERIFYCTX           7
259 #define EVP_PKEY_OP_ENCRYPT             8
260 #define EVP_PKEY_OP_DECRYPT             9
261
262 struct evp_pkey_method_st
263         {
264         int pkey_id;
265         int flags;
266         int (*init)(EVP_PKEY_CTX *ctx);
267
268         int (*paramgen_init)(EVP_PKEY_CTX *ctx);
269         int (*paramgen)(EVP_PKEY_CTX *ctx);
270
271         int (*keygen_init)(EVP_PKEY_CTX *ctx);
272         int (*keygen)(EVP_PKEY_CTX *ctx);
273
274         int (*sign_init)(EVP_PKEY_CTX *ctx);
275         int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, int *siglen,
276                                         unsigned char *tbs, int tbslen);
277
278         int (*verify_init)(EVP_PKEY_CTX *ctx);
279         int (*verify)(EVP_PKEY_CTX *ctx, unsigned char *sig, int siglen,
280                                         unsigned char *tbs, int tbslen);
281
282         int (*verify_recover_init)(EVP_PKEY_CTX *ctx);
283         int (*verify_recover)(EVP_PKEY_CTX *ctx,
284                                         unsigned char *rout, int *routlen,
285                                         unsigned char *sig, int siglen);
286
287         int (*signctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
288         int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, int *siglen,
289                                         EVP_MD_CTX *mctx);
290
291         int (*verifyctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
292         int (*verifyctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, int siglen,
293                                         EVP_MD_CTX *mctx);
294
295         int (*encrypt_init)(EVP_PKEY_CTX *ctx);
296         int (*encrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, int *outlen,
297                                         unsigned char *in, int inlen);
298
299         int (*decrypt_init)(EVP_PKEY_CTX *ctx);
300         int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, int *outlen,
301                                         unsigned char *in, int inlen);
302
303         int (*ctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2);
304         int (*ctrl_str)(EVP_PKEY_CTX *ctx, const char *type, const char *value);
305
306         void (*cleanup)(EVP_PKEY_CTX *ctx);
307
308         } /* EVP_PKEY_METHOD */;