pmeth_lib.c (256281) | pmeth_lib.c (280304) |
---|---|
1/* pmeth_lib.c */ | 1/* pmeth_lib.c */ |
2/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL 3 * project 2006. | 2/* 3 * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project 4 * 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 | 5 */ 6/* ==================================================================== 7 * Copyright (c) 2006 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 |
13 * notice, this list of conditions and the following disclaimer. | 14 * 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: --- 35 unchanged lines hidden (view full) --- 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#ifndef OPENSSL_NO_ENGINE | 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: --- 35 unchanged lines hidden (view full) --- 58 */ 59 60#include <stdio.h> 61#include <stdlib.h> 62#include "cryptlib.h" 63#include <openssl/objects.h> 64#include <openssl/evp.h> 65#ifndef OPENSSL_NO_ENGINE |
65#include | 66# include <openssl/engine.h> |
66#endif 67#include "asn1_locl.h" 68#include "evp_locl.h" 69 | 67#endif 68#include "asn1_locl.h" 69#include "evp_locl.h" 70 |
70typedef int sk_cmp_fn_type(const char * const *a, const char * const *b); | 71typedef int sk_cmp_fn_type(const char *const *a, const char *const *b); |
71 72DECLARE_STACK_OF(EVP_PKEY_METHOD) 73STACK_OF(EVP_PKEY_METHOD) *app_pkey_methods = NULL; 74 75extern const EVP_PKEY_METHOD rsa_pkey_meth, dh_pkey_meth, dsa_pkey_meth; 76extern const EVP_PKEY_METHOD ec_pkey_meth, hmac_pkey_meth, cmac_pkey_meth; 77 | 72 73DECLARE_STACK_OF(EVP_PKEY_METHOD) 74STACK_OF(EVP_PKEY_METHOD) *app_pkey_methods = NULL; 75 76extern const EVP_PKEY_METHOD rsa_pkey_meth, dh_pkey_meth, dsa_pkey_meth; 77extern const EVP_PKEY_METHOD ec_pkey_meth, hmac_pkey_meth, cmac_pkey_meth; 78 |
78static const EVP_PKEY_METHOD *standard_methods[] = 79 { | 79static const EVP_PKEY_METHOD *standard_methods[] = { |
80#ifndef OPENSSL_NO_RSA | 80#ifndef OPENSSL_NO_RSA |
81 &rsa_pkey_meth, | 81 &rsa_pkey_meth, |
82#endif 83#ifndef OPENSSL_NO_DH | 82#endif 83#ifndef OPENSSL_NO_DH |
84 &dh_pkey_meth, | 84 &dh_pkey_meth, |
85#endif 86#ifndef OPENSSL_NO_DSA | 85#endif 86#ifndef OPENSSL_NO_DSA |
87 &dsa_pkey_meth, | 87 &dsa_pkey_meth, |
88#endif 89#ifndef OPENSSL_NO_EC | 88#endif 89#ifndef OPENSSL_NO_EC |
90 &ec_pkey_meth, | 90 &ec_pkey_meth, |
91#endif | 91#endif |
92 &hmac_pkey_meth, 93 &cmac_pkey_meth 94 }; | 92 &hmac_pkey_meth, 93 &cmac_pkey_meth 94}; |
95 96DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *, | 95 96DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *, |
97 pmeth); | 97 pmeth); |
98 | 98 |
99static int pmeth_cmp(const EVP_PKEY_METHOD * const *a, 100 const EVP_PKEY_METHOD * const *b) 101 { 102 return ((*a)->pkey_id - (*b)->pkey_id); 103 } | 99static int pmeth_cmp(const EVP_PKEY_METHOD *const *a, 100 const EVP_PKEY_METHOD *const *b) 101{ 102 return ((*a)->pkey_id - (*b)->pkey_id); 103} |
104 105IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *, | 104 105IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *, |
106 pmeth); | 106 pmeth); |
107 108const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type) | 107 108const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type) |
109 { 110 EVP_PKEY_METHOD tmp; 111 const EVP_PKEY_METHOD *t = &tmp, **ret; 112 tmp.pkey_id = type; 113 if (app_pkey_methods) 114 { 115 int idx; 116 idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp); 117 if (idx >= 0) 118 return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx); 119 } 120 ret = OBJ_bsearch_pmeth(&t, standard_methods, 121 sizeof(standard_methods)/sizeof(EVP_PKEY_METHOD *)); 122 if (!ret || !*ret) 123 return NULL; 124 return *ret; 125 } | 109{ 110 EVP_PKEY_METHOD tmp; 111 const EVP_PKEY_METHOD *t = &tmp, **ret; 112 tmp.pkey_id = type; 113 if (app_pkey_methods) { 114 int idx; 115 idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp); 116 if (idx >= 0) 117 return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx); 118 } 119 ret = OBJ_bsearch_pmeth(&t, standard_methods, 120 sizeof(standard_methods) / 121 sizeof(EVP_PKEY_METHOD *)); 122 if (!ret || !*ret) 123 return NULL; 124 return *ret; 125} |
126 127static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id) | 126 127static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id) |
128 { 129 EVP_PKEY_CTX *ret; 130 const EVP_PKEY_METHOD *pmeth; 131 if (id == -1) 132 { 133 if (!pkey || !pkey->ameth) 134 return NULL; 135 id = pkey->ameth->pkey_id; 136 } | 128{ 129 EVP_PKEY_CTX *ret; 130 const EVP_PKEY_METHOD *pmeth; 131 if (id == -1) { 132 if (!pkey || !pkey->ameth) 133 return NULL; 134 id = pkey->ameth->pkey_id; 135 } |
137#ifndef OPENSSL_NO_ENGINE | 136#ifndef OPENSSL_NO_ENGINE |
138 if (pkey && pkey->engine) 139 e = pkey->engine; 140 /* Try to find an ENGINE which implements this method */ 141 if (e) 142 { 143 if (!ENGINE_init(e)) 144 { 145 EVPerr(EVP_F_INT_CTX_NEW,ERR_R_ENGINE_LIB); 146 return NULL; 147 } 148 } 149 else 150 e = ENGINE_get_pkey_meth_engine(id); | 137 if (pkey && pkey->engine) 138 e = pkey->engine; 139 /* Try to find an ENGINE which implements this method */ 140 if (e) { 141 if (!ENGINE_init(e)) { 142 EVPerr(EVP_F_INT_CTX_NEW, ERR_R_ENGINE_LIB); 143 return NULL; 144 } 145 } else 146 e = ENGINE_get_pkey_meth_engine(id); |
151 | 147 |
152 /* If an ENGINE handled this method look it up. Othewise 153 * use internal tables. 154 */ | 148 /* 149 * If an ENGINE handled this method look it up. Othewise use internal 150 * tables. 151 */ |
155 | 152 |
156 if (e) 157 pmeth = ENGINE_get_pkey_meth(e, id); 158 else | 153 if (e) 154 pmeth = ENGINE_get_pkey_meth(e, id); 155 else |
159#endif | 156#endif |
160 pmeth = EVP_PKEY_meth_find(id); | 157 pmeth = EVP_PKEY_meth_find(id); |
161 | 158 |
162 if (pmeth == NULL) 163 { 164 EVPerr(EVP_F_INT_CTX_NEW,EVP_R_UNSUPPORTED_ALGORITHM); 165 return NULL; 166 } | 159 if (pmeth == NULL) { 160 EVPerr(EVP_F_INT_CTX_NEW, EVP_R_UNSUPPORTED_ALGORITHM); 161 return NULL; 162 } |
167 | 163 |
168 ret = OPENSSL_malloc(sizeof(EVP_PKEY_CTX)); 169 if (!ret) 170 { | 164 ret = OPENSSL_malloc(sizeof(EVP_PKEY_CTX)); 165 if (!ret) { |
171#ifndef OPENSSL_NO_ENGINE | 166#ifndef OPENSSL_NO_ENGINE |
172 if (e) 173 ENGINE_finish(e); | 167 if (e) 168 ENGINE_finish(e); |
174#endif | 169#endif |
175 EVPerr(EVP_F_INT_CTX_NEW,ERR_R_MALLOC_FAILURE); 176 return NULL; 177 } 178 ret->engine = e; 179 ret->pmeth = pmeth; 180 ret->operation = EVP_PKEY_OP_UNDEFINED; 181 ret->pkey = pkey; 182 ret->peerkey = NULL; 183 ret->pkey_gencb = 0; 184 if (pkey) 185 CRYPTO_add(&pkey->references,1,CRYPTO_LOCK_EVP_PKEY); 186 ret->data = NULL; | 170 EVPerr(EVP_F_INT_CTX_NEW, ERR_R_MALLOC_FAILURE); 171 return NULL; 172 } 173 ret->engine = e; 174 ret->pmeth = pmeth; 175 ret->operation = EVP_PKEY_OP_UNDEFINED; 176 ret->pkey = pkey; 177 ret->peerkey = NULL; 178 ret->pkey_gencb = 0; 179 if (pkey) 180 CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY); 181 ret->data = NULL; |
187 | 182 |
188 if (pmeth->init) 189 { 190 if (pmeth->init(ret) <= 0) 191 { 192 EVP_PKEY_CTX_free(ret); 193 return NULL; 194 } 195 } | 183 if (pmeth->init) { 184 if (pmeth->init(ret) <= 0) { 185 EVP_PKEY_CTX_free(ret); 186 return NULL; 187 } 188 } |
196 | 189 |
197 return ret; 198 } | 190 return ret; 191} |
199 | 192 |
200EVP_PKEY_METHOD* EVP_PKEY_meth_new(int id, int flags) 201 { 202 EVP_PKEY_METHOD *pmeth; 203 pmeth = OPENSSL_malloc(sizeof(EVP_PKEY_METHOD)); 204 if (!pmeth) 205 return NULL; | 193EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags) 194{ 195 EVP_PKEY_METHOD *pmeth; 196 pmeth = OPENSSL_malloc(sizeof(EVP_PKEY_METHOD)); 197 if (!pmeth) 198 return NULL; |
206 | 199 |
207 memset(pmeth, 0, sizeof(EVP_PKEY_METHOD)); | 200 memset(pmeth, 0, sizeof(EVP_PKEY_METHOD)); |
208 | 201 |
209 pmeth->pkey_id = id; 210 pmeth->flags = flags | EVP_PKEY_FLAG_DYNAMIC; | 202 pmeth->pkey_id = id; 203 pmeth->flags = flags | EVP_PKEY_FLAG_DYNAMIC; |
211 | 204 |
212 pmeth->init = 0; 213 pmeth->copy = 0; 214 pmeth->cleanup = 0; 215 pmeth->paramgen_init = 0; 216 pmeth->paramgen = 0; 217 pmeth->keygen_init = 0; 218 pmeth->keygen = 0; 219 pmeth->sign_init = 0; 220 pmeth->sign = 0; 221 pmeth->verify_init = 0; 222 pmeth->verify = 0; 223 pmeth->verify_recover_init = 0; 224 pmeth->verify_recover = 0; 225 pmeth->signctx_init = 0; 226 pmeth->signctx = 0; 227 pmeth->verifyctx_init = 0; 228 pmeth->verifyctx = 0; 229 pmeth->encrypt_init = 0; 230 pmeth->encrypt = 0; 231 pmeth->decrypt_init = 0; 232 pmeth->decrypt = 0; 233 pmeth->derive_init = 0; 234 pmeth->derive = 0; 235 pmeth->ctrl = 0; 236 pmeth->ctrl_str = 0; | 205 pmeth->init = 0; 206 pmeth->copy = 0; 207 pmeth->cleanup = 0; 208 pmeth->paramgen_init = 0; 209 pmeth->paramgen = 0; 210 pmeth->keygen_init = 0; 211 pmeth->keygen = 0; 212 pmeth->sign_init = 0; 213 pmeth->sign = 0; 214 pmeth->verify_init = 0; 215 pmeth->verify = 0; 216 pmeth->verify_recover_init = 0; 217 pmeth->verify_recover = 0; 218 pmeth->signctx_init = 0; 219 pmeth->signctx = 0; 220 pmeth->verifyctx_init = 0; 221 pmeth->verifyctx = 0; 222 pmeth->encrypt_init = 0; 223 pmeth->encrypt = 0; 224 pmeth->decrypt_init = 0; 225 pmeth->decrypt = 0; 226 pmeth->derive_init = 0; 227 pmeth->derive = 0; 228 pmeth->ctrl = 0; 229 pmeth->ctrl_str = 0; |
237 | 230 |
238 return pmeth; 239 } | 231 return pmeth; 232} |
240 241void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags, | 233 234void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags, |
242 const EVP_PKEY_METHOD *meth) 243 { 244 if (ppkey_id) 245 *ppkey_id = meth->pkey_id; 246 if (pflags) 247 *pflags = meth->flags; 248 } | 235 const EVP_PKEY_METHOD *meth) 236{ 237 if (ppkey_id) 238 *ppkey_id = meth->pkey_id; 239 if (pflags) 240 *pflags = meth->flags; 241} |
249 250void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src) | 242 243void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src) |
251 { | 244{ |
252 | 245 |
253 dst->init = src->init; 254 dst->copy = src->copy; 255 dst->cleanup = src->cleanup; | 246 dst->init = src->init; 247 dst->copy = src->copy; 248 dst->cleanup = src->cleanup; |
256 | 249 |
257 dst->paramgen_init = src->paramgen_init; 258 dst->paramgen = src->paramgen; | 250 dst->paramgen_init = src->paramgen_init; 251 dst->paramgen = src->paramgen; |
259 | 252 |
260 dst->keygen_init = src->keygen_init; 261 dst->keygen = src->keygen; | 253 dst->keygen_init = src->keygen_init; 254 dst->keygen = src->keygen; |
262 | 255 |
263 dst->sign_init = src->sign_init; 264 dst->sign = src->sign; | 256 dst->sign_init = src->sign_init; 257 dst->sign = src->sign; |
265 | 258 |
266 dst->verify_init = src->verify_init; 267 dst->verify = src->verify; | 259 dst->verify_init = src->verify_init; 260 dst->verify = src->verify; |
268 | 261 |
269 dst->verify_recover_init = src->verify_recover_init; 270 dst->verify_recover = src->verify_recover; | 262 dst->verify_recover_init = src->verify_recover_init; 263 dst->verify_recover = src->verify_recover; |
271 | 264 |
272 dst->signctx_init = src->signctx_init; 273 dst->signctx = src->signctx; | 265 dst->signctx_init = src->signctx_init; 266 dst->signctx = src->signctx; |
274 | 267 |
275 dst->verifyctx_init = src->verifyctx_init; 276 dst->verifyctx = src->verifyctx; | 268 dst->verifyctx_init = src->verifyctx_init; 269 dst->verifyctx = src->verifyctx; |
277 | 270 |
278 dst->encrypt_init = src->encrypt_init; 279 dst->encrypt = src->encrypt; | 271 dst->encrypt_init = src->encrypt_init; 272 dst->encrypt = src->encrypt; |
280 | 273 |
281 dst->decrypt_init = src->decrypt_init; 282 dst->decrypt = src->decrypt; | 274 dst->decrypt_init = src->decrypt_init; 275 dst->decrypt = src->decrypt; |
283 | 276 |
284 dst->derive_init = src->derive_init; 285 dst->derive = src->derive; | 277 dst->derive_init = src->derive_init; 278 dst->derive = src->derive; |
286 | 279 |
287 dst->ctrl = src->ctrl; 288 dst->ctrl_str = src->ctrl_str; 289 } | 280 dst->ctrl = src->ctrl; 281 dst->ctrl_str = src->ctrl_str; 282} |
290 291void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth) | 283 284void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth) |
292 { 293 if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC)) 294 OPENSSL_free(pmeth); 295 } | 285{ 286 if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC)) 287 OPENSSL_free(pmeth); 288} |
296 297EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e) | 289 290EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e) |
298 { 299 return int_ctx_new(pkey, e, -1); 300 } | 291{ 292 return int_ctx_new(pkey, e, -1); 293} |
301 302EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e) | 294 295EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e) |
303 { 304 return int_ctx_new(NULL, e, id); 305 } | 296{ 297 return int_ctx_new(NULL, e, id); 298} |
306 307EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx) | 299 300EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx) |
308 { 309 EVP_PKEY_CTX *rctx; 310 if (!pctx->pmeth || !pctx->pmeth->copy) 311 return NULL; | 301{ 302 EVP_PKEY_CTX *rctx; 303 if (!pctx->pmeth || !pctx->pmeth->copy) 304 return NULL; |
312#ifndef OPENSSL_NO_ENGINE | 305#ifndef OPENSSL_NO_ENGINE |
313 /* Make sure it's safe to copy a pkey context using an ENGINE */ 314 if (pctx->engine && !ENGINE_init(pctx->engine)) 315 { 316 EVPerr(EVP_F_EVP_PKEY_CTX_DUP,ERR_R_ENGINE_LIB); 317 return 0; 318 } | 306 /* Make sure it's safe to copy a pkey context using an ENGINE */ 307 if (pctx->engine && !ENGINE_init(pctx->engine)) { 308 EVPerr(EVP_F_EVP_PKEY_CTX_DUP, ERR_R_ENGINE_LIB); 309 return 0; 310 } |
319#endif | 311#endif |
320 rctx = OPENSSL_malloc(sizeof(EVP_PKEY_CTX)); 321 if (!rctx) 322 return NULL; | 312 rctx = OPENSSL_malloc(sizeof(EVP_PKEY_CTX)); 313 if (!rctx) 314 return NULL; |
323 | 315 |
324 rctx->pmeth = pctx->pmeth; | 316 rctx->pmeth = pctx->pmeth; |
325#ifndef OPENSSL_NO_ENGINE | 317#ifndef OPENSSL_NO_ENGINE |
326 rctx->engine = pctx->engine; | 318 rctx->engine = pctx->engine; |
327#endif 328 | 319#endif 320 |
329 if (pctx->pkey) 330 CRYPTO_add(&pctx->pkey->references,1,CRYPTO_LOCK_EVP_PKEY); | 321 if (pctx->pkey) 322 CRYPTO_add(&pctx->pkey->references, 1, CRYPTO_LOCK_EVP_PKEY); |
331 | 323 |
332 rctx->pkey = pctx->pkey; | 324 rctx->pkey = pctx->pkey; |
333 | 325 |
334 if (pctx->peerkey) 335 CRYPTO_add(&pctx->peerkey->references,1,CRYPTO_LOCK_EVP_PKEY); | 326 if (pctx->peerkey) 327 CRYPTO_add(&pctx->peerkey->references, 1, CRYPTO_LOCK_EVP_PKEY); |
336 | 328 |
337 rctx->peerkey = pctx->peerkey; | 329 rctx->peerkey = pctx->peerkey; |
338 | 330 |
339 rctx->data = NULL; 340 rctx->app_data = NULL; 341 rctx->operation = pctx->operation; | 331 rctx->data = NULL; 332 rctx->app_data = NULL; 333 rctx->operation = pctx->operation; |
342 | 334 |
343 if (pctx->pmeth->copy(rctx, pctx) > 0) 344 return rctx; | 335 if (pctx->pmeth->copy(rctx, pctx) > 0) 336 return rctx; |
345 | 337 |
346 EVP_PKEY_CTX_free(rctx); 347 return NULL; | 338 EVP_PKEY_CTX_free(rctx); 339 return NULL; |
348 | 340 |
349 } | 341} |
350 351int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth) | 342 343int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth) |
352 { 353 if (app_pkey_methods == NULL) 354 { 355 app_pkey_methods = sk_EVP_PKEY_METHOD_new(pmeth_cmp); 356 if (!app_pkey_methods) 357 return 0; 358 } 359 if (!sk_EVP_PKEY_METHOD_push(app_pkey_methods, pmeth)) 360 return 0; 361 sk_EVP_PKEY_METHOD_sort(app_pkey_methods); 362 return 1; 363 } | 344{ 345 if (app_pkey_methods == NULL) { 346 app_pkey_methods = sk_EVP_PKEY_METHOD_new(pmeth_cmp); 347 if (!app_pkey_methods) 348 return 0; 349 } 350 if (!sk_EVP_PKEY_METHOD_push(app_pkey_methods, pmeth)) 351 return 0; 352 sk_EVP_PKEY_METHOD_sort(app_pkey_methods); 353 return 1; 354} |
364 365void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx) | 355 356void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx) |
366 { 367 if (ctx == NULL) 368 return; 369 if (ctx->pmeth && ctx->pmeth->cleanup) 370 ctx->pmeth->cleanup(ctx); 371 if (ctx->pkey) 372 EVP_PKEY_free(ctx->pkey); 373 if (ctx->peerkey) 374 EVP_PKEY_free(ctx->peerkey); | 357{ 358 if (ctx == NULL) 359 return; 360 if (ctx->pmeth && ctx->pmeth->cleanup) 361 ctx->pmeth->cleanup(ctx); 362 if (ctx->pkey) 363 EVP_PKEY_free(ctx->pkey); 364 if (ctx->peerkey) 365 EVP_PKEY_free(ctx->peerkey); |
375#ifndef OPENSSL_NO_ENGINE | 366#ifndef OPENSSL_NO_ENGINE |
376 if(ctx->engine) 377 /* The EVP_PKEY_CTX we used belongs to an ENGINE, release the 378 * functional reference we held for this reason. */ 379 ENGINE_finish(ctx->engine); | 367 if (ctx->engine) 368 /* 369 * The EVP_PKEY_CTX we used belongs to an ENGINE, release the 370 * functional reference we held for this reason. 371 */ 372 ENGINE_finish(ctx->engine); |
380#endif | 373#endif |
381 OPENSSL_free(ctx); 382 } | 374 OPENSSL_free(ctx); 375} |
383 384int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype, | 376 377int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype, |
385 int cmd, int p1, void *p2) 386 { 387 int ret; 388 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl) 389 { 390 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED); 391 return -2; 392 } 393 if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype)) 394 return -1; | 378 int cmd, int p1, void *p2) 379{ 380 int ret; 381 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl) { 382 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED); 383 return -2; 384 } 385 if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype)) 386 return -1; |
395 | 387 |
396 if (ctx->operation == EVP_PKEY_OP_UNDEFINED) 397 { 398 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET); 399 return -1; 400 } | 388 if (ctx->operation == EVP_PKEY_OP_UNDEFINED) { 389 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET); 390 return -1; 391 } |
401 | 392 |
402 if ((optype != -1) && !(ctx->operation & optype)) 403 { 404 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION); 405 return -1; 406 } | 393 if ((optype != -1) && !(ctx->operation & optype)) { 394 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION); 395 return -1; 396 } |
407 | 397 |
408 ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2); | 398 ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2); |
409 | 399 |
410 if (ret == -2) 411 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED); | 400 if (ret == -2) 401 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED); |
412 | 402 |
413 return ret; | 403 return ret; |
414 | 404 |
415 } | 405} |
416 417int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, | 406 407int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, |
418 const char *name, const char *value) 419 { 420 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str) 421 { 422 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, 423 EVP_R_COMMAND_NOT_SUPPORTED); 424 return -2; 425 } 426 if (!strcmp(name, "digest")) 427 { 428 const EVP_MD *md; 429 if (!value || !(md = EVP_get_digestbyname(value))) 430 { 431 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, 432 EVP_R_INVALID_DIGEST); 433 return 0; 434 } 435 return EVP_PKEY_CTX_set_signature_md(ctx, md); 436 } 437 return ctx->pmeth->ctrl_str(ctx, name, value); 438 } | 408 const char *name, const char *value) 409{ 410 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str) { 411 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, EVP_R_COMMAND_NOT_SUPPORTED); 412 return -2; 413 } 414 if (!strcmp(name, "digest")) { 415 const EVP_MD *md; 416 if (!value || !(md = EVP_get_digestbyname(value))) { 417 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, EVP_R_INVALID_DIGEST); 418 return 0; 419 } 420 return EVP_PKEY_CTX_set_signature_md(ctx, md); 421 } 422 return ctx->pmeth->ctrl_str(ctx, name, value); 423} |
439 440int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx) | 424 425int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx) |
441 { 442 return ctx->operation; 443 } | 426{ 427 return ctx->operation; 428} |
444 445void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen) | 429 430void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen) |
446 { 447 ctx->keygen_info = dat; 448 ctx->keygen_info_count = datlen; 449 } | 431{ 432 ctx->keygen_info = dat; 433 ctx->keygen_info_count = datlen; 434} |
450 451void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data) | 435 436void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data) |
452 { 453 ctx->data = data; 454 } | 437{ 438 ctx->data = data; 439} |
455 456void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx) | 440 441void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx) |
457 { 458 return ctx->data; 459 } | 442{ 443 return ctx->data; 444} |
460 461EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx) | 445 446EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx) |
462 { 463 return ctx->pkey; 464 } | 447{ 448 return ctx->pkey; 449} |
465 466EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx) | 450 451EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx) |
467 { 468 return ctx->peerkey; 469 } 470 | 452{ 453 return ctx->peerkey; 454} 455 |
471void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data) | 456void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data) |
472 { 473 ctx->app_data = data; 474 } | 457{ 458 ctx->app_data = data; 459} |
475 476void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx) | 460 461void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx) |
477 { 478 return ctx->app_data; 479 } | 462{ 463 return ctx->app_data; 464} |
480 481void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth, | 465 466void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth, |
482 int (*init)(EVP_PKEY_CTX *ctx)) 483 { 484 pmeth->init = init; 485 } | 467 int (*init) (EVP_PKEY_CTX *ctx)) 468{ 469 pmeth->init = init; 470} |
486 487void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth, | 471 472void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth, |
488 int (*copy)(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)) 489 { 490 pmeth->copy = copy; 491 } | 473 int (*copy) (EVP_PKEY_CTX *dst, 474 EVP_PKEY_CTX *src)) 475{ 476 pmeth->copy = copy; 477} |
492 493void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth, | 478 479void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth, |
494 void (*cleanup)(EVP_PKEY_CTX *ctx)) 495 { 496 pmeth->cleanup = cleanup; 497 } | 480 void (*cleanup) (EVP_PKEY_CTX *ctx)) 481{ 482 pmeth->cleanup = cleanup; 483} |
498 499void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth, | 484 485void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth, |
500 int (*paramgen_init)(EVP_PKEY_CTX *ctx), 501 int (*paramgen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)) 502 { 503 pmeth->paramgen_init = paramgen_init; 504 pmeth->paramgen = paramgen; 505 } | 486 int (*paramgen_init) (EVP_PKEY_CTX *ctx), 487 int (*paramgen) (EVP_PKEY_CTX *ctx, 488 EVP_PKEY *pkey)) 489{ 490 pmeth->paramgen_init = paramgen_init; 491 pmeth->paramgen = paramgen; 492} |
506 507void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth, | 493 494void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth, |
508 int (*keygen_init)(EVP_PKEY_CTX *ctx), 509 int (*keygen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)) 510 { 511 pmeth->keygen_init = keygen_init; 512 pmeth->keygen = keygen; 513 } | 495 int (*keygen_init) (EVP_PKEY_CTX *ctx), 496 int (*keygen) (EVP_PKEY_CTX *ctx, 497 EVP_PKEY *pkey)) 498{ 499 pmeth->keygen_init = keygen_init; 500 pmeth->keygen = keygen; 501} |
514 515void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth, | 502 503void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth, |
516 int (*sign_init)(EVP_PKEY_CTX *ctx), 517 int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen, 518 const unsigned char *tbs, size_t tbslen)) 519 { 520 pmeth->sign_init = sign_init; 521 pmeth->sign = sign; 522 } | 504 int (*sign_init) (EVP_PKEY_CTX *ctx), 505 int (*sign) (EVP_PKEY_CTX *ctx, 506 unsigned char *sig, size_t *siglen, 507 const unsigned char *tbs, 508 size_t tbslen)) 509{ 510 pmeth->sign_init = sign_init; 511 pmeth->sign = sign; 512} |
523 524void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth, | 513 514void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth, |
525 int (*verify_init)(EVP_PKEY_CTX *ctx), 526 int (*verify)(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen, 527 const unsigned char *tbs, size_t tbslen)) 528 { 529 pmeth->verify_init = verify_init; 530 pmeth->verify = verify; 531 } | 515 int (*verify_init) (EVP_PKEY_CTX *ctx), 516 int (*verify) (EVP_PKEY_CTX *ctx, 517 const unsigned char *sig, 518 size_t siglen, 519 const unsigned char *tbs, 520 size_t tbslen)) 521{ 522 pmeth->verify_init = verify_init; 523 pmeth->verify = verify; 524} |
532 533void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth, | 525 526void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth, |
534 int (*verify_recover_init)(EVP_PKEY_CTX *ctx), 535 int (*verify_recover)(EVP_PKEY_CTX *ctx, 536 unsigned char *sig, size_t *siglen, 537 const unsigned char *tbs, size_t tbslen)) 538 { 539 pmeth->verify_recover_init = verify_recover_init; 540 pmeth->verify_recover = verify_recover; 541 } | 527 int (*verify_recover_init) (EVP_PKEY_CTX 528 *ctx), 529 int (*verify_recover) (EVP_PKEY_CTX 530 *ctx, 531 unsigned char 532 *sig, 533 size_t *siglen, 534 const unsigned 535 char *tbs, 536 size_t tbslen)) 537{ 538 pmeth->verify_recover_init = verify_recover_init; 539 pmeth->verify_recover = verify_recover; 540} |
542 543void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth, | 541 542void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth, |
544 int (*signctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx), 545 int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen, 546 EVP_MD_CTX *mctx)) 547 { 548 pmeth->signctx_init = signctx_init; 549 pmeth->signctx = signctx; 550 } | 543 int (*signctx_init) (EVP_PKEY_CTX *ctx, 544 EVP_MD_CTX *mctx), 545 int (*signctx) (EVP_PKEY_CTX *ctx, 546 unsigned char *sig, 547 size_t *siglen, 548 EVP_MD_CTX *mctx)) 549{ 550 pmeth->signctx_init = signctx_init; 551 pmeth->signctx = signctx; 552} |
551 552void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth, | 553 554void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth, |
553 int (*verifyctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx), 554 int (*verifyctx)(EVP_PKEY_CTX *ctx, const unsigned char *sig,int siglen, 555 EVP_MD_CTX *mctx)) 556 { 557 pmeth->verifyctx_init = verifyctx_init; 558 pmeth->verifyctx = verifyctx; 559 } | 555 int (*verifyctx_init) (EVP_PKEY_CTX *ctx, 556 EVP_MD_CTX *mctx), 557 int (*verifyctx) (EVP_PKEY_CTX *ctx, 558 const unsigned char *sig, 559 int siglen, 560 EVP_MD_CTX *mctx)) 561{ 562 pmeth->verifyctx_init = verifyctx_init; 563 pmeth->verifyctx = verifyctx; 564} |
560 561void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth, | 565 566void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth, |
562 int (*encrypt_init)(EVP_PKEY_CTX *ctx), 563 int (*encryptfn)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, 564 const unsigned char *in, size_t inlen)) 565 { 566 pmeth->encrypt_init = encrypt_init; 567 pmeth->encrypt = encryptfn; 568 } | 567 int (*encrypt_init) (EVP_PKEY_CTX *ctx), 568 int (*encryptfn) (EVP_PKEY_CTX *ctx, 569 unsigned char *out, 570 size_t *outlen, 571 const unsigned char *in, 572 size_t inlen)) 573{ 574 pmeth->encrypt_init = encrypt_init; 575 pmeth->encrypt = encryptfn; 576} |
569 570void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth, | 577 578void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth, |
571 int (*decrypt_init)(EVP_PKEY_CTX *ctx), 572 int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, 573 const unsigned char *in, size_t inlen)) 574 { 575 pmeth->decrypt_init = decrypt_init; 576 pmeth->decrypt = decrypt; 577 } | 579 int (*decrypt_init) (EVP_PKEY_CTX *ctx), 580 int (*decrypt) (EVP_PKEY_CTX *ctx, 581 unsigned char *out, 582 size_t *outlen, 583 const unsigned char *in, 584 size_t inlen)) 585{ 586 pmeth->decrypt_init = decrypt_init; 587 pmeth->decrypt = decrypt; 588} |
578 579void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth, | 589 590void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth, |
580 int (*derive_init)(EVP_PKEY_CTX *ctx), 581 int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)) 582 { 583 pmeth->derive_init = derive_init; 584 pmeth->derive = derive; 585 } | 591 int (*derive_init) (EVP_PKEY_CTX *ctx), 592 int (*derive) (EVP_PKEY_CTX *ctx, 593 unsigned char *key, 594 size_t *keylen)) 595{ 596 pmeth->derive_init = derive_init; 597 pmeth->derive = derive; 598} |
586 587void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth, | 599 600void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth, |
588 int (*ctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2), 589 int (*ctrl_str)(EVP_PKEY_CTX *ctx, const char *type, const char *value)) 590 { 591 pmeth->ctrl = ctrl; 592 pmeth->ctrl_str = ctrl_str; 593 } | 601 int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1, 602 void *p2), 603 int (*ctrl_str) (EVP_PKEY_CTX *ctx, 604 const char *type, 605 const char *value)) 606{ 607 pmeth->ctrl = ctrl; 608 pmeth->ctrl_str = ctrl_str; 609} |