1 /* crypto/ec/ec_kmeth.c */
3 * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
6 /* ====================================================================
7 * Copyright (c) 2015 The OpenSSL Project. All rights reserved.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
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
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/)"
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.
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.
35 * 6. Redistributions of any form whatsoever must retain the following
37 * "This product includes software developed by the OpenSSL Project
38 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
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 * ====================================================================
55 #include <openssl/ec.h>
56 #ifndef OPENSSL_NO_ENGINE
57 # include <openssl/engine.h>
59 #include <openssl/err.h>
63 static const EC_KEY_METHOD openssl_ec_key_method = {
64 "OpenSSL EC_KEY method",
68 ossl_ecdh_compute_key,
70 ossl_ecdsa_sign_setup,
76 static const EC_KEY_METHOD *default_ec_key_meth = &openssl_ec_key_method;
78 const EC_KEY_METHOD *EC_KEY_OpenSSL(void)
80 return &openssl_ec_key_method;
83 const EC_KEY_METHOD *EC_KEY_get_default_method(void)
85 return default_ec_key_meth;
88 void EC_KEY_set_default_method(const EC_KEY_METHOD *meth)
91 default_ec_key_meth = &openssl_ec_key_method;
93 default_ec_key_meth = meth;
96 EC_KEY *EC_KEY_new_method(ENGINE *engine)
98 EC_KEY *ret = OPENSSL_zalloc(sizeof(*ret));
101 ECerr(EC_F_EC_KEY_NEW_METHOD, ERR_R_MALLOC_FAILURE);
104 ret->meth = EC_KEY_get_default_method();
105 #ifndef OPENSSL_NO_ENGINE
106 if (engine != NULL) {
107 if (!ENGINE_init(engine)) {
108 ECerr(EC_F_EC_KEY_NEW_METHOD, ERR_R_ENGINE_LIB);
112 ret->engine = engine;
114 ret->engine = ENGINE_get_default_EC();
115 if (ret->engine != NULL) {
116 ret->meth = ENGINE_get_EC(ret->engine);
117 if (ret->meth == NULL) {
118 ECerr(EC_F_EC_KEY_NEW_METHOD, ERR_R_ENGINE_LIB);
119 ENGINE_finish(ret->engine);
127 ret->conv_form = POINT_CONVERSION_UNCOMPRESSED;
129 if (ret->meth->init != NULL && ret->meth->init(ret) == 0) {
136 int ECDH_compute_key(void *out, size_t outlen, const EC_POINT *pub_key,
138 void *(*KDF) (const void *in, size_t inlen, void *out,
141 if (eckey->meth->compute_key != NULL)
142 return eckey->meth->compute_key(out, outlen, pub_key, eckey, KDF);
143 ECerr(EC_F_ECDH_COMPUTE_KEY, EC_R_OPERATION_NOT_SUPPORTED);
147 EC_KEY_METHOD *EC_KEY_METHOD_new(const EC_KEY_METHOD *meth)
150 ret = OPENSSL_zalloc(sizeof(*meth));
155 ret->flags |= EC_KEY_METHOD_DYNAMIC;
159 void EC_KEY_METHOD_free(EC_KEY_METHOD *meth)
161 if (meth->flags & EC_KEY_METHOD_DYNAMIC)
165 void EC_KEY_METHOD_set_init(EC_KEY_METHOD *meth,
166 int (*init)(EC_KEY *key),
167 void (*finish)(EC_KEY *key),
168 int (*copy)(EC_KEY *dest, const EC_KEY *src),
169 int (*set_group)(EC_KEY *key, const EC_GROUP *grp),
170 int (*set_private)(EC_KEY *key,
171 const BIGNUM *priv_key),
172 int (*set_public)(EC_KEY *key,
173 const EC_POINT *pub_key))
176 meth->finish = finish;
178 meth->set_group = set_group;
179 meth->set_private = set_private;
180 meth->set_public = set_public;
183 void EC_KEY_METHOD_set_keygen(EC_KEY_METHOD *meth,
184 int (*keygen)(EC_KEY *key))
186 meth->keygen = keygen;
189 void EC_KEY_METHOD_set_compute_key(EC_KEY_METHOD *meth,
190 int (*ckey)(void *out,
192 const EC_POINT *pub_key,
194 void *(*KDF) (const void *in,
199 meth->compute_key = ckey;
202 void EC_KEY_METHOD_set_sign(EC_KEY_METHOD *meth,
203 int (*sign)(int type, const unsigned char *dgst,
204 int dlen, unsigned char *sig,
205 unsigned int *siglen,
206 const BIGNUM *kinv, const BIGNUM *r,
208 int (*sign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
209 BIGNUM **kinvp, BIGNUM **rp),
210 ECDSA_SIG *(*sign_sig)(const unsigned char *dgst,
212 const BIGNUM *in_kinv,
217 meth->sign_setup = sign_setup;
218 meth->sign_sig = sign_sig;
221 void EC_KEY_METHOD_set_verify(EC_KEY_METHOD *meth,
222 int (*verify)(int type, const unsigned
223 char *dgst, int dgst_len,
224 const unsigned char *sigbuf,
225 int sig_len, EC_KEY *eckey),
226 int (*verify_sig)(const unsigned char *dgst,
228 const ECDSA_SIG *sig,
231 meth->verify = verify;
232 meth->verify_sig = verify_sig;
235 void EC_KEY_METHOD_get_init(EC_KEY_METHOD *meth,
236 int (**pinit)(EC_KEY *key),
237 void (**pfinish)(EC_KEY *key),
238 int (**pcopy)(EC_KEY *dest, const EC_KEY *src),
239 int (**pset_group)(EC_KEY *key,
240 const EC_GROUP *grp),
241 int (**pset_private)(EC_KEY *key,
242 const BIGNUM *priv_key),
243 int (**pset_public)(EC_KEY *key,
244 const EC_POINT *pub_key))
249 *pfinish = meth->finish;
252 if (pset_group != NULL)
253 *pset_group = meth->set_group;
254 if (pset_private != NULL)
255 *pset_private = meth->set_private;
256 if (pset_public != NULL)
257 *pset_public = meth->set_public;
260 void EC_KEY_METHOD_get_keygen(EC_KEY_METHOD *meth,
261 int (**pkeygen)(EC_KEY *key))
264 *pkeygen = meth->keygen;
267 void EC_KEY_METHOD_get_compute_key(EC_KEY_METHOD *meth,
268 int (**pck)(void *out,
270 const EC_POINT *pub_key,
272 void *(*KDF) (const void *in,
278 *pck = meth->compute_key;
281 void EC_KEY_METHOD_get_sign(EC_KEY_METHOD *meth,
282 int (**psign)(int type, const unsigned char *dgst,
283 int dlen, unsigned char *sig,
284 unsigned int *siglen,
285 const BIGNUM *kinv, const BIGNUM *r,
287 int (**psign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
288 BIGNUM **kinvp, BIGNUM **rp),
289 ECDSA_SIG *(**psign_sig)(const unsigned char *dgst,
291 const BIGNUM *in_kinv,
297 if (psign_setup != NULL)
298 *psign_setup = meth->sign_setup;
299 if (psign_sig != NULL)
300 *psign_sig = meth->sign_sig;
303 void EC_KEY_METHOD_get_verify(EC_KEY_METHOD *meth,
304 int (**pverify)(int type, const unsigned
305 char *dgst, int dgst_len,
306 const unsigned char *sigbuf,
307 int sig_len, EC_KEY *eckey),
308 int (**pverify_sig)(const unsigned char *dgst,
310 const ECDSA_SIG *sig,
314 *pverify = meth->verify;
315 if (pverify_sig != NULL)
316 *pverify_sig = meth->verify_sig;