evp.h revision 344604
1/* crypto/evp/evp.h */ 2/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 3 * All rights reserved. 4 * 5 * This package is an SSL implementation written 6 * by Eric Young (eay@cryptsoft.com). 7 * The implementation was written so as to conform with Netscapes SSL. 8 * 9 * This library is free for commercial and non-commercial use as long as 10 * the following conditions are aheared to. The following conditions 11 * apply to all code found in this distribution, be it the RC4, RSA, 12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation 13 * included with this distribution is covered by the same copyright terms 14 * except that the holder is Tim Hudson (tjh@cryptsoft.com). 15 * 16 * Copyright remains Eric Young's, and as such any Copyright notices in 17 * the code are not to be removed. 18 * If this package is used in a product, Eric Young should be given attribution 19 * as the author of the parts of the library used. 20 * This can be in the form of a textual message at program startup or 21 * in documentation (online or textual) provided with the package. 22 * 23 * Redistribution and use in source and binary forms, with or without 24 * modification, are permitted provided that the following conditions 25 * are met: 26 * 1. Redistributions of source code must retain the copyright 27 * notice, this list of conditions and the following disclaimer. 28 * 2. Redistributions in binary form must reproduce the above copyright 29 * notice, this list of conditions and the following disclaimer in the 30 * documentation and/or other materials provided with the distribution. 31 * 3. All advertising materials mentioning features or use of this software 32 * must display the following acknowledgement: 33 * "This product includes cryptographic software written by 34 * Eric Young (eay@cryptsoft.com)" 35 * The word 'cryptographic' can be left out if the rouines from the library 36 * being used are not cryptographic related :-). 37 * 4. If you include any Windows specific code (or a derivative thereof) from 38 * the apps directory (application code) you must include an acknowledgement: 39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 40 * 41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 51 * SUCH DAMAGE. 52 * 53 * The licence and distribution terms for any publically available version or 54 * derivative of this code cannot be changed. i.e. this code cannot simply be 55 * copied and put under another distribution licence 56 * [including the GNU Public Licence.] 57 */ 58 59#ifndef HEADER_ENVELOPE_H 60# define HEADER_ENVELOPE_H 61 62# ifdef OPENSSL_ALGORITHM_DEFINES 63# include <openssl/opensslconf.h> 64# else 65# define OPENSSL_ALGORITHM_DEFINES 66# include <openssl/opensslconf.h> 67# undef OPENSSL_ALGORITHM_DEFINES 68# endif 69 70# include <openssl/ossl_typ.h> 71 72# include <openssl/symhacks.h> 73 74# ifndef OPENSSL_NO_BIO 75# include <openssl/bio.h> 76# endif 77 78/*- 79#define EVP_RC2_KEY_SIZE 16 80#define EVP_RC4_KEY_SIZE 16 81#define EVP_BLOWFISH_KEY_SIZE 16 82#define EVP_CAST5_KEY_SIZE 16 83#define EVP_RC5_32_12_16_KEY_SIZE 16 84*/ 85# define EVP_MAX_MD_SIZE 64/* longest known is SHA512 */ 86# define EVP_MAX_KEY_LENGTH 64 87# define EVP_MAX_IV_LENGTH 16 88# define EVP_MAX_BLOCK_LENGTH 32 89 90# define PKCS5_SALT_LEN 8 91/* Default PKCS#5 iteration count */ 92# define PKCS5_DEFAULT_ITER 2048 93 94# include <openssl/objects.h> 95 96# define EVP_PK_RSA 0x0001 97# define EVP_PK_DSA 0x0002 98# define EVP_PK_DH 0x0004 99# define EVP_PK_EC 0x0008 100# define EVP_PKT_SIGN 0x0010 101# define EVP_PKT_ENC 0x0020 102# define EVP_PKT_EXCH 0x0040 103# define EVP_PKS_RSA 0x0100 104# define EVP_PKS_DSA 0x0200 105# define EVP_PKS_EC 0x0400 106 107# define EVP_PKEY_NONE NID_undef 108# define EVP_PKEY_RSA NID_rsaEncryption 109# define EVP_PKEY_RSA2 NID_rsa 110# define EVP_PKEY_DSA NID_dsa 111# define EVP_PKEY_DSA1 NID_dsa_2 112# define EVP_PKEY_DSA2 NID_dsaWithSHA 113# define EVP_PKEY_DSA3 NID_dsaWithSHA1 114# define EVP_PKEY_DSA4 NID_dsaWithSHA1_2 115# define EVP_PKEY_DH NID_dhKeyAgreement 116# define EVP_PKEY_DHX NID_dhpublicnumber 117# define EVP_PKEY_EC NID_X9_62_id_ecPublicKey 118# define EVP_PKEY_HMAC NID_hmac 119# define EVP_PKEY_CMAC NID_cmac 120 121#ifdef __cplusplus 122extern "C" { 123#endif 124 125/* 126 * Type needs to be a bit field Sub-type needs to be for variations on the 127 * method, as in, can it do arbitrary encryption.... 128 */ 129struct evp_pkey_st { 130 int type; 131 int save_type; 132 int references; 133 const EVP_PKEY_ASN1_METHOD *ameth; 134 ENGINE *engine; 135 union { 136 char *ptr; 137# ifndef OPENSSL_NO_RSA 138 struct rsa_st *rsa; /* RSA */ 139# endif 140# ifndef OPENSSL_NO_DSA 141 struct dsa_st *dsa; /* DSA */ 142# endif 143# ifndef OPENSSL_NO_DH 144 struct dh_st *dh; /* DH */ 145# endif 146# ifndef OPENSSL_NO_EC 147 struct ec_key_st *ec; /* ECC */ 148# endif 149 } pkey; 150 int save_parameters; 151 STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */ 152} /* EVP_PKEY */ ; 153 154# define EVP_PKEY_MO_SIGN 0x0001 155# define EVP_PKEY_MO_VERIFY 0x0002 156# define EVP_PKEY_MO_ENCRYPT 0x0004 157# define EVP_PKEY_MO_DECRYPT 0x0008 158 159# ifndef EVP_MD 160struct env_md_st { 161 int type; 162 int pkey_type; 163 int md_size; 164 unsigned long flags; 165 int (*init) (EVP_MD_CTX *ctx); 166 int (*update) (EVP_MD_CTX *ctx, const void *data, size_t count); 167 int (*final) (EVP_MD_CTX *ctx, unsigned char *md); 168 int (*copy) (EVP_MD_CTX *to, const EVP_MD_CTX *from); 169 int (*cleanup) (EVP_MD_CTX *ctx); 170 /* FIXME: prototype these some day */ 171 int (*sign) (int type, const unsigned char *m, unsigned int m_length, 172 unsigned char *sigret, unsigned int *siglen, void *key); 173 int (*verify) (int type, const unsigned char *m, unsigned int m_length, 174 const unsigned char *sigbuf, unsigned int siglen, 175 void *key); 176 int required_pkey_type[5]; /* EVP_PKEY_xxx */ 177 int block_size; 178 int ctx_size; /* how big does the ctx->md_data need to be */ 179 /* control function */ 180 int (*md_ctrl) (EVP_MD_CTX *ctx, int cmd, int p1, void *p2); 181} /* EVP_MD */ ; 182 183typedef int evp_sign_method(int type, const unsigned char *m, 184 unsigned int m_length, unsigned char *sigret, 185 unsigned int *siglen, void *key); 186typedef int evp_verify_method(int type, const unsigned char *m, 187 unsigned int m_length, 188 const unsigned char *sigbuf, 189 unsigned int siglen, void *key); 190 191/* digest can only handle a single block */ 192# define EVP_MD_FLAG_ONESHOT 0x0001 193 194/* 195 * digest is a "clone" digest used 196 * which is a copy of an existing 197 * one for a specific public key type. 198 * EVP_dss1() etc 199 */ 200# define EVP_MD_FLAG_PKEY_DIGEST 0x0002 201 202/* Digest uses EVP_PKEY_METHOD for signing instead of MD specific signing */ 203 204# define EVP_MD_FLAG_PKEY_METHOD_SIGNATURE 0x0004 205 206/* DigestAlgorithmIdentifier flags... */ 207 208# define EVP_MD_FLAG_DIGALGID_MASK 0x0018 209 210/* NULL or absent parameter accepted. Use NULL */ 211 212# define EVP_MD_FLAG_DIGALGID_NULL 0x0000 213 214/* NULL or absent parameter accepted. Use NULL for PKCS#1 otherwise absent */ 215 216# define EVP_MD_FLAG_DIGALGID_ABSENT 0x0008 217 218/* Custom handling via ctrl */ 219 220# define EVP_MD_FLAG_DIGALGID_CUSTOM 0x0018 221 222/* Note if suitable for use in FIPS mode */ 223# define EVP_MD_FLAG_FIPS 0x0400 224 225/* Digest ctrls */ 226 227# define EVP_MD_CTRL_DIGALGID 0x1 228# define EVP_MD_CTRL_MICALG 0x2 229 230/* Minimum Algorithm specific ctrl value */ 231 232# define EVP_MD_CTRL_ALG_CTRL 0x1000 233 234# define EVP_PKEY_NULL_method NULL,NULL,{0,0,0,0} 235 236# ifndef OPENSSL_NO_DSA 237# define EVP_PKEY_DSA_method (evp_sign_method *)DSA_sign, \ 238 (evp_verify_method *)DSA_verify, \ 239 {EVP_PKEY_DSA,EVP_PKEY_DSA2,EVP_PKEY_DSA3, \ 240 EVP_PKEY_DSA4,0} 241# else 242# define EVP_PKEY_DSA_method EVP_PKEY_NULL_method 243# endif 244 245# ifndef OPENSSL_NO_ECDSA 246# define EVP_PKEY_ECDSA_method (evp_sign_method *)ECDSA_sign, \ 247 (evp_verify_method *)ECDSA_verify, \ 248 {EVP_PKEY_EC,0,0,0} 249# else 250# define EVP_PKEY_ECDSA_method EVP_PKEY_NULL_method 251# endif 252 253# ifndef OPENSSL_NO_RSA 254# define EVP_PKEY_RSA_method (evp_sign_method *)RSA_sign, \ 255 (evp_verify_method *)RSA_verify, \ 256 {EVP_PKEY_RSA,EVP_PKEY_RSA2,0,0} 257# define EVP_PKEY_RSA_ASN1_OCTET_STRING_method \ 258 (evp_sign_method *)RSA_sign_ASN1_OCTET_STRING, \ 259 (evp_verify_method *)RSA_verify_ASN1_OCTET_STRING, \ 260 {EVP_PKEY_RSA,EVP_PKEY_RSA2,0,0} 261# else 262# define EVP_PKEY_RSA_method EVP_PKEY_NULL_method 263# define EVP_PKEY_RSA_ASN1_OCTET_STRING_method EVP_PKEY_NULL_method 264# endif 265 266# endif /* !EVP_MD */ 267 268struct env_md_ctx_st { 269 const EVP_MD *digest; 270 ENGINE *engine; /* functional reference if 'digest' is 271 * ENGINE-provided */ 272 unsigned long flags; 273 void *md_data; 274 /* Public key context for sign/verify */ 275 EVP_PKEY_CTX *pctx; 276 /* Update function: usually copied from EVP_MD */ 277 int (*update) (EVP_MD_CTX *ctx, const void *data, size_t count); 278} /* EVP_MD_CTX */ ; 279 280/* values for EVP_MD_CTX flags */ 281 282# define EVP_MD_CTX_FLAG_ONESHOT 0x0001/* digest update will be 283 * called once only */ 284# define EVP_MD_CTX_FLAG_CLEANED 0x0002/* context has already been 285 * cleaned */ 286# define EVP_MD_CTX_FLAG_REUSE 0x0004/* Don't free up ctx->md_data 287 * in EVP_MD_CTX_cleanup */ 288/* 289 * FIPS and pad options are ignored in 1.0.0, definitions are here so we 290 * don't accidentally reuse the values for other purposes. 291 */ 292 293# define EVP_MD_CTX_FLAG_NON_FIPS_ALLOW 0x0008/* Allow use of non FIPS 294 * digest in FIPS mode */ 295 296/* 297 * The following PAD options are also currently ignored in 1.0.0, digest 298 * parameters are handled through EVP_DigestSign*() and EVP_DigestVerify*() 299 * instead. 300 */ 301# define EVP_MD_CTX_FLAG_PAD_MASK 0xF0/* RSA mode to use */ 302# define EVP_MD_CTX_FLAG_PAD_PKCS1 0x00/* PKCS#1 v1.5 mode */ 303# define EVP_MD_CTX_FLAG_PAD_X931 0x10/* X9.31 mode */ 304# define EVP_MD_CTX_FLAG_PAD_PSS 0x20/* PSS mode */ 305 306# define EVP_MD_CTX_FLAG_NO_INIT 0x0100/* Don't initialize md_data */ 307 308struct evp_cipher_st { 309 int nid; 310 int block_size; 311 /* Default value for variable length ciphers */ 312 int key_len; 313 int iv_len; 314 /* Various flags */ 315 unsigned long flags; 316 /* init key */ 317 int (*init) (EVP_CIPHER_CTX *ctx, const unsigned char *key, 318 const unsigned char *iv, int enc); 319 /* encrypt/decrypt data */ 320 int (*do_cipher) (EVP_CIPHER_CTX *ctx, unsigned char *out, 321 const unsigned char *in, size_t inl); 322 /* cleanup ctx */ 323 int (*cleanup) (EVP_CIPHER_CTX *); 324 /* how big ctx->cipher_data needs to be */ 325 int ctx_size; 326 /* Populate a ASN1_TYPE with parameters */ 327 int (*set_asn1_parameters) (EVP_CIPHER_CTX *, ASN1_TYPE *); 328 /* Get parameters from a ASN1_TYPE */ 329 int (*get_asn1_parameters) (EVP_CIPHER_CTX *, ASN1_TYPE *); 330 /* Miscellaneous operations */ 331 int (*ctrl) (EVP_CIPHER_CTX *, int type, int arg, void *ptr); 332 /* Application data */ 333 void *app_data; 334} /* EVP_CIPHER */ ; 335 336/* Values for cipher flags */ 337 338/* Modes for ciphers */ 339 340# define EVP_CIPH_STREAM_CIPHER 0x0 341# define EVP_CIPH_ECB_MODE 0x1 342# define EVP_CIPH_CBC_MODE 0x2 343# define EVP_CIPH_CFB_MODE 0x3 344# define EVP_CIPH_OFB_MODE 0x4 345# define EVP_CIPH_CTR_MODE 0x5 346# define EVP_CIPH_GCM_MODE 0x6 347# define EVP_CIPH_CCM_MODE 0x7 348# define EVP_CIPH_XTS_MODE 0x10001 349# define EVP_CIPH_WRAP_MODE 0x10002 350# define EVP_CIPH_MODE 0xF0007 351/* Set if variable length cipher */ 352# define EVP_CIPH_VARIABLE_LENGTH 0x8 353/* Set if the iv handling should be done by the cipher itself */ 354# define EVP_CIPH_CUSTOM_IV 0x10 355/* Set if the cipher's init() function should be called if key is NULL */ 356# define EVP_CIPH_ALWAYS_CALL_INIT 0x20 357/* Call ctrl() to init cipher parameters */ 358# define EVP_CIPH_CTRL_INIT 0x40 359/* Don't use standard key length function */ 360# define EVP_CIPH_CUSTOM_KEY_LENGTH 0x80 361/* Don't use standard block padding */ 362# define EVP_CIPH_NO_PADDING 0x100 363/* cipher handles random key generation */ 364# define EVP_CIPH_RAND_KEY 0x200 365/* cipher has its own additional copying logic */ 366# define EVP_CIPH_CUSTOM_COPY 0x400 367/* Allow use default ASN1 get/set iv */ 368# define EVP_CIPH_FLAG_DEFAULT_ASN1 0x1000 369/* Buffer length in bits not bytes: CFB1 mode only */ 370# define EVP_CIPH_FLAG_LENGTH_BITS 0x2000 371/* Note if suitable for use in FIPS mode */ 372# define EVP_CIPH_FLAG_FIPS 0x4000 373/* Allow non FIPS cipher in FIPS mode */ 374# define EVP_CIPH_FLAG_NON_FIPS_ALLOW 0x8000 375/* 376 * Cipher handles any and all padding logic as well as finalisation. 377 */ 378# define EVP_CIPH_FLAG_CUSTOM_CIPHER 0x100000 379# define EVP_CIPH_FLAG_AEAD_CIPHER 0x200000 380# define EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0x400000 381 382/* 383 * Cipher context flag to indicate we can handle wrap mode: if allowed in 384 * older applications it could overflow buffers. 385 */ 386 387# define EVP_CIPHER_CTX_FLAG_WRAP_ALLOW 0x1 388 389/* ctrl() values */ 390 391# define EVP_CTRL_INIT 0x0 392# define EVP_CTRL_SET_KEY_LENGTH 0x1 393# define EVP_CTRL_GET_RC2_KEY_BITS 0x2 394# define EVP_CTRL_SET_RC2_KEY_BITS 0x3 395# define EVP_CTRL_GET_RC5_ROUNDS 0x4 396# define EVP_CTRL_SET_RC5_ROUNDS 0x5 397# define EVP_CTRL_RAND_KEY 0x6 398# define EVP_CTRL_PBE_PRF_NID 0x7 399# define EVP_CTRL_COPY 0x8 400# define EVP_CTRL_GCM_SET_IVLEN 0x9 401# define EVP_CTRL_GCM_GET_TAG 0x10 402# define EVP_CTRL_GCM_SET_TAG 0x11 403# define EVP_CTRL_GCM_SET_IV_FIXED 0x12 404# define EVP_CTRL_GCM_IV_GEN 0x13 405# define EVP_CTRL_CCM_SET_IVLEN EVP_CTRL_GCM_SET_IVLEN 406# define EVP_CTRL_CCM_GET_TAG EVP_CTRL_GCM_GET_TAG 407# define EVP_CTRL_CCM_SET_TAG EVP_CTRL_GCM_SET_TAG 408# define EVP_CTRL_CCM_SET_L 0x14 409# define EVP_CTRL_CCM_SET_MSGLEN 0x15 410/* 411 * AEAD cipher deduces payload length and returns number of bytes required to 412 * store MAC and eventual padding. Subsequent call to EVP_Cipher even 413 * appends/verifies MAC. 414 */ 415# define EVP_CTRL_AEAD_TLS1_AAD 0x16 416/* Used by composite AEAD ciphers, no-op in GCM, CCM... */ 417# define EVP_CTRL_AEAD_SET_MAC_KEY 0x17 418/* Set the GCM invocation field, decrypt only */ 419# define EVP_CTRL_GCM_SET_IV_INV 0x18 420 421# define EVP_CTRL_TLS1_1_MULTIBLOCK_AAD 0x19 422# define EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT 0x1a 423# define EVP_CTRL_TLS1_1_MULTIBLOCK_DECRYPT 0x1b 424# define EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE 0x1c 425 426/* RFC 5246 defines additional data to be 13 bytes in length */ 427# define EVP_AEAD_TLS1_AAD_LEN 13 428 429typedef struct { 430 unsigned char *out; 431 const unsigned char *inp; 432 size_t len; 433 unsigned int interleave; 434} EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM; 435 436/* GCM TLS constants */ 437/* Length of fixed part of IV derived from PRF */ 438# define EVP_GCM_TLS_FIXED_IV_LEN 4 439/* Length of explicit part of IV part of TLS records */ 440# define EVP_GCM_TLS_EXPLICIT_IV_LEN 8 441/* Length of tag for TLS */ 442# define EVP_GCM_TLS_TAG_LEN 16 443 444typedef struct evp_cipher_info_st { 445 const EVP_CIPHER *cipher; 446 unsigned char iv[EVP_MAX_IV_LENGTH]; 447} EVP_CIPHER_INFO; 448 449struct evp_cipher_ctx_st { 450 const EVP_CIPHER *cipher; 451 ENGINE *engine; /* functional reference if 'cipher' is 452 * ENGINE-provided */ 453 int encrypt; /* encrypt or decrypt */ 454 int buf_len; /* number we have left */ 455 unsigned char oiv[EVP_MAX_IV_LENGTH]; /* original iv */ 456 unsigned char iv[EVP_MAX_IV_LENGTH]; /* working iv */ 457 unsigned char buf[EVP_MAX_BLOCK_LENGTH]; /* saved partial block */ 458 int num; /* used by cfb/ofb/ctr mode */ 459 void *app_data; /* application stuff */ 460 int key_len; /* May change for variable length cipher */ 461 unsigned long flags; /* Various flags */ 462 void *cipher_data; /* per EVP data */ 463 int final_used; 464 int block_mask; 465 unsigned char final[EVP_MAX_BLOCK_LENGTH]; /* possible final block */ 466} /* EVP_CIPHER_CTX */ ; 467 468typedef struct evp_Encode_Ctx_st { 469 /* number saved in a partial encode/decode */ 470 int num; 471 /* 472 * The length is either the output line length (in input bytes) or the 473 * shortest input line length that is ok. Once decoding begins, the 474 * length is adjusted up each time a longer line is decoded 475 */ 476 int length; 477 /* data to encode */ 478 unsigned char enc_data[80]; 479 /* number read on current line */ 480 int line_num; 481 int expect_nl; 482} EVP_ENCODE_CTX; 483 484/* Password based encryption function */ 485typedef int (EVP_PBE_KEYGEN) (EVP_CIPHER_CTX *ctx, const char *pass, 486 int passlen, ASN1_TYPE *param, 487 const EVP_CIPHER *cipher, const EVP_MD *md, 488 int en_de); 489 490# ifndef OPENSSL_NO_RSA 491# define EVP_PKEY_assign_RSA(pkey,rsa) EVP_PKEY_assign((pkey),EVP_PKEY_RSA,\ 492 (char *)(rsa)) 493# endif 494 495# ifndef OPENSSL_NO_DSA 496# define EVP_PKEY_assign_DSA(pkey,dsa) EVP_PKEY_assign((pkey),EVP_PKEY_DSA,\ 497 (char *)(dsa)) 498# endif 499 500# ifndef OPENSSL_NO_DH 501# define EVP_PKEY_assign_DH(pkey,dh) EVP_PKEY_assign((pkey),EVP_PKEY_DH,\ 502 (char *)(dh)) 503# endif 504 505# ifndef OPENSSL_NO_EC 506# define EVP_PKEY_assign_EC_KEY(pkey,eckey) EVP_PKEY_assign((pkey),EVP_PKEY_EC,\ 507 (char *)(eckey)) 508# endif 509 510/* Add some extra combinations */ 511# define EVP_get_digestbynid(a) EVP_get_digestbyname(OBJ_nid2sn(a)) 512# define EVP_get_digestbyobj(a) EVP_get_digestbynid(OBJ_obj2nid(a)) 513# define EVP_get_cipherbynid(a) EVP_get_cipherbyname(OBJ_nid2sn(a)) 514# define EVP_get_cipherbyobj(a) EVP_get_cipherbynid(OBJ_obj2nid(a)) 515 516int EVP_MD_type(const EVP_MD *md); 517# define EVP_MD_nid(e) EVP_MD_type(e) 518# define EVP_MD_name(e) OBJ_nid2sn(EVP_MD_nid(e)) 519int EVP_MD_pkey_type(const EVP_MD *md); 520int EVP_MD_size(const EVP_MD *md); 521int EVP_MD_block_size(const EVP_MD *md); 522unsigned long EVP_MD_flags(const EVP_MD *md); 523 524const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx); 525# define EVP_MD_CTX_size(e) EVP_MD_size(EVP_MD_CTX_md(e)) 526# define EVP_MD_CTX_block_size(e) EVP_MD_block_size(EVP_MD_CTX_md(e)) 527# define EVP_MD_CTX_type(e) EVP_MD_type(EVP_MD_CTX_md(e)) 528 529int EVP_CIPHER_nid(const EVP_CIPHER *cipher); 530# define EVP_CIPHER_name(e) OBJ_nid2sn(EVP_CIPHER_nid(e)) 531int EVP_CIPHER_block_size(const EVP_CIPHER *cipher); 532int EVP_CIPHER_key_length(const EVP_CIPHER *cipher); 533int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher); 534unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher); 535# define EVP_CIPHER_mode(e) (EVP_CIPHER_flags(e) & EVP_CIPH_MODE) 536 537const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx); 538int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx); 539int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx); 540int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx); 541int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx); 542int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in); 543void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx); 544void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data); 545# define EVP_CIPHER_CTX_type(c) EVP_CIPHER_type(EVP_CIPHER_CTX_cipher(c)) 546unsigned long EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx); 547# define EVP_CIPHER_CTX_mode(e) (EVP_CIPHER_CTX_flags(e) & EVP_CIPH_MODE) 548 549# define EVP_ENCODE_LENGTH(l) (((l+2)/3*4)+(l/48+1)*2+80) 550# define EVP_DECODE_LENGTH(l) ((l+3)/4*3+80) 551 552# define EVP_SignInit_ex(a,b,c) EVP_DigestInit_ex(a,b,c) 553# define EVP_SignInit(a,b) EVP_DigestInit(a,b) 554# define EVP_SignUpdate(a,b,c) EVP_DigestUpdate(a,b,c) 555# define EVP_VerifyInit_ex(a,b,c) EVP_DigestInit_ex(a,b,c) 556# define EVP_VerifyInit(a,b) EVP_DigestInit(a,b) 557# define EVP_VerifyUpdate(a,b,c) EVP_DigestUpdate(a,b,c) 558# define EVP_OpenUpdate(a,b,c,d,e) EVP_DecryptUpdate(a,b,c,d,e) 559# define EVP_SealUpdate(a,b,c,d,e) EVP_EncryptUpdate(a,b,c,d,e) 560# define EVP_DigestSignUpdate(a,b,c) EVP_DigestUpdate(a,b,c) 561# define EVP_DigestVerifyUpdate(a,b,c) EVP_DigestUpdate(a,b,c) 562 563# ifdef CONST_STRICT 564void BIO_set_md(BIO *, const EVP_MD *md); 565# else 566# define BIO_set_md(b,md) BIO_ctrl(b,BIO_C_SET_MD,0,(char *)md) 567# endif 568# define BIO_get_md(b,mdp) BIO_ctrl(b,BIO_C_GET_MD,0,(char *)mdp) 569# define BIO_get_md_ctx(b,mdcp) BIO_ctrl(b,BIO_C_GET_MD_CTX,0,(char *)mdcp) 570# define BIO_set_md_ctx(b,mdcp) BIO_ctrl(b,BIO_C_SET_MD_CTX,0,(char *)mdcp) 571# define BIO_get_cipher_status(b) BIO_ctrl(b,BIO_C_GET_CIPHER_STATUS,0,NULL) 572# define BIO_get_cipher_ctx(b,c_pp) BIO_ctrl(b,BIO_C_GET_CIPHER_CTX,0,(char *)c_pp) 573 574int EVP_Cipher(EVP_CIPHER_CTX *c, 575 unsigned char *out, const unsigned char *in, unsigned int inl); 576 577# define EVP_add_cipher_alias(n,alias) \ 578 OBJ_NAME_add((alias),OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS,(n)) 579# define EVP_add_digest_alias(n,alias) \ 580 OBJ_NAME_add((alias),OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS,(n)) 581# define EVP_delete_cipher_alias(alias) \ 582 OBJ_NAME_remove(alias,OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS); 583# define EVP_delete_digest_alias(alias) \ 584 OBJ_NAME_remove(alias,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS); 585 586void EVP_MD_CTX_init(EVP_MD_CTX *ctx); 587int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx); 588EVP_MD_CTX *EVP_MD_CTX_create(void); 589void EVP_MD_CTX_destroy(EVP_MD_CTX *ctx); 590int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in); 591void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags); 592void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags); 593int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags); 594int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl); 595int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d, size_t cnt); 596int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s); 597int EVP_Digest(const void *data, size_t count, 598 unsigned char *md, unsigned int *size, const EVP_MD *type, 599 ENGINE *impl); 600 601int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in); 602int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type); 603int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s); 604 605int EVP_read_pw_string(char *buf, int length, const char *prompt, int verify); 606int EVP_read_pw_string_min(char *buf, int minlen, int maxlen, 607 const char *prompt, int verify); 608void EVP_set_pw_prompt(const char *prompt); 609char *EVP_get_pw_prompt(void); 610 611int EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md, 612 const unsigned char *salt, const unsigned char *data, 613 int datal, int count, unsigned char *key, 614 unsigned char *iv); 615 616void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags); 617void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags); 618int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags); 619 620int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 621 const unsigned char *key, const unsigned char *iv); 622int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 623 ENGINE *impl, const unsigned char *key, 624 const unsigned char *iv); 625int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 626 const unsigned char *in, int inl); 627int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); 628int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); 629 630int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 631 const unsigned char *key, const unsigned char *iv); 632int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 633 ENGINE *impl, const unsigned char *key, 634 const unsigned char *iv); 635int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 636 const unsigned char *in, int inl); 637int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl); 638int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl); 639 640int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 641 const unsigned char *key, const unsigned char *iv, 642 int enc); 643int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 644 ENGINE *impl, const unsigned char *key, 645 const unsigned char *iv, int enc); 646int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 647 const unsigned char *in, int inl); 648int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl); 649int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl); 650 651int EVP_SignFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s, 652 EVP_PKEY *pkey); 653 654int EVP_VerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sigbuf, 655 unsigned int siglen, EVP_PKEY *pkey); 656 657int EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, 658 const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey); 659int EVP_DigestSignFinal(EVP_MD_CTX *ctx, 660 unsigned char *sigret, size_t *siglen); 661 662int EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, 663 const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey); 664int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, 665 const unsigned char *sig, size_t siglen); 666 667int EVP_OpenInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, 668 const unsigned char *ek, int ekl, const unsigned char *iv, 669 EVP_PKEY *priv); 670int EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); 671 672int EVP_SealInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, 673 unsigned char **ek, int *ekl, unsigned char *iv, 674 EVP_PKEY **pubk, int npubk); 675int EVP_SealFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); 676 677void EVP_EncodeInit(EVP_ENCODE_CTX *ctx); 678void EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl, 679 const unsigned char *in, int inl); 680void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl); 681int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n); 682 683void EVP_DecodeInit(EVP_ENCODE_CTX *ctx); 684int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl, 685 const unsigned char *in, int inl); 686int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned 687 char *out, int *outl); 688int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n); 689 690void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *a); 691int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *a); 692EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void); 693void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *a); 694int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen); 695int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad); 696int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr); 697int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key); 698 699# ifndef OPENSSL_NO_BIO 700BIO_METHOD *BIO_f_md(void); 701BIO_METHOD *BIO_f_base64(void); 702BIO_METHOD *BIO_f_cipher(void); 703BIO_METHOD *BIO_f_reliable(void); 704void BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k, 705 const unsigned char *i, int enc); 706# endif 707 708const EVP_MD *EVP_md_null(void); 709# ifndef OPENSSL_NO_MD2 710const EVP_MD *EVP_md2(void); 711# endif 712# ifndef OPENSSL_NO_MD4 713const EVP_MD *EVP_md4(void); 714# endif 715# ifndef OPENSSL_NO_MD5 716const EVP_MD *EVP_md5(void); 717# endif 718# ifndef OPENSSL_NO_SHA 719const EVP_MD *EVP_sha(void); 720const EVP_MD *EVP_sha1(void); 721const EVP_MD *EVP_dss(void); 722const EVP_MD *EVP_dss1(void); 723const EVP_MD *EVP_ecdsa(void); 724# endif 725# ifndef OPENSSL_NO_SHA256 726const EVP_MD *EVP_sha224(void); 727const EVP_MD *EVP_sha256(void); 728# endif 729# ifndef OPENSSL_NO_SHA512 730const EVP_MD *EVP_sha384(void); 731const EVP_MD *EVP_sha512(void); 732# endif 733# ifndef OPENSSL_NO_MDC2 734const EVP_MD *EVP_mdc2(void); 735# endif 736# ifndef OPENSSL_NO_RIPEMD 737const EVP_MD *EVP_ripemd160(void); 738# endif 739# ifndef OPENSSL_NO_WHIRLPOOL 740const EVP_MD *EVP_whirlpool(void); 741# endif 742const EVP_CIPHER *EVP_enc_null(void); /* does nothing :-) */ 743# ifndef OPENSSL_NO_DES 744const EVP_CIPHER *EVP_des_ecb(void); 745const EVP_CIPHER *EVP_des_ede(void); 746const EVP_CIPHER *EVP_des_ede3(void); 747const EVP_CIPHER *EVP_des_ede_ecb(void); 748const EVP_CIPHER *EVP_des_ede3_ecb(void); 749const EVP_CIPHER *EVP_des_cfb64(void); 750# define EVP_des_cfb EVP_des_cfb64 751const EVP_CIPHER *EVP_des_cfb1(void); 752const EVP_CIPHER *EVP_des_cfb8(void); 753const EVP_CIPHER *EVP_des_ede_cfb64(void); 754# define EVP_des_ede_cfb EVP_des_ede_cfb64 755# if 0 756const EVP_CIPHER *EVP_des_ede_cfb1(void); 757const EVP_CIPHER *EVP_des_ede_cfb8(void); 758# endif 759const EVP_CIPHER *EVP_des_ede3_cfb64(void); 760# define EVP_des_ede3_cfb EVP_des_ede3_cfb64 761const EVP_CIPHER *EVP_des_ede3_cfb1(void); 762const EVP_CIPHER *EVP_des_ede3_cfb8(void); 763const EVP_CIPHER *EVP_des_ofb(void); 764const EVP_CIPHER *EVP_des_ede_ofb(void); 765const EVP_CIPHER *EVP_des_ede3_ofb(void); 766const EVP_CIPHER *EVP_des_cbc(void); 767const EVP_CIPHER *EVP_des_ede_cbc(void); 768const EVP_CIPHER *EVP_des_ede3_cbc(void); 769const EVP_CIPHER *EVP_desx_cbc(void); 770const EVP_CIPHER *EVP_des_ede3_wrap(void); 771/* 772 * This should now be supported through the dev_crypto ENGINE. But also, why 773 * are rc4 and md5 declarations made here inside a "NO_DES" precompiler 774 * branch? 775 */ 776# if 0 777# ifdef OPENSSL_OPENBSD_DEV_CRYPTO 778const EVP_CIPHER *EVP_dev_crypto_des_ede3_cbc(void); 779const EVP_CIPHER *EVP_dev_crypto_rc4(void); 780const EVP_MD *EVP_dev_crypto_md5(void); 781# endif 782# endif 783# endif 784# ifndef OPENSSL_NO_RC4 785const EVP_CIPHER *EVP_rc4(void); 786const EVP_CIPHER *EVP_rc4_40(void); 787# ifndef OPENSSL_NO_MD5 788const EVP_CIPHER *EVP_rc4_hmac_md5(void); 789# endif 790# endif 791# ifndef OPENSSL_NO_IDEA 792const EVP_CIPHER *EVP_idea_ecb(void); 793const EVP_CIPHER *EVP_idea_cfb64(void); 794# define EVP_idea_cfb EVP_idea_cfb64 795const EVP_CIPHER *EVP_idea_ofb(void); 796const EVP_CIPHER *EVP_idea_cbc(void); 797# endif 798# ifndef OPENSSL_NO_RC2 799const EVP_CIPHER *EVP_rc2_ecb(void); 800const EVP_CIPHER *EVP_rc2_cbc(void); 801const EVP_CIPHER *EVP_rc2_40_cbc(void); 802const EVP_CIPHER *EVP_rc2_64_cbc(void); 803const EVP_CIPHER *EVP_rc2_cfb64(void); 804# define EVP_rc2_cfb EVP_rc2_cfb64 805const EVP_CIPHER *EVP_rc2_ofb(void); 806# endif 807# ifndef OPENSSL_NO_BF 808const EVP_CIPHER *EVP_bf_ecb(void); 809const EVP_CIPHER *EVP_bf_cbc(void); 810const EVP_CIPHER *EVP_bf_cfb64(void); 811# define EVP_bf_cfb EVP_bf_cfb64 812const EVP_CIPHER *EVP_bf_ofb(void); 813# endif 814# ifndef OPENSSL_NO_CAST 815const EVP_CIPHER *EVP_cast5_ecb(void); 816const EVP_CIPHER *EVP_cast5_cbc(void); 817const EVP_CIPHER *EVP_cast5_cfb64(void); 818# define EVP_cast5_cfb EVP_cast5_cfb64 819const EVP_CIPHER *EVP_cast5_ofb(void); 820# endif 821# ifndef OPENSSL_NO_RC5 822const EVP_CIPHER *EVP_rc5_32_12_16_cbc(void); 823const EVP_CIPHER *EVP_rc5_32_12_16_ecb(void); 824const EVP_CIPHER *EVP_rc5_32_12_16_cfb64(void); 825# define EVP_rc5_32_12_16_cfb EVP_rc5_32_12_16_cfb64 826const EVP_CIPHER *EVP_rc5_32_12_16_ofb(void); 827# endif 828# ifndef OPENSSL_NO_AES 829const EVP_CIPHER *EVP_aes_128_ecb(void); 830const EVP_CIPHER *EVP_aes_128_cbc(void); 831const EVP_CIPHER *EVP_aes_128_cfb1(void); 832const EVP_CIPHER *EVP_aes_128_cfb8(void); 833const EVP_CIPHER *EVP_aes_128_cfb128(void); 834# define EVP_aes_128_cfb EVP_aes_128_cfb128 835const EVP_CIPHER *EVP_aes_128_ofb(void); 836const EVP_CIPHER *EVP_aes_128_ctr(void); 837const EVP_CIPHER *EVP_aes_128_ccm(void); 838const EVP_CIPHER *EVP_aes_128_gcm(void); 839const EVP_CIPHER *EVP_aes_128_xts(void); 840const EVP_CIPHER *EVP_aes_128_wrap(void); 841const EVP_CIPHER *EVP_aes_192_ecb(void); 842const EVP_CIPHER *EVP_aes_192_cbc(void); 843const EVP_CIPHER *EVP_aes_192_cfb1(void); 844const EVP_CIPHER *EVP_aes_192_cfb8(void); 845const EVP_CIPHER *EVP_aes_192_cfb128(void); 846# define EVP_aes_192_cfb EVP_aes_192_cfb128 847const EVP_CIPHER *EVP_aes_192_ofb(void); 848const EVP_CIPHER *EVP_aes_192_ctr(void); 849const EVP_CIPHER *EVP_aes_192_ccm(void); 850const EVP_CIPHER *EVP_aes_192_gcm(void); 851const EVP_CIPHER *EVP_aes_192_wrap(void); 852const EVP_CIPHER *EVP_aes_256_ecb(void); 853const EVP_CIPHER *EVP_aes_256_cbc(void); 854const EVP_CIPHER *EVP_aes_256_cfb1(void); 855const EVP_CIPHER *EVP_aes_256_cfb8(void); 856const EVP_CIPHER *EVP_aes_256_cfb128(void); 857# define EVP_aes_256_cfb EVP_aes_256_cfb128 858const EVP_CIPHER *EVP_aes_256_ofb(void); 859const EVP_CIPHER *EVP_aes_256_ctr(void); 860const EVP_CIPHER *EVP_aes_256_ccm(void); 861const EVP_CIPHER *EVP_aes_256_gcm(void); 862const EVP_CIPHER *EVP_aes_256_xts(void); 863const EVP_CIPHER *EVP_aes_256_wrap(void); 864# if !defined(OPENSSL_NO_SHA) && !defined(OPENSSL_NO_SHA1) 865const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha1(void); 866const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha1(void); 867# endif 868# ifndef OPENSSL_NO_SHA256 869const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha256(void); 870const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha256(void); 871# endif 872# endif 873# ifndef OPENSSL_NO_CAMELLIA 874const EVP_CIPHER *EVP_camellia_128_ecb(void); 875const EVP_CIPHER *EVP_camellia_128_cbc(void); 876const EVP_CIPHER *EVP_camellia_128_cfb1(void); 877const EVP_CIPHER *EVP_camellia_128_cfb8(void); 878const EVP_CIPHER *EVP_camellia_128_cfb128(void); 879# define EVP_camellia_128_cfb EVP_camellia_128_cfb128 880const EVP_CIPHER *EVP_camellia_128_ofb(void); 881const EVP_CIPHER *EVP_camellia_192_ecb(void); 882const EVP_CIPHER *EVP_camellia_192_cbc(void); 883const EVP_CIPHER *EVP_camellia_192_cfb1(void); 884const EVP_CIPHER *EVP_camellia_192_cfb8(void); 885const EVP_CIPHER *EVP_camellia_192_cfb128(void); 886# define EVP_camellia_192_cfb EVP_camellia_192_cfb128 887const EVP_CIPHER *EVP_camellia_192_ofb(void); 888const EVP_CIPHER *EVP_camellia_256_ecb(void); 889const EVP_CIPHER *EVP_camellia_256_cbc(void); 890const EVP_CIPHER *EVP_camellia_256_cfb1(void); 891const EVP_CIPHER *EVP_camellia_256_cfb8(void); 892const EVP_CIPHER *EVP_camellia_256_cfb128(void); 893# define EVP_camellia_256_cfb EVP_camellia_256_cfb128 894const EVP_CIPHER *EVP_camellia_256_ofb(void); 895# endif 896 897# ifndef OPENSSL_NO_SEED 898const EVP_CIPHER *EVP_seed_ecb(void); 899const EVP_CIPHER *EVP_seed_cbc(void); 900const EVP_CIPHER *EVP_seed_cfb128(void); 901# define EVP_seed_cfb EVP_seed_cfb128 902const EVP_CIPHER *EVP_seed_ofb(void); 903# endif 904 905void OPENSSL_add_all_algorithms_noconf(void); 906void OPENSSL_add_all_algorithms_conf(void); 907 908# ifdef OPENSSL_LOAD_CONF 909# define OpenSSL_add_all_algorithms() \ 910 OPENSSL_add_all_algorithms_conf() 911# else 912# define OpenSSL_add_all_algorithms() \ 913 OPENSSL_add_all_algorithms_noconf() 914# endif 915 916void OpenSSL_add_all_ciphers(void); 917void OpenSSL_add_all_digests(void); 918# define SSLeay_add_all_algorithms() OpenSSL_add_all_algorithms() 919# define SSLeay_add_all_ciphers() OpenSSL_add_all_ciphers() 920# define SSLeay_add_all_digests() OpenSSL_add_all_digests() 921 922int EVP_add_cipher(const EVP_CIPHER *cipher); 923int EVP_add_digest(const EVP_MD *digest); 924 925const EVP_CIPHER *EVP_get_cipherbyname(const char *name); 926const EVP_MD *EVP_get_digestbyname(const char *name); 927void EVP_cleanup(void); 928 929void EVP_CIPHER_do_all(void (*fn) (const EVP_CIPHER *ciph, 930 const char *from, const char *to, void *x), 931 void *arg); 932void EVP_CIPHER_do_all_sorted(void (*fn) 933 (const EVP_CIPHER *ciph, const char *from, 934 const char *to, void *x), void *arg); 935 936void EVP_MD_do_all(void (*fn) (const EVP_MD *ciph, 937 const char *from, const char *to, void *x), 938 void *arg); 939void EVP_MD_do_all_sorted(void (*fn) 940 (const EVP_MD *ciph, const char *from, 941 const char *to, void *x), void *arg); 942 943int EVP_PKEY_decrypt_old(unsigned char *dec_key, 944 const unsigned char *enc_key, int enc_key_len, 945 EVP_PKEY *private_key); 946int EVP_PKEY_encrypt_old(unsigned char *enc_key, 947 const unsigned char *key, int key_len, 948 EVP_PKEY *pub_key); 949int EVP_PKEY_type(int type); 950int EVP_PKEY_id(const EVP_PKEY *pkey); 951int EVP_PKEY_base_id(const EVP_PKEY *pkey); 952int EVP_PKEY_bits(EVP_PKEY *pkey); 953int EVP_PKEY_size(EVP_PKEY *pkey); 954int EVP_PKEY_set_type(EVP_PKEY *pkey, int type); 955int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len); 956int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key); 957void *EVP_PKEY_get0(EVP_PKEY *pkey); 958 959# ifndef OPENSSL_NO_RSA 960struct rsa_st; 961int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, struct rsa_st *key); 962struct rsa_st *EVP_PKEY_get1_RSA(EVP_PKEY *pkey); 963# endif 964# ifndef OPENSSL_NO_DSA 965struct dsa_st; 966int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, struct dsa_st *key); 967struct dsa_st *EVP_PKEY_get1_DSA(EVP_PKEY *pkey); 968# endif 969# ifndef OPENSSL_NO_DH 970struct dh_st; 971int EVP_PKEY_set1_DH(EVP_PKEY *pkey, struct dh_st *key); 972struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey); 973# endif 974# ifndef OPENSSL_NO_EC 975struct ec_key_st; 976int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, struct ec_key_st *key); 977struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey); 978# endif 979 980EVP_PKEY *EVP_PKEY_new(void); 981void EVP_PKEY_free(EVP_PKEY *pkey); 982 983EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp, 984 long length); 985int i2d_PublicKey(EVP_PKEY *a, unsigned char **pp); 986 987EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp, 988 long length); 989EVP_PKEY *d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp, 990 long length); 991int i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp); 992 993int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from); 994int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey); 995int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode); 996int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b); 997 998int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b); 999 1000int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey, 1001 int indent, ASN1_PCTX *pctx); 1002int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey, 1003 int indent, ASN1_PCTX *pctx); 1004int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey, 1005 int indent, ASN1_PCTX *pctx); 1006 1007int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid); 1008 1009int EVP_CIPHER_type(const EVP_CIPHER *ctx); 1010 1011/* calls methods */ 1012int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type); 1013int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type); 1014 1015/* These are used by EVP_CIPHER methods */ 1016int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type); 1017int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type); 1018 1019/* PKCS5 password based encryption */ 1020int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, 1021 ASN1_TYPE *param, const EVP_CIPHER *cipher, 1022 const EVP_MD *md, int en_de); 1023int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen, 1024 const unsigned char *salt, int saltlen, int iter, 1025 int keylen, unsigned char *out); 1026int PKCS5_PBKDF2_HMAC(const char *pass, int passlen, 1027 const unsigned char *salt, int saltlen, int iter, 1028 const EVP_MD *digest, int keylen, unsigned char *out); 1029int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, 1030 ASN1_TYPE *param, const EVP_CIPHER *cipher, 1031 const EVP_MD *md, int en_de); 1032 1033void PKCS5_PBE_add(void); 1034 1035int EVP_PBE_CipherInit(ASN1_OBJECT *pbe_obj, const char *pass, int passlen, 1036 ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de); 1037 1038/* PBE type */ 1039 1040/* Can appear as the outermost AlgorithmIdentifier */ 1041# define EVP_PBE_TYPE_OUTER 0x0 1042/* Is an PRF type OID */ 1043# define EVP_PBE_TYPE_PRF 0x1 1044 1045int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid, 1046 int md_nid, EVP_PBE_KEYGEN *keygen); 1047int EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md, 1048 EVP_PBE_KEYGEN *keygen); 1049int EVP_PBE_find(int type, int pbe_nid, int *pcnid, int *pmnid, 1050 EVP_PBE_KEYGEN **pkeygen); 1051void EVP_PBE_cleanup(void); 1052 1053# define ASN1_PKEY_ALIAS 0x1 1054# define ASN1_PKEY_DYNAMIC 0x2 1055# define ASN1_PKEY_SIGPARAM_NULL 0x4 1056 1057# define ASN1_PKEY_CTRL_PKCS7_SIGN 0x1 1058# define ASN1_PKEY_CTRL_PKCS7_ENCRYPT 0x2 1059# define ASN1_PKEY_CTRL_DEFAULT_MD_NID 0x3 1060# define ASN1_PKEY_CTRL_CMS_SIGN 0x5 1061# define ASN1_PKEY_CTRL_CMS_ENVELOPE 0x7 1062# define ASN1_PKEY_CTRL_CMS_RI_TYPE 0x8 1063 1064int EVP_PKEY_asn1_get_count(void); 1065const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx); 1066const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type); 1067const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe, 1068 const char *str, int len); 1069int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth); 1070int EVP_PKEY_asn1_add_alias(int to, int from); 1071int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *pkey_base_id, 1072 int *ppkey_flags, const char **pinfo, 1073 const char **ppem_str, 1074 const EVP_PKEY_ASN1_METHOD *ameth); 1075 1076const EVP_PKEY_ASN1_METHOD *EVP_PKEY_get0_asn1(EVP_PKEY *pkey); 1077EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_new(int id, int flags, 1078 const char *pem_str, 1079 const char *info); 1080void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst, 1081 const EVP_PKEY_ASN1_METHOD *src); 1082void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth); 1083void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth, 1084 int (*pub_decode) (EVP_PKEY *pk, 1085 X509_PUBKEY *pub), 1086 int (*pub_encode) (X509_PUBKEY *pub, 1087 const EVP_PKEY *pk), 1088 int (*pub_cmp) (const EVP_PKEY *a, 1089 const EVP_PKEY *b), 1090 int (*pub_print) (BIO *out, 1091 const EVP_PKEY *pkey, 1092 int indent, ASN1_PCTX *pctx), 1093 int (*pkey_size) (const EVP_PKEY *pk), 1094 int (*pkey_bits) (const EVP_PKEY *pk)); 1095void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth, 1096 int (*priv_decode) (EVP_PKEY *pk, 1097 PKCS8_PRIV_KEY_INFO 1098 *p8inf), 1099 int (*priv_encode) (PKCS8_PRIV_KEY_INFO *p8, 1100 const EVP_PKEY *pk), 1101 int (*priv_print) (BIO *out, 1102 const EVP_PKEY *pkey, 1103 int indent, 1104 ASN1_PCTX *pctx)); 1105void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth, 1106 int (*param_decode) (EVP_PKEY *pkey, 1107 const unsigned char **pder, 1108 int derlen), 1109 int (*param_encode) (const EVP_PKEY *pkey, 1110 unsigned char **pder), 1111 int (*param_missing) (const EVP_PKEY *pk), 1112 int (*param_copy) (EVP_PKEY *to, 1113 const EVP_PKEY *from), 1114 int (*param_cmp) (const EVP_PKEY *a, 1115 const EVP_PKEY *b), 1116 int (*param_print) (BIO *out, 1117 const EVP_PKEY *pkey, 1118 int indent, 1119 ASN1_PCTX *pctx)); 1120 1121void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth, 1122 void (*pkey_free) (EVP_PKEY *pkey)); 1123void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth, 1124 int (*pkey_ctrl) (EVP_PKEY *pkey, int op, 1125 long arg1, void *arg2)); 1126void EVP_PKEY_asn1_set_item(EVP_PKEY_ASN1_METHOD *ameth, 1127 int (*item_verify) (EVP_MD_CTX *ctx, 1128 const ASN1_ITEM *it, 1129 void *asn, 1130 X509_ALGOR *a, 1131 ASN1_BIT_STRING *sig, 1132 EVP_PKEY *pkey), 1133 int (*item_sign) (EVP_MD_CTX *ctx, 1134 const ASN1_ITEM *it, 1135 void *asn, 1136 X509_ALGOR *alg1, 1137 X509_ALGOR *alg2, 1138 ASN1_BIT_STRING *sig)); 1139 1140# define EVP_PKEY_OP_UNDEFINED 0 1141# define EVP_PKEY_OP_PARAMGEN (1<<1) 1142# define EVP_PKEY_OP_KEYGEN (1<<2) 1143# define EVP_PKEY_OP_SIGN (1<<3) 1144# define EVP_PKEY_OP_VERIFY (1<<4) 1145# define EVP_PKEY_OP_VERIFYRECOVER (1<<5) 1146# define EVP_PKEY_OP_SIGNCTX (1<<6) 1147# define EVP_PKEY_OP_VERIFYCTX (1<<7) 1148# define EVP_PKEY_OP_ENCRYPT (1<<8) 1149# define EVP_PKEY_OP_DECRYPT (1<<9) 1150# define EVP_PKEY_OP_DERIVE (1<<10) 1151 1152# define EVP_PKEY_OP_TYPE_SIG \ 1153 (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY | EVP_PKEY_OP_VERIFYRECOVER \ 1154 | EVP_PKEY_OP_SIGNCTX | EVP_PKEY_OP_VERIFYCTX) 1155 1156# define EVP_PKEY_OP_TYPE_CRYPT \ 1157 (EVP_PKEY_OP_ENCRYPT | EVP_PKEY_OP_DECRYPT) 1158 1159# define EVP_PKEY_OP_TYPE_NOGEN \ 1160 (EVP_PKEY_OP_SIG | EVP_PKEY_OP_CRYPT | EVP_PKEY_OP_DERIVE) 1161 1162# define EVP_PKEY_OP_TYPE_GEN \ 1163 (EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN) 1164 1165# define EVP_PKEY_CTX_set_signature_md(ctx, md) \ 1166 EVP_PKEY_CTX_ctrl(ctx, -1, EVP_PKEY_OP_TYPE_SIG, \ 1167 EVP_PKEY_CTRL_MD, 0, (void *)md) 1168 1169# define EVP_PKEY_CTX_get_signature_md(ctx, pmd) \ 1170 EVP_PKEY_CTX_ctrl(ctx, -1, EVP_PKEY_OP_TYPE_SIG, \ 1171 EVP_PKEY_CTRL_GET_MD, 0, (void *)pmd) 1172 1173# define EVP_PKEY_CTRL_MD 1 1174# define EVP_PKEY_CTRL_PEER_KEY 2 1175 1176# define EVP_PKEY_CTRL_PKCS7_ENCRYPT 3 1177# define EVP_PKEY_CTRL_PKCS7_DECRYPT 4 1178 1179# define EVP_PKEY_CTRL_PKCS7_SIGN 5 1180 1181# define EVP_PKEY_CTRL_SET_MAC_KEY 6 1182 1183# define EVP_PKEY_CTRL_DIGESTINIT 7 1184 1185/* Used by GOST key encryption in TLS */ 1186# define EVP_PKEY_CTRL_SET_IV 8 1187 1188# define EVP_PKEY_CTRL_CMS_ENCRYPT 9 1189# define EVP_PKEY_CTRL_CMS_DECRYPT 10 1190# define EVP_PKEY_CTRL_CMS_SIGN 11 1191 1192# define EVP_PKEY_CTRL_CIPHER 12 1193 1194# define EVP_PKEY_CTRL_GET_MD 13 1195 1196# define EVP_PKEY_ALG_CTRL 0x1000 1197 1198# define EVP_PKEY_FLAG_AUTOARGLEN 2 1199/* 1200 * Method handles all operations: don't assume any digest related defaults. 1201 */ 1202# define EVP_PKEY_FLAG_SIGCTX_CUSTOM 4 1203 1204const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type); 1205EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags); 1206void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags, 1207 const EVP_PKEY_METHOD *meth); 1208void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src); 1209void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth); 1210int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth); 1211 1212EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e); 1213EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e); 1214EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *ctx); 1215void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx); 1216 1217int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype, 1218 int cmd, int p1, void *p2); 1219int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, 1220 const char *value); 1221 1222int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx); 1223void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen); 1224 1225EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e, 1226 const unsigned char *key, int keylen); 1227 1228void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data); 1229void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx); 1230EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx); 1231 1232EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx); 1233 1234void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data); 1235void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx); 1236 1237int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx); 1238int EVP_PKEY_sign(EVP_PKEY_CTX *ctx, 1239 unsigned char *sig, size_t *siglen, 1240 const unsigned char *tbs, size_t tbslen); 1241int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx); 1242int EVP_PKEY_verify(EVP_PKEY_CTX *ctx, 1243 const unsigned char *sig, size_t siglen, 1244 const unsigned char *tbs, size_t tbslen); 1245int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx); 1246int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx, 1247 unsigned char *rout, size_t *routlen, 1248 const unsigned char *sig, size_t siglen); 1249int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx); 1250int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx, 1251 unsigned char *out, size_t *outlen, 1252 const unsigned char *in, size_t inlen); 1253int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx); 1254int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx, 1255 unsigned char *out, size_t *outlen, 1256 const unsigned char *in, size_t inlen); 1257 1258int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx); 1259int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer); 1260int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen); 1261 1262typedef int EVP_PKEY_gen_cb (EVP_PKEY_CTX *ctx); 1263 1264int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx); 1265int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey); 1266int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx); 1267int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey); 1268 1269void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb); 1270EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx); 1271 1272int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx); 1273 1274void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth, 1275 int (*init) (EVP_PKEY_CTX *ctx)); 1276 1277void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth, 1278 int (*copy) (EVP_PKEY_CTX *dst, 1279 EVP_PKEY_CTX *src)); 1280 1281void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth, 1282 void (*cleanup) (EVP_PKEY_CTX *ctx)); 1283 1284void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth, 1285 int (*paramgen_init) (EVP_PKEY_CTX *ctx), 1286 int (*paramgen) (EVP_PKEY_CTX *ctx, 1287 EVP_PKEY *pkey)); 1288 1289void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth, 1290 int (*keygen_init) (EVP_PKEY_CTX *ctx), 1291 int (*keygen) (EVP_PKEY_CTX *ctx, 1292 EVP_PKEY *pkey)); 1293 1294void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth, 1295 int (*sign_init) (EVP_PKEY_CTX *ctx), 1296 int (*sign) (EVP_PKEY_CTX *ctx, 1297 unsigned char *sig, size_t *siglen, 1298 const unsigned char *tbs, 1299 size_t tbslen)); 1300 1301void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth, 1302 int (*verify_init) (EVP_PKEY_CTX *ctx), 1303 int (*verify) (EVP_PKEY_CTX *ctx, 1304 const unsigned char *sig, 1305 size_t siglen, 1306 const unsigned char *tbs, 1307 size_t tbslen)); 1308 1309void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth, 1310 int (*verify_recover_init) (EVP_PKEY_CTX 1311 *ctx), 1312 int (*verify_recover) (EVP_PKEY_CTX 1313 *ctx, 1314 unsigned char 1315 *sig, 1316 size_t *siglen, 1317 const unsigned 1318 char *tbs, 1319 size_t tbslen)); 1320 1321void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth, 1322 int (*signctx_init) (EVP_PKEY_CTX *ctx, 1323 EVP_MD_CTX *mctx), 1324 int (*signctx) (EVP_PKEY_CTX *ctx, 1325 unsigned char *sig, 1326 size_t *siglen, 1327 EVP_MD_CTX *mctx)); 1328 1329void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth, 1330 int (*verifyctx_init) (EVP_PKEY_CTX *ctx, 1331 EVP_MD_CTX *mctx), 1332 int (*verifyctx) (EVP_PKEY_CTX *ctx, 1333 const unsigned char *sig, 1334 int siglen, 1335 EVP_MD_CTX *mctx)); 1336 1337void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth, 1338 int (*encrypt_init) (EVP_PKEY_CTX *ctx), 1339 int (*encryptfn) (EVP_PKEY_CTX *ctx, 1340 unsigned char *out, 1341 size_t *outlen, 1342 const unsigned char *in, 1343 size_t inlen)); 1344 1345void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth, 1346 int (*decrypt_init) (EVP_PKEY_CTX *ctx), 1347 int (*decrypt) (EVP_PKEY_CTX *ctx, 1348 unsigned char *out, 1349 size_t *outlen, 1350 const unsigned char *in, 1351 size_t inlen)); 1352 1353void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth, 1354 int (*derive_init) (EVP_PKEY_CTX *ctx), 1355 int (*derive) (EVP_PKEY_CTX *ctx, 1356 unsigned char *key, 1357 size_t *keylen)); 1358 1359void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth, 1360 int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1, 1361 void *p2), 1362 int (*ctrl_str) (EVP_PKEY_CTX *ctx, 1363 const char *type, 1364 const char *value)); 1365 1366void EVP_PKEY_meth_get_init(EVP_PKEY_METHOD *pmeth, 1367 int (**pinit) (EVP_PKEY_CTX *ctx)); 1368 1369void EVP_PKEY_meth_get_copy(EVP_PKEY_METHOD *pmeth, 1370 int (**pcopy) (EVP_PKEY_CTX *dst, 1371 EVP_PKEY_CTX *src)); 1372 1373void EVP_PKEY_meth_get_cleanup(EVP_PKEY_METHOD *pmeth, 1374 void (**pcleanup) (EVP_PKEY_CTX *ctx)); 1375 1376void EVP_PKEY_meth_get_paramgen(EVP_PKEY_METHOD *pmeth, 1377 int (**pparamgen_init) (EVP_PKEY_CTX *ctx), 1378 int (**pparamgen) (EVP_PKEY_CTX *ctx, 1379 EVP_PKEY *pkey)); 1380 1381void EVP_PKEY_meth_get_keygen(EVP_PKEY_METHOD *pmeth, 1382 int (**pkeygen_init) (EVP_PKEY_CTX *ctx), 1383 int (**pkeygen) (EVP_PKEY_CTX *ctx, 1384 EVP_PKEY *pkey)); 1385 1386void EVP_PKEY_meth_get_sign(EVP_PKEY_METHOD *pmeth, 1387 int (**psign_init) (EVP_PKEY_CTX *ctx), 1388 int (**psign) (EVP_PKEY_CTX *ctx, 1389 unsigned char *sig, size_t *siglen, 1390 const unsigned char *tbs, 1391 size_t tbslen)); 1392 1393void EVP_PKEY_meth_get_verify(EVP_PKEY_METHOD *pmeth, 1394 int (**pverify_init) (EVP_PKEY_CTX *ctx), 1395 int (**pverify) (EVP_PKEY_CTX *ctx, 1396 const unsigned char *sig, 1397 size_t siglen, 1398 const unsigned char *tbs, 1399 size_t tbslen)); 1400 1401void EVP_PKEY_meth_get_verify_recover(EVP_PKEY_METHOD *pmeth, 1402 int (**pverify_recover_init) (EVP_PKEY_CTX 1403 *ctx), 1404 int (**pverify_recover) (EVP_PKEY_CTX 1405 *ctx, 1406 unsigned char 1407 *sig, 1408 size_t *siglen, 1409 const unsigned 1410 char *tbs, 1411 size_t tbslen)); 1412 1413void EVP_PKEY_meth_get_signctx(EVP_PKEY_METHOD *pmeth, 1414 int (**psignctx_init) (EVP_PKEY_CTX *ctx, 1415 EVP_MD_CTX *mctx), 1416 int (**psignctx) (EVP_PKEY_CTX *ctx, 1417 unsigned char *sig, 1418 size_t *siglen, 1419 EVP_MD_CTX *mctx)); 1420 1421void EVP_PKEY_meth_get_verifyctx(EVP_PKEY_METHOD *pmeth, 1422 int (**pverifyctx_init) (EVP_PKEY_CTX *ctx, 1423 EVP_MD_CTX *mctx), 1424 int (**pverifyctx) (EVP_PKEY_CTX *ctx, 1425 const unsigned char *sig, 1426 int siglen, 1427 EVP_MD_CTX *mctx)); 1428 1429void EVP_PKEY_meth_get_encrypt(EVP_PKEY_METHOD *pmeth, 1430 int (**pencrypt_init) (EVP_PKEY_CTX *ctx), 1431 int (**pencryptfn) (EVP_PKEY_CTX *ctx, 1432 unsigned char *out, 1433 size_t *outlen, 1434 const unsigned char *in, 1435 size_t inlen)); 1436 1437void EVP_PKEY_meth_get_decrypt(EVP_PKEY_METHOD *pmeth, 1438 int (**pdecrypt_init) (EVP_PKEY_CTX *ctx), 1439 int (**pdecrypt) (EVP_PKEY_CTX *ctx, 1440 unsigned char *out, 1441 size_t *outlen, 1442 const unsigned char *in, 1443 size_t inlen)); 1444 1445void EVP_PKEY_meth_get_derive(EVP_PKEY_METHOD *pmeth, 1446 int (**pderive_init) (EVP_PKEY_CTX *ctx), 1447 int (**pderive) (EVP_PKEY_CTX *ctx, 1448 unsigned char *key, 1449 size_t *keylen)); 1450 1451void EVP_PKEY_meth_get_ctrl(EVP_PKEY_METHOD *pmeth, 1452 int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1, 1453 void *p2), 1454 int (**pctrl_str) (EVP_PKEY_CTX *ctx, 1455 const char *type, 1456 const char *value)); 1457 1458void EVP_add_alg_module(void); 1459 1460/* BEGIN ERROR CODES */ 1461/* 1462 * The following lines are auto generated by the script mkerr.pl. Any changes 1463 * made after this point may be overwritten when the script is next run. 1464 */ 1465 1466void ERR_load_EVP_strings(void); 1467 1468/* Error codes for the EVP functions. */ 1469 1470/* Function codes. */ 1471# define EVP_F_AESNI_INIT_KEY 165 1472# define EVP_F_AESNI_XTS_CIPHER 176 1473# define EVP_F_AES_INIT_KEY 133 1474# define EVP_F_AES_T4_INIT_KEY 178 1475# define EVP_F_AES_XTS 172 1476# define EVP_F_AES_XTS_CIPHER 175 1477# define EVP_F_ALG_MODULE_INIT 177 1478# define EVP_F_CAMELLIA_INIT_KEY 159 1479# define EVP_F_CMAC_INIT 173 1480# define EVP_F_CMLL_T4_INIT_KEY 179 1481# define EVP_F_D2I_PKEY 100 1482# define EVP_F_DO_SIGVER_INIT 161 1483# define EVP_F_DSAPKEY2PKCS8 134 1484# define EVP_F_DSA_PKEY2PKCS8 135 1485# define EVP_F_ECDSA_PKEY2PKCS8 129 1486# define EVP_F_ECKEY_PKEY2PKCS8 132 1487# define EVP_F_EVP_CIPHERINIT_EX 123 1488# define EVP_F_EVP_CIPHER_CTX_COPY 163 1489# define EVP_F_EVP_CIPHER_CTX_CTRL 124 1490# define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH 122 1491# define EVP_F_EVP_DECRYPTFINAL_EX 101 1492# define EVP_F_EVP_DECRYPTUPDATE 181 1493# define EVP_F_EVP_DIGESTINIT_EX 128 1494# define EVP_F_EVP_ENCRYPTFINAL_EX 127 1495# define EVP_F_EVP_ENCRYPTUPDATE 180 1496# define EVP_F_EVP_MD_CTX_COPY_EX 110 1497# define EVP_F_EVP_MD_SIZE 162 1498# define EVP_F_EVP_OPENINIT 102 1499# define EVP_F_EVP_PBE_ALG_ADD 115 1500# define EVP_F_EVP_PBE_ALG_ADD_TYPE 160 1501# define EVP_F_EVP_PBE_CIPHERINIT 116 1502# define EVP_F_EVP_PKCS82PKEY 111 1503# define EVP_F_EVP_PKCS82PKEY_BROKEN 136 1504# define EVP_F_EVP_PKEY2PKCS8_BROKEN 113 1505# define EVP_F_EVP_PKEY_COPY_PARAMETERS 103 1506# define EVP_F_EVP_PKEY_CTX_CTRL 137 1507# define EVP_F_EVP_PKEY_CTX_CTRL_STR 150 1508# define EVP_F_EVP_PKEY_CTX_DUP 156 1509# define EVP_F_EVP_PKEY_DECRYPT 104 1510# define EVP_F_EVP_PKEY_DECRYPT_INIT 138 1511# define EVP_F_EVP_PKEY_DECRYPT_OLD 151 1512# define EVP_F_EVP_PKEY_DERIVE 153 1513# define EVP_F_EVP_PKEY_DERIVE_INIT 154 1514# define EVP_F_EVP_PKEY_DERIVE_SET_PEER 155 1515# define EVP_F_EVP_PKEY_ENCRYPT 105 1516# define EVP_F_EVP_PKEY_ENCRYPT_INIT 139 1517# define EVP_F_EVP_PKEY_ENCRYPT_OLD 152 1518# define EVP_F_EVP_PKEY_GET1_DH 119 1519# define EVP_F_EVP_PKEY_GET1_DSA 120 1520# define EVP_F_EVP_PKEY_GET1_ECDSA 130 1521# define EVP_F_EVP_PKEY_GET1_EC_KEY 131 1522# define EVP_F_EVP_PKEY_GET1_RSA 121 1523# define EVP_F_EVP_PKEY_KEYGEN 146 1524# define EVP_F_EVP_PKEY_KEYGEN_INIT 147 1525# define EVP_F_EVP_PKEY_NEW 106 1526# define EVP_F_EVP_PKEY_PARAMGEN 148 1527# define EVP_F_EVP_PKEY_PARAMGEN_INIT 149 1528# define EVP_F_EVP_PKEY_SIGN 140 1529# define EVP_F_EVP_PKEY_SIGN_INIT 141 1530# define EVP_F_EVP_PKEY_VERIFY 142 1531# define EVP_F_EVP_PKEY_VERIFY_INIT 143 1532# define EVP_F_EVP_PKEY_VERIFY_RECOVER 144 1533# define EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT 145 1534# define EVP_F_EVP_RIJNDAEL 126 1535# define EVP_F_EVP_SIGNFINAL 107 1536# define EVP_F_EVP_VERIFYFINAL 108 1537# define EVP_F_FIPS_CIPHERINIT 166 1538# define EVP_F_FIPS_CIPHER_CTX_COPY 170 1539# define EVP_F_FIPS_CIPHER_CTX_CTRL 167 1540# define EVP_F_FIPS_CIPHER_CTX_SET_KEY_LENGTH 171 1541# define EVP_F_FIPS_DIGESTINIT 168 1542# define EVP_F_FIPS_MD_CTX_COPY 169 1543# define EVP_F_HMAC_INIT_EX 174 1544# define EVP_F_INT_CTX_NEW 157 1545# define EVP_F_PKCS5_PBE_KEYIVGEN 117 1546# define EVP_F_PKCS5_V2_PBE_KEYIVGEN 118 1547# define EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN 164 1548# define EVP_F_PKCS8_SET_BROKEN 112 1549# define EVP_F_PKEY_SET_TYPE 158 1550# define EVP_F_RC2_MAGIC_TO_METH 109 1551# define EVP_F_RC5_CTRL 125 1552 1553/* Reason codes. */ 1554# define EVP_R_AES_IV_SETUP_FAILED 162 1555# define EVP_R_AES_KEY_SETUP_FAILED 143 1556# define EVP_R_ASN1_LIB 140 1557# define EVP_R_BAD_BLOCK_LENGTH 136 1558# define EVP_R_BAD_DECRYPT 100 1559# define EVP_R_BAD_KEY_LENGTH 137 1560# define EVP_R_BN_DECODE_ERROR 112 1561# define EVP_R_BN_PUBKEY_ERROR 113 1562# define EVP_R_BUFFER_TOO_SMALL 155 1563# define EVP_R_CAMELLIA_KEY_SETUP_FAILED 157 1564# define EVP_R_CIPHER_PARAMETER_ERROR 122 1565# define EVP_R_COMMAND_NOT_SUPPORTED 147 1566# define EVP_R_CTRL_NOT_IMPLEMENTED 132 1567# define EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED 133 1568# define EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH 138 1569# define EVP_R_DECODE_ERROR 114 1570# define EVP_R_DIFFERENT_KEY_TYPES 101 1571# define EVP_R_DIFFERENT_PARAMETERS 153 1572# define EVP_R_DISABLED_FOR_FIPS 163 1573# define EVP_R_ENCODE_ERROR 115 1574# define EVP_R_ERROR_LOADING_SECTION 165 1575# define EVP_R_ERROR_SETTING_FIPS_MODE 166 1576# define EVP_R_EVP_PBE_CIPHERINIT_ERROR 119 1577# define EVP_R_EXPECTING_AN_RSA_KEY 127 1578# define EVP_R_EXPECTING_A_DH_KEY 128 1579# define EVP_R_EXPECTING_A_DSA_KEY 129 1580# define EVP_R_EXPECTING_A_ECDSA_KEY 141 1581# define EVP_R_EXPECTING_A_EC_KEY 142 1582# define EVP_R_FIPS_MODE_NOT_SUPPORTED 167 1583# define EVP_R_INITIALIZATION_ERROR 134 1584# define EVP_R_INPUT_NOT_INITIALIZED 111 1585# define EVP_R_INVALID_DIGEST 152 1586# define EVP_R_INVALID_FIPS_MODE 168 1587# define EVP_R_INVALID_KEY 171 1588# define EVP_R_INVALID_KEY_LENGTH 130 1589# define EVP_R_INVALID_OPERATION 148 1590# define EVP_R_IV_TOO_LARGE 102 1591# define EVP_R_KEYGEN_FAILURE 120 1592# define EVP_R_MESSAGE_DIGEST_IS_NULL 159 1593# define EVP_R_METHOD_NOT_SUPPORTED 144 1594# define EVP_R_MISSING_PARAMETERS 103 1595# define EVP_R_NO_CIPHER_SET 131 1596# define EVP_R_NO_DEFAULT_DIGEST 158 1597# define EVP_R_NO_DIGEST_SET 139 1598# define EVP_R_NO_DSA_PARAMETERS 116 1599# define EVP_R_NO_KEY_SET 154 1600# define EVP_R_NO_OPERATION_SET 149 1601# define EVP_R_NO_SIGN_FUNCTION_CONFIGURED 104 1602# define EVP_R_NO_VERIFY_FUNCTION_CONFIGURED 105 1603# define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 150 1604# define EVP_R_OPERATON_NOT_INITIALIZED 151 1605# define EVP_R_PKCS8_UNKNOWN_BROKEN_TYPE 117 1606# define EVP_R_PRIVATE_KEY_DECODE_ERROR 145 1607# define EVP_R_PRIVATE_KEY_ENCODE_ERROR 146 1608# define EVP_R_PUBLIC_KEY_NOT_RSA 106 1609# define EVP_R_TOO_LARGE 164 1610# define EVP_R_UNKNOWN_CIPHER 160 1611# define EVP_R_UNKNOWN_DIGEST 161 1612# define EVP_R_UNKNOWN_OPTION 169 1613# define EVP_R_UNKNOWN_PBE_ALGORITHM 121 1614# define EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS 135 1615# define EVP_R_UNSUPPORTED_ALGORITHM 156 1616# define EVP_R_UNSUPPORTED_CIPHER 107 1617# define EVP_R_UNSUPPORTED_KEYLENGTH 123 1618# define EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION 124 1619# define EVP_R_UNSUPPORTED_KEY_SIZE 108 1620# define EVP_R_UNSUPPORTED_PRF 125 1621# define EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM 118 1622# define EVP_R_UNSUPPORTED_SALT_TYPE 126 1623# define EVP_R_WRAP_MODE_NOT_ALLOWED 170 1624# define EVP_R_WRONG_FINAL_BLOCK_LENGTH 109 1625# define EVP_R_WRONG_PUBLIC_KEY_TYPE 110 1626 1627# ifdef __cplusplus 1628} 1629# endif 1630#endif 1631