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