Enc doesn't support AEAD ciphers.
[openssl.git] / crypto / evp / pmeth_fn.c
1 /* pmeth_fn.c */
2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3  * project 2006.
4  */
5 /* ====================================================================
6  * Copyright (c) 2006 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 #include <stdio.h>
60 #include <stdlib.h>
61 #include "cryptlib.h"
62 #include <openssl/objects.h>
63 #include <openssl/evp.h>
64 #include "evp_locl.h"
65
66 #define M_check_autoarg(ctx, arg, arglen, err) \
67         if (ctx->pmeth->flags & EVP_PKEY_FLAG_AUTOARGLEN) \
68                 { \
69                 size_t pksize = (size_t)EVP_PKEY_size(ctx->pkey); \
70                 if (!arg) \
71                         { \
72                         *arglen = pksize; \
73                         return 1; \
74                         } \
75                 else if (*arglen < pksize) \
76                         { \
77                         EVPerr(err, EVP_R_BUFFER_TOO_SMALL); /*ckerr_ignore*/\
78                         return 0; \
79                         } \
80                 }
81
82 int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx)
83         {
84         int ret;
85         if (!ctx || !ctx->pmeth || !ctx->pmeth->sign)
86                 {
87                 EVPerr(EVP_F_EVP_PKEY_SIGN_INIT,
88                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
89                 return -2;
90                 }
91         ctx->operation = EVP_PKEY_OP_SIGN;
92         if (!ctx->pmeth->sign_init)
93                 return 1;
94         ret = ctx->pmeth->sign_init(ctx);
95         if (ret <= 0)
96                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
97         return ret;
98         }
99
100 int EVP_PKEY_sign(EVP_PKEY_CTX *ctx,
101                         unsigned char *sig, size_t *siglen,
102                         const unsigned char *tbs, size_t tbslen)
103         {
104         if (!ctx || !ctx->pmeth || !ctx->pmeth->sign)
105                 {
106                 EVPerr(EVP_F_EVP_PKEY_SIGN,
107                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
108                 return -2;
109                 }
110         if (ctx->operation != EVP_PKEY_OP_SIGN)
111                 {
112                 EVPerr(EVP_F_EVP_PKEY_SIGN, EVP_R_OPERATON_NOT_INITIALIZED);
113                 return -1;
114                 }
115         M_check_autoarg(ctx, sig, siglen, EVP_F_EVP_PKEY_SIGN)
116         return ctx->pmeth->sign(ctx, sig, siglen, tbs, tbslen);
117         }
118
119 int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx)
120         {
121         int ret;
122         if (!ctx || !ctx->pmeth || !ctx->pmeth->verify)
123                 {
124                 EVPerr(EVP_F_EVP_PKEY_VERIFY_INIT,
125                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
126                 return -2;
127                 }
128         ctx->operation = EVP_PKEY_OP_VERIFY;
129         if (!ctx->pmeth->verify_init)
130                 return 1;
131         ret = ctx->pmeth->verify_init(ctx);
132         if (ret <= 0)
133                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
134         return ret;
135         }
136
137 int EVP_PKEY_verify(EVP_PKEY_CTX *ctx,
138                         const unsigned char *sig, size_t siglen,
139                         const unsigned char *tbs, size_t tbslen)
140         {
141         if (!ctx || !ctx->pmeth || !ctx->pmeth->verify)
142                 {
143                 EVPerr(EVP_F_EVP_PKEY_VERIFY,
144                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
145                 return -2;
146                 }
147         if (ctx->operation != EVP_PKEY_OP_VERIFY)
148                 {
149                 EVPerr(EVP_F_EVP_PKEY_VERIFY, EVP_R_OPERATON_NOT_INITIALIZED);
150                 return -1;
151                 }
152         return ctx->pmeth->verify(ctx, sig, siglen, tbs, tbslen);
153         }
154
155 int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx)
156         {
157         int ret;
158         if (!ctx || !ctx->pmeth || !ctx->pmeth->verify_recover)
159                 {
160                 EVPerr(EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT,
161                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
162                 return -2;
163                 }
164         ctx->operation = EVP_PKEY_OP_VERIFYRECOVER;
165         if (!ctx->pmeth->verify_recover_init)
166                 return 1;
167         ret = ctx->pmeth->verify_recover_init(ctx);
168         if (ret <= 0)
169                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
170         return ret;
171         }
172
173 int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx,
174                         unsigned char *rout, size_t *routlen,
175                         const unsigned char *sig, size_t siglen)
176         {
177         if (!ctx || !ctx->pmeth || !ctx->pmeth->verify_recover)
178                 {
179                 EVPerr(EVP_F_EVP_PKEY_VERIFY_RECOVER,
180                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
181                 return -2;
182                 }
183         if (ctx->operation != EVP_PKEY_OP_VERIFYRECOVER)
184                 {
185                 EVPerr(EVP_F_EVP_PKEY_VERIFY_RECOVER, EVP_R_OPERATON_NOT_INITIALIZED);
186                 return -1;
187                 }
188         M_check_autoarg(ctx, rout, routlen, EVP_F_EVP_PKEY_VERIFY_RECOVER)
189         return ctx->pmeth->verify_recover(ctx, rout, routlen, sig, siglen);
190         }
191
192 int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx)
193         {
194         int ret;
195         if (!ctx || !ctx->pmeth || !ctx->pmeth->encrypt)
196                 {
197                 EVPerr(EVP_F_EVP_PKEY_ENCRYPT_INIT,
198                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
199                 return -2;
200                 }
201         ctx->operation = EVP_PKEY_OP_ENCRYPT;
202         if (!ctx->pmeth->encrypt_init)
203                 return 1;
204         ret = ctx->pmeth->encrypt_init(ctx);
205         if (ret <= 0)
206                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
207         return ret;
208         }
209
210 int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,
211                         unsigned char *out, size_t *outlen,
212                         const unsigned char *in, size_t inlen)
213         {
214         if (!ctx || !ctx->pmeth || !ctx->pmeth->encrypt)
215                 {
216                 EVPerr(EVP_F_EVP_PKEY_ENCRYPT,
217                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
218                 return -2;
219                 }
220         if (ctx->operation != EVP_PKEY_OP_ENCRYPT)
221                 {
222                 EVPerr(EVP_F_EVP_PKEY_ENCRYPT, EVP_R_OPERATON_NOT_INITIALIZED);
223                 return -1;
224                 }
225         M_check_autoarg(ctx, out, outlen, EVP_F_EVP_PKEY_ENCRYPT)
226         return ctx->pmeth->encrypt(ctx, out, outlen, in, inlen);
227         }
228
229 int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx)
230         {
231         int ret;
232         if (!ctx || !ctx->pmeth || !ctx->pmeth->decrypt)
233                 {
234                 EVPerr(EVP_F_EVP_PKEY_DECRYPT_INIT,
235                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
236                 return -2;
237                 }
238         ctx->operation = EVP_PKEY_OP_DECRYPT;
239         if (!ctx->pmeth->decrypt_init)
240                 return 1;
241         ret = ctx->pmeth->decrypt_init(ctx);
242         if (ret <= 0)
243                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
244         return ret;
245         }
246
247 int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,
248                         unsigned char *out, size_t *outlen,
249                         const unsigned char *in, size_t inlen)
250         {
251         if (!ctx || !ctx->pmeth || !ctx->pmeth->decrypt)
252                 {
253                 EVPerr(EVP_F_EVP_PKEY_DECRYPT,
254                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
255                 return -2;
256                 }
257         if (ctx->operation != EVP_PKEY_OP_DECRYPT)
258                 {
259                 EVPerr(EVP_F_EVP_PKEY_DECRYPT, EVP_R_OPERATON_NOT_INITIALIZED);
260                 return -1;
261                 }
262         M_check_autoarg(ctx, out, outlen, EVP_F_EVP_PKEY_DECRYPT)
263         return ctx->pmeth->decrypt(ctx, out, outlen, in, inlen);
264         }
265
266
267 int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx)
268         {
269         int ret;
270         if (!ctx || !ctx->pmeth || !ctx->pmeth->derive)
271                 {
272                 EVPerr(EVP_F_EVP_PKEY_DERIVE_INIT,
273                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
274                 return -2;
275                 }
276         ctx->operation = EVP_PKEY_OP_DERIVE;
277         if (!ctx->pmeth->derive_init)
278                 return 1;
279         ret = ctx->pmeth->derive_init(ctx);
280         if (ret <= 0)
281                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
282         return ret;
283         }
284
285 int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer)
286         {
287         int ret;
288         if (!ctx || !ctx->pmeth || !(ctx->pmeth->derive||ctx->pmeth->encrypt||ctx->pmeth->decrypt) || !ctx->pmeth->ctrl)
289                 {
290                 EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER,
291                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
292                 return -2;
293                 }
294         if (ctx->operation != EVP_PKEY_OP_DERIVE && ctx->operation != EVP_PKEY_OP_ENCRYPT && ctx->operation != EVP_PKEY_OP_DECRYPT)
295                 {
296                 EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER,
297                                         EVP_R_OPERATON_NOT_INITIALIZED);
298                 return -1;
299                 }
300
301         ret = ctx->pmeth->ctrl(ctx, EVP_PKEY_CTRL_PEER_KEY, 0, peer);
302
303         if (ret <= 0)
304                 return ret;
305
306         if (ret == 2)
307                 return 1;
308
309         if (!ctx->pkey)
310                 {
311                 EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER, EVP_R_NO_KEY_SET);
312                 return -1;
313                 }
314
315         if (ctx->pkey->type != peer->type)
316                 {
317                 EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER,
318                                                 EVP_R_DIFFERENT_KEY_TYPES);
319                 return -1;
320                 }
321
322         /* ran@cryptocom.ru: For clarity.  The error is if parameters in peer are
323          * present (!missing) but don't match.  EVP_PKEY_cmp_parameters may return
324          * 1 (match), 0 (don't match) and -2 (comparison is not defined).  -1
325          * (different key types) is impossible here because it is checked earlier.
326          * -2 is OK for us here, as well as 1, so we can check for 0 only. */
327         if (!EVP_PKEY_missing_parameters(peer) &&
328                 !EVP_PKEY_cmp_parameters(ctx->pkey, peer))
329                 {
330                 EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER,
331                                                 EVP_R_DIFFERENT_PARAMETERS);
332                 return -1;
333                 }
334
335         if (ctx->peerkey)
336                 EVP_PKEY_free(ctx->peerkey);
337         ctx->peerkey = peer;
338
339         ret = ctx->pmeth->ctrl(ctx, EVP_PKEY_CTRL_PEER_KEY, 1, peer);
340
341         if (ret <= 0)
342                 {
343                 ctx->peerkey = NULL;
344                 return ret;
345                 }
346
347         CRYPTO_add(&peer->references,1,CRYPTO_LOCK_EVP_PKEY);
348         return 1;
349         }
350
351
352 int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *pkeylen)
353         {
354         if (!ctx || !ctx->pmeth || !ctx->pmeth->derive)
355                 {
356                 EVPerr(EVP_F_EVP_PKEY_DERIVE,
357                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
358                 return -2;
359                 }
360         if (ctx->operation != EVP_PKEY_OP_DERIVE)
361                 {
362                 EVPerr(EVP_F_EVP_PKEY_DERIVE, EVP_R_OPERATON_NOT_INITIALIZED);
363                 return -1;
364                 }
365         M_check_autoarg(ctx, key, pkeylen, EVP_F_EVP_PKEY_DERIVE)
366         return ctx->pmeth->derive(ctx, key, pkeylen);
367         }
368