lesderid
/
ircbot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ircbot/deimos/openssl/evp.d

1409 lines
52 KiB
D
Raw Blame History

/* crypto/evp/evp.h */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
module deimos.openssl.evp;
import deimos.openssl._d_util;
import deimos.openssl.x509; // Needed for X509_ATTRIBUTE.
//#ifdef OPENSSL_ALGORITHM_DEFINES
public import deimos.openssl.opensslconf;
//#else
//# define OPENSSL_ALGORITHM_DEFINES
//public import deimos.openssl.opensslconf;
//# undef OPENSSL_ALGORITHM_DEFINES
//#endif
public import deimos.openssl.ossl_typ;
public import deimos.openssl.symhacks;
version(OPENSSL_NO_BIO) {} else {
public import deimos.openssl.bio;
}
/*
enum EVP_RC2_KEY_SIZE = 16;
enum EVP_RC4_KEY_SIZE = 16;
enum EVP_BLOWFISH_KEY_SIZE = 16;
enum EVP_CAST5_KEY_SIZE = 16;
enum EVP_RC5_32_12_16_KEY_SIZE = 16;
*/
enum EVP_MAX_MD_SIZE = 64; /* longest known is SHA512 */
enum EVP_MAX_KEY_LENGTH = 64;
enum EVP_MAX_IV_LENGTH = 16;
enum EVP_MAX_BLOCK_LENGTH = 32;
enum PKCS5_SALT_LEN = 8;
/* Default PKCS#5 iteration count */
enum PKCS5_DEFAULT_ITER = 2048;
public import deimos.openssl.objects;
enum EVP_PK_RSA = 0x0001;
enum EVP_PK_DSA = 0x0002;
enum EVP_PK_DH = 0x0004;
enum EVP_PK_EC = 0x0008;
enum EVP_PKT_SIGN = 0x0010;
enum EVP_PKT_ENC = 0x0020;
enum EVP_PKT_EXCH = 0x0040;
enum EVP_PKS_RSA = 0x0100;
enum EVP_PKS_DSA = 0x0200;
enum EVP_PKS_EC = 0x0400;
enum EVP_PKT_EXP = 0x1000; /* <= 512 bit key */
alias NID_undef EVP_PKEY_NONE;
alias NID_rsaEncryption EVP_PKEY_RSA;
alias NID_rsa EVP_PKEY_RSA2;
alias NID_dsa EVP_PKEY_DSA;
alias NID_dsa_2 EVP_PKEY_DSA1;
alias NID_dsaWithSHA EVP_PKEY_DSA2;
alias NID_dsaWithSHA1 EVP_PKEY_DSA3;
alias NID_dsaWithSHA1_2 EVP_PKEY_DSA4;
alias NID_dhKeyAgreement EVP_PKEY_DH;
alias NID_X9_62_id_ecPublicKey EVP_PKEY_EC;
alias NID_hmac EVP_PKEY_HMAC;
alias NID_cmac EVP_PKEY_CMAC;
extern (C):
nothrow:
/* Type needs to be a bit field
* Sub-type needs to be for variations on the method, as in_, can it do
* arbitrary encryption.... */
struct evp_pkey_st
{
int type;
int save_type;
int references;
const(EVP_PKEY_ASN1_METHOD)* ameth;
ENGINE* engine;
union pkey_ {
char* ptr;
version(OPENSSL_NO_RSA) {} else {
rsa_st* rsa; /* RSA */
}
version(OPENSSL_NO_DSA) {} else {
dsa_st* dsa; /* DSA */
}
version(OPENSSL_NO_DH) {} else {
dh_st* dh; /* DH */
}
version(OPENSSL_NO_EC) {} else {
ec_key_st* ec; /* ECC */
}
}
pkey_ pkey;
int save_parameters;
STACK_OF!(X509_ATTRIBUTE) *attributes; /* [ 0 ] */
} /* EVP_PKEY */;
enum EVP_PKEY_MO_SIGN = 0x0001;
enum EVP_PKEY_MO_VERIFY = 0x0002;
enum EVP_PKEY_MO_ENCRYPT = 0x0004;
enum EVP_PKEY_MO_DECRYPT = 0x0008;
// #ifndef EVP_MD
struct env_md_st
{
int type;
int pkey_type;
int md_size;
c_ulong flags;
ExternC!(int function(EVP_MD_CTX* ctx)) init_;
ExternC!(int function(EVP_MD_CTX* ctx,const(void)* data,size_t count)) update;
ExternC!(int function(EVP_MD_CTX* ctx,ubyte* md)) final_;
ExternC!(int function(EVP_MD_CTX* to,const(EVP_MD_CTX)* from)) copy;
ExternC!(int function(EVP_MD_CTX* ctx)) cleanup;
/* FIXME: prototype these some day */
ExternC!(int function(int type, const(ubyte)* m, uint m_length,
ubyte* sigret, uint* siglen, void* key)) sign;
ExternC!(int function(int type, const(ubyte)* m, uint m_length,
const(ubyte)* sigbuf, uint siglen,
void* key)) verify;
int[5] required_pkey_type; /*EVP_PKEY_xxx */
int block_size;
int ctx_size; /* how big does the ctx->md_data need to be */
/* control function */
ExternC!(int function(EVP_MD_CTX* ctx, int cmd, int p1, void* p2)) md_ctrl;
} /* EVP_MD */;
alias typeof(*(ExternC!(int function(int type,const(ubyte)* m,
uint m_length,ubyte* sigret,
uint* siglen, void* key))).init) evp_sign_method;
alias typeof(*(ExternC!(int function(int type,const(ubyte)* m,
uint m_length,const(ubyte)* sigbuf,
uint siglen, void* key))).init) evp_verify_method;
enum EVP_MD_FLAG_ONESHOT = 0x0001; /* digest can only handle a single
* block */
enum EVP_MD_FLAG_PKEY_DIGEST = 0x0002; /* digest is a "clone" digest used
* which is a copy of an existing
* one for a specific public key type.
* EVP_dss1() etc */
/* Digest uses EVP_PKEY_METHOD for signing instead of MD specific signing */
enum EVP_MD_FLAG_PKEY_METHOD_SIGNATURE = 0x0004;
/* DigestAlgorithmIdentifier flags... */
enum EVP_MD_FLAG_DIGALGID_MASK = 0x0018;
/* NULL or absent parameter accepted. Use NULL */
enum EVP_MD_FLAG_DIGALGID_NULL = 0x0000;
/* NULL or absent parameter accepted. Use NULL for PKCS#1 otherwise absent */
enum EVP_MD_FLAG_DIGALGID_ABSENT = 0x0008;
/* Custom handling via ctrl */
enum EVP_MD_FLAG_DIGALGID_CUSTOM = 0x0018;
enum EVP_MD_FLAG_FIPS = 0x0400; /* Note if suitable for use in FIPS mode */
/* Digest ctrls */
enum EVP_MD_CTRL_DIGALGID = 0x1;
enum EVP_MD_CTRL_MICALG = 0x2;
/* Minimum Algorithm specific ctrl value */
enum EVP_MD_CTRL_ALG_CTRL = 0x1000;
enum EVP_PKEY_NULL_method = "null,null,{0,0,0,0}";
version (OPENSSL_NO_DSA) {
alias EVP_PKEY_NULL_method EVP_PKEY_DSA_method;
} else {
enum EVP_PKEY_DSA_method = "cast(evp_sign_method*)&DSA_sign," ~
"cast(evp_verify_method*)&DSA_verify,{EVP_PKEY_DSA,EVP_PKEY_DSA2," ~
"EVP_PKEY_DSA3, EVP_PKEY_DSA4,0}";
}
version(OPENSSL_NO_ECDSA) {
alias EVP_PKEY_NULL_method EVP_PKEY_ECDSA_method;
} else {
enum EVP_PKEY_ECDSA_method = "cast(evp_sign_method*)&ECDSA_sign," ~
"cast(evp_verify_method*)&ECDSA_verify,{EVP_PKEY_EC,0,0,0}";
}
version (OPENSSL_NO_RSA) {
alias EVP_PKEY_NULL_method EVP_PKEY_RSA_method;
alias EVP_PKEY_NULL_method EVP_PKEY_RSA_ASN1_OCTET_STRING_method;
} else {
enum EVP_PKEY_RSA_method = "cast(evp_sign_method*)&RSA_sign," ~
"cast(evp_verify_method*)RSA_verify,{EVP_PKEY_RSA,EVP_PKEY_RSA2,0,0}";
enum EVP_PKEY_RSA_ASN1_OCTET_STRING_method =
"cast(evp_sign_method*)&RSA_sign_ASN1_OCTET_STRING," ~
"cast(evp_verify_method*)RSA_verify_ASN1_OCTET_STRING," ~
"{EVP_PKEY_RSA,EVP_PKEY_RSA2,0,0}";
}
// #endif /* !EVP_MD */
struct env_md_ctx_st
{
const(EVP_MD)* digest;
ENGINE* engine; /* functional reference if 'digest' is ENGINE-provided */
c_ulong flags;
void* md_data;
/* Public key context for sign/verify */
EVP_PKEY_CTX* pctx;
/* Update function: usually copied from EVP_MD */
ExternC!(int function(EVP_MD_CTX* ctx,const(void)* data,size_t count)) update;
} /* EVP_MD_CTX */;
/* values for EVP_MD_CTX flags */
enum EVP_MD_CTX_FLAG_ONESHOT = 0x0001; /* digest update will be called
* once only */
enum EVP_MD_CTX_FLAG_CLEANED = 0x0002; /* context has already been
* cleaned */
enum EVP_MD_CTX_FLAG_REUSE = 0x0004; /* Don't free up ctx->md_data
* in EVP_MD_CTX_cleanup */
/* FIPS and pad options are ignored in 1.0.0, definitions are here
* so we don't accidentally reuse the values for other purposes.
*/
enum EVP_MD_CTX_FLAG_NON_FIPS_ALLOW = 0x0008; /* Allow use of non FIPS digest
* in FIPS mode */
/* The following PAD options are also currently ignored in 1.0.0, digest
* parameters are handled through EVP_DigestSign*() and EVP_DigestVerify*()
* instead.
*/
enum EVP_MD_CTX_FLAG_PAD_MASK = 0xF0; /* RSA mode to use */
enum EVP_MD_CTX_FLAG_PAD_PKCS1 = 0x00; /* PKCS#1 v1.5 mode */
enum EVP_MD_CTX_FLAG_PAD_X931 = 0x10; /* X9.31 mode */
enum EVP_MD_CTX_FLAG_PAD_PSS = 0x20; /* PSS mode */
enum EVP_MD_CTX_FLAG_NO_INIT = 0x0100; /* Don't initialize md_data */
struct evp_cipher_st
{
int nid;
int block_size;
int key_len; /* Default value for variable length ciphers */
int iv_len;
c_ulong flags; /* Various flags */
ExternC!(int function(EVP_CIPHER_CTX* ctx, const(ubyte)* key,
const(ubyte)* iv, int enc)) init_; /* init key */
ExternC!(int function(EVP_CIPHER_CTX* ctx, ubyte* out_,
const(ubyte)* in_, size_t inl)) do_cipher;/* encrypt/decrypt data */
ExternC!(int function(EVP_CIPHER_CTX*)) cleanup; /* cleanup ctx */
int ctx_size; /* how big ctx->cipher_data needs to be */
ExternC!(int function(EVP_CIPHER_CTX*, ASN1_TYPE*)) set_asn1_parameters; /* Populate a ASN1_TYPE with parameters */
ExternC!(int function(EVP_CIPHER_CTX*, ASN1_TYPE*)) get_asn1_parameters; /* Get parameters from a ASN1_TYPE */
ExternC!(int function(EVP_CIPHER_CTX*, int type, int arg, void* ptr)) ctrl; /* Miscellaneous operations */
void* app_data; /* Application data */
} /* EVP_CIPHER */;
/* Values for cipher flags */
/* Modes for ciphers */
enum EVP_CIPH_STREAM_CIPHER = 0x0;
enum EVP_CIPH_ECB_MODE = 0x1;
enum EVP_CIPH_CBC_MODE = 0x2;
enum EVP_CIPH_CFB_MODE = 0x3;
enum EVP_CIPH_OFB_MODE = 0x4;
enum EVP_CIPH_CTR_MODE = 0x5;
enum EVP_CIPH_GCM_MODE = 0x6;
enum EVP_CIPH_CCM_MODE = 0x7;
enum EVP_CIPH_XTS_MODE = 0x10001;
enum EVP_CIPH_MODE = 0xF0007;
/* Set if variable length cipher */
enum EVP_CIPH_VARIABLE_LENGTH = 0x8;
/* Set if the iv handling should be done by the cipher itself */
enum EVP_CIPH_CUSTOM_IV = 0x10;
/* Set if the cipher's init() function should be called if key is NULL */
enum EVP_CIPH_ALWAYS_CALL_INIT = 0x20;
/* Call ctrl() to init cipher parameters */
enum EVP_CIPH_CTRL_INIT = 0x40;
/* Don't use standard key length function */
enum EVP_CIPH_CUSTOM_KEY_LENGTH = 0x80;
/* Don't use standard block padding */
enum EVP_CIPH_NO_PADDING = 0x100;
/* cipher handles random key generation */
enum EVP_CIPH_RAND_KEY = 0x200;
/* cipher has its own additional copying logic */
enum EVP_CIPH_CUSTOM_COPY = 0x400;
/* Allow use default ASN1 get/set iv */
enum EVP_CIPH_FLAG_DEFAULT_ASN1 = 0x1000;
/* Buffer length in bits not bytes: CFB1 mode only */
enum EVP_CIPH_FLAG_LENGTH_BITS = 0x2000;
/* Note if suitable for use in FIPS mode */
enum EVP_CIPH_FLAG_FIPS = 0x4000;
/* Allow non FIPS cipher in FIPS mode */
enum EVP_CIPH_FLAG_NON_FIPS_ALLOW = 0x8000;
/* Cipher handles any and all padding logic as well
* as finalisation.
*/
enum EVP_CIPH_FLAG_CUSTOM_CIPHER = 0x100000;
enum EVP_CIPH_FLAG_AEAD_CIPHER = 0x200000;
/* ctrl() values */
enum EVP_CTRL_INIT = 0x0;
enum EVP_CTRL_SET_KEY_LENGTH = 0x1;
enum EVP_CTRL_GET_RC2_KEY_BITS = 0x2;
enum EVP_CTRL_SET_RC2_KEY_BITS = 0x3;
enum EVP_CTRL_GET_RC5_ROUNDS = 0x4;
enum EVP_CTRL_SET_RC5_ROUNDS = 0x5;
enum EVP_CTRL_RAND_KEY = 0x6;
enum EVP_CTRL_PBE_PRF_NID = 0x7;
enum EVP_CTRL_COPY = 0x8;
enum EVP_CTRL_GCM_SET_IVLEN = 0x9;
enum EVP_CTRL_GCM_GET_TAG = 0x10;
enum EVP_CTRL_GCM_SET_TAG = 0x11;
enum EVP_CTRL_GCM_SET_IV_FIXED = 0x12;
enum EVP_CTRL_GCM_IV_GEN = 0x13;
alias EVP_CTRL_CCM_SET_IVLEN = EVP_CTRL_GCM_SET_IVLEN;
alias EVP_CTRL_CCM_GET_TAG = EVP_CTRL_GCM_GET_TAG;
alias EVP_CTRL_CCM_SET_TAG = EVP_CTRL_GCM_SET_TAG;
enum EVP_CTRL_CCM_SET_L = 0x14;
enum EVP_CTRL_CCM_SET_MSGLEN = 0x15;
/* AEAD cipher deduces payload length and returns number of bytes
* required to store MAC and eventual padding. Subsequent call to
* EVP_Cipher even appends/verifies MAC.
*/
enum EVP_CTRL_AEAD_TLS1_AAD = 0x16;
/* Used by composite AEAD ciphers, no-op in GCM, CCM... */
enum EVP_CTRL_AEAD_SET_MAC_KEY = 0x17;
/* Set the GCM invocation field, decrypt only */
enum EVP_CTRL_GCM_SET_IV_INV = 0x18;
/* GCM TLS constants */
/* Length of fixed part of IV derived from PRF */
enum EVP_GCM_TLS_FIXED_IV_LEN = 4;
/* Length of explicit part of IV part of TLS records */
enum EVP_GCM_TLS_EXPLICIT_IV_LEN = 8;
/* Length of tag for TLS */
enum EVP_GCM_TLS_TAG_LEN = 16;
struct evp_cipher_info_st {
const(EVP_CIPHER)* cipher;
ubyte[EVP_MAX_IV_LENGTH] iv;
}
alias evp_cipher_info_st EVP_CIPHER_INFO;
struct evp_cipher_ctx_st
{
const(EVP_CIPHER)* cipher;
ENGINE* engine; /* functional reference if 'cipher' is ENGINE-provided */
int encrypt; /* encrypt or decrypt */
int buf_len; /* number we have left */
ubyte[EVP_MAX_IV_LENGTH] oiv; /* original iv */
ubyte[EVP_MAX_IV_LENGTH] iv; /* working iv */
ubyte[EVP_MAX_BLOCK_LENGTH] buf;/* saved partial block */
int num; /* used by cfb/ofb mode */
void* app_data; /* application stuff */
int key_len; /* May change for variable length cipher */
c_ulong flags; /* Various flags */
void* cipher_data; /* per EVP data */
int final_used;
int block_mask;
ubyte[EVP_MAX_BLOCK_LENGTH] final_;/* possible final block */
} /* EVP_CIPHER_CTX */;
struct evp_Encode_Ctx_st {
int num; /* number saved in a partial encode/decode */
int length; /* The length is either the output line length
* (in input bytes) or the shortest input line
* length that is ok. Once decoding begins,
* the length is adjusted up each time a longer
* line is decoded */
ubyte[80] enc_data; /* data to encode */
int line_num; /* number read on current line */
int expect_nl;
}
alias evp_Encode_Ctx_st EVP_ENCODE_CTX;
/* Password based encryption function */
alias typeof(*(ExternC!(int function(EVP_CIPHER_CTX* ctx, const(char)* pass, int passlen,
ASN1_TYPE* param, const(EVP_CIPHER)* cipher,
const(EVP_MD)* md, int en_de))).init) EVP_PBE_KEYGEN;
version(OPENSSL_NO_RSA) {} else {
auto EVP_PKEY_assign_RSA()(EVP_PKEY* pkey, RSA* key) {
return EVP_PKEY_assign(pkey,EVP_PKEY_RSA,cast(void*)key);
}
}
version(OPENSSL_NO_DSA) {} else {
auto EVP_PKEY_assign_RSA()(EVP_PKEY* pkey, DSA* key) {
return EVP_PKEY_assign(pkey,EVP_PKEY_DSA,cast(void*)key);
}
}
version(OPENSSL_NO_DH) {} else {
auto EVP_PKEY_assign_DH()(EVP_PKEY* pkey, DH* key) {
return EVP_PKEY_assign(pkey,EVP_PKEY_DH,cast(void*)key);
}
}
version(OPENSSL_NO_EC) {} else {
auto EVP_PKEY_assign_EC_KEY()(EVP_PKEY* pkey, EC_KEY* key) {
return EVP_PKEY_assign(pkey,EVP_PKEY_EC,cast(void*)key);
}
}
/* Add some extra combinations */
auto EVP_get_digestbynid()(int a) { return EVP_get_digestbyname(OBJ_nid2sn(a)); }
auto EVP_get_digestbyobj()(const(ASN1_OBJECT)* a) { return EVP_get_digestbynid(OBJ_obj2nid(a)); }
auto EVP_get_cipherbynid()(int a) { return EVP_get_cipherbyname(OBJ_nid2sn(a)); }
auto EVP_get_cipherbyobj()(const(ASN1_OBJECT)* a) { return EVP_get_cipherbynid(OBJ_obj2nid(a)); }
int EVP_MD_type(const(EVP_MD)* md);
alias EVP_MD_type EVP_MD_nid;
auto EVP_MD_name()(const(EVP_MD)* e) { return OBJ_nid2sn(EVP_MD_nid(e)); }
int EVP_MD_pkey_type(const(EVP_MD)* md);
int EVP_MD_size(const(EVP_MD)* md);
int EVP_MD_block_size(const(EVP_MD)* md);
c_ulong EVP_MD_flags(const(EVP_MD)* md);
const(EVP_MD)* EVP_MD_CTX_md(const(EVP_MD_CTX)* ctx);
auto EVP_MD_CTX_size()(const(EVP_MD_CTX)* e) { return EVP_MD_size(EVP_MD_CTX_md(e)); }
auto EVP_MD_CTX_block_size()(const(EVP_MD_CTX)* e) { return EVP_MD_block_size(EVP_MD_CTX_md(e)); }
auto EVP_MD_CTX_type()(const(EVP_MD_CTX)* e) { return EVP_MD_type(EVP_MD_CTX_md(e)); }
int EVP_CIPHER_nid(const(EVP_CIPHER)* cipher);
auto EVP_CIPHER_name()(const(EVP_CIPHER)* e){ return OBJ_nid2sn(EVP_CIPHER_nid(e)); }
int EVP_CIPHER_block_size(const(EVP_CIPHER)* cipher);
int EVP_CIPHER_key_length(const(EVP_CIPHER)* cipher);
int EVP_CIPHER_iv_length(const(EVP_CIPHER)* cipher);
c_ulong EVP_CIPHER_flags(const(EVP_CIPHER)* cipher);
auto EVP_CIPHER_mode()(const(EVP_CIPHER)* e) { return (EVP_CIPHER_flags(e) & EVP_CIPH_MODE); }
const(EVP_CIPHER)* EVP_CIPHER_CTX_cipher(const(EVP_CIPHER_CTX)* ctx);
int EVP_CIPHER_CTX_nid(const(EVP_CIPHER_CTX)* ctx);
int EVP_CIPHER_CTX_block_size(const(EVP_CIPHER_CTX)* ctx);
int EVP_CIPHER_CTX_key_length(const(EVP_CIPHER_CTX)* ctx);
int EVP_CIPHER_CTX_iv_length(const(EVP_CIPHER_CTX)* ctx);
int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX* out_, const(EVP_CIPHER_CTX)* in_);
void* EVP_CIPHER_CTX_get_app_data(const(EVP_CIPHER_CTX)* ctx);
void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX* ctx, void* data);
auto EVP_CIPHER_CTX_type()(const(EVP_CIPHER_CTX)* c) { return EVP_CIPHER_type(EVP_CIPHER_CTX_cipher(c)); }
c_ulong EVP_CIPHER_CTX_flags(const(EVP_CIPHER_CTX)* ctx);
auto EVP_CIPHER_CTX_mode()(const(EVP_CIPHER_CTX)* e) { return (EVP_CIPHER_CTX_flags(e) & EVP_CIPH_MODE); }
auto EVP_ENCODE_LENGTH(T)(T l) { return (((l+2)/3*4)+(l/48+1)*2+80); }
auto EVP_DECODE_LENGTH(T)(T l) { return ((l+3)/4*3+80); }
alias EVP_DigestInit_ex EVP_SignInit_ex;
alias EVP_DigestInit EVP_SignInit;
alias EVP_DigestUpdate EVP_SignUpdate;
alias EVP_DigestInit_ex EVP_VerifyInit_ex;
alias EVP_DigestInit EVP_VerifyInit;
alias EVP_DigestUpdate EVP_VerifyUpdate;
alias EVP_DecryptUpdate EVP_OpenUpdate;
alias EVP_EncryptUpdate EVP_SealUpdate;
alias EVP_DigestUpdate EVP_DigestSignUpdate;
alias EVP_DigestUpdate EVP_DigestVerifyUpdate;
void BIO_set_md()(BIO* b,const(EVP_MD)* md) { return BIO_ctrl(b,BIO_C_SET_MD,0,md); }
auto BIO_get_md()(BIO* b,EVP_MD** mdp) { return BIO_ctrl(b,BIO_C_GET_MD,0,mdp); }
auto BIO_get_md_ctx()(BIO* b,EVP_MD_CTX** mdcp) { return BIO_ctrl(b,BIO_C_GET_MD_CTX,0,mdcp); }
auto BIO_set_md_ctx()(BIO* b,EVP_MD_CTX** mdcp) { return BIO_ctrl(b,BIO_C_SET_MD_CTX,0,mdcp); }
auto BIO_get_cipher_status()(BIO* b) { return BIO_ctrl(b,BIO_C_GET_CIPHER_STATUS,0,null); }
auto BIO_get_cipher_ctx()(BIO* b,EVP_CIPHER_CTX** c_pp) { return BIO_ctrl(b,BIO_C_GET_CIPHER_CTX,0,c_pp); }
int EVP_Cipher(EVP_CIPHER_CTX* c,
ubyte* out_,
const(ubyte)* in_,
uint inl);
auto EVP_add_cipher_alias()(const(char)* n,const(char)* alias_) {
return OBJ_NAME_add(alias_,OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS,(n));
}
auto EVP_add_digest_alias()(const(char)* n,const(char)* alias_) {
return OBJ_NAME_add(alias_,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS,(n));
}
auto EVP_delete_cipher_alias()(const(char)* alias_) {
return OBJ_NAME_remove(alias_,OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS);
}
auto EVP_delete_digest_alias()(const(char)* alias_) {
return OBJ_NAME_remove(alias_,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS);
}
void EVP_MD_CTX_init(EVP_MD_CTX* ctx);
int EVP_MD_CTX_cleanup(EVP_MD_CTX* ctx);
EVP_MD_CTX* EVP_MD_CTX_create();
void EVP_MD_CTX_destroy(EVP_MD_CTX* ctx);
int EVP_MD_CTX_copy_ex(EVP_MD_CTX* out_,const(EVP_MD_CTX)* in_);
void EVP_MD_CTX_set_flags(EVP_MD_CTX* ctx, int flags);
void EVP_MD_CTX_clear_flags(EVP_MD_CTX* ctx, int flags);
int EVP_MD_CTX_test_flags(const(EVP_MD_CTX)* ctx,int flags);
int EVP_DigestInit_ex(EVP_MD_CTX* ctx, const(EVP_MD)* type, ENGINE* impl);
int EVP_DigestUpdate(EVP_MD_CTX* ctx,const(void)* d,
size_t cnt);
int EVP_DigestFinal_ex(EVP_MD_CTX* ctx,ubyte* md,uint* s);
int EVP_Digest(const(void)* data, size_t count,
ubyte* md, uint* size, const(EVP_MD)* type, ENGINE* impl);
int EVP_MD_CTX_copy(EVP_MD_CTX* out_,const(EVP_MD_CTX)* in_);
int EVP_DigestInit(EVP_MD_CTX* ctx, const(EVP_MD)* type);
int EVP_DigestFinal(EVP_MD_CTX* ctx,ubyte* md,uint* s);
int EVP_read_pw_string(char* buf,int length,const(char)* prompt,int verify);
int EVP_read_pw_string_min(char* buf,int minlen,int maxlen,const(char)* prompt,int verify);
void EVP_set_pw_prompt(const(char)* prompt);
char* EVP_get_pw_prompt();
int EVP_BytesToKey(const(EVP_CIPHER)* type,const(EVP_MD)* md,
const(ubyte)* salt, const(ubyte)* data,
int datal, int count, ubyte* key,ubyte* iv);
void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX* ctx, int flags);
void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX* ctx, int flags);
int EVP_CIPHER_CTX_test_flags(const(EVP_CIPHER_CTX)* ctx,int flags);
int EVP_EncryptInit(EVP_CIPHER_CTX* ctx,const(EVP_CIPHER)* cipher,
const(ubyte)* key, const(ubyte)* iv);
int EVP_EncryptInit_ex(EVP_CIPHER_CTX* ctx,const(EVP_CIPHER)* cipher, ENGINE* impl,
const(ubyte)* key, const(ubyte)* iv);
int EVP_EncryptUpdate(EVP_CIPHER_CTX* ctx, ubyte* out_,
int* outl, const(ubyte)* in_, int inl);
int EVP_EncryptFinal_ex(EVP_CIPHER_CTX* ctx, ubyte* out_, int* outl);
int EVP_EncryptFinal(EVP_CIPHER_CTX* ctx, ubyte* out_, int* outl);
int EVP_DecryptInit(EVP_CIPHER_CTX* ctx,const(EVP_CIPHER)* cipher,
const(ubyte)* key, const(ubyte)* iv);
int EVP_DecryptInit_ex(EVP_CIPHER_CTX* ctx,const(EVP_CIPHER)* cipher, ENGINE* impl,
const(ubyte)* key, const(ubyte)* iv);
int EVP_DecryptUpdate(EVP_CIPHER_CTX* ctx, ubyte* out_,
int* outl, const(ubyte)* in_, int inl);
int EVP_DecryptFinal(EVP_CIPHER_CTX* ctx, ubyte* outm, int* outl);
int EVP_DecryptFinal_ex(EVP_CIPHER_CTX* ctx, ubyte* outm, int* outl);
int EVP_CipherInit(EVP_CIPHER_CTX* ctx,const(EVP_CIPHER)* cipher,
const(ubyte)* key,const(ubyte)* iv,
int enc);
int EVP_CipherInit_ex(EVP_CIPHER_CTX* ctx,const(EVP_CIPHER)* cipher, ENGINE* impl,
const(ubyte)* key,const(ubyte)* iv,
int enc);
int EVP_CipherUpdate(EVP_CIPHER_CTX* ctx, ubyte* out_,
int* outl, const(ubyte)* in_, int inl);
int EVP_CipherFinal(EVP_CIPHER_CTX* ctx, ubyte* outm, int* outl);
int EVP_CipherFinal_ex(EVP_CIPHER_CTX* ctx, ubyte* outm, int* outl);
int EVP_SignFinal(EVP_MD_CTX* ctx,ubyte* md,uint* s,
EVP_PKEY* pkey);
int EVP_VerifyFinal(EVP_MD_CTX* ctx,const(ubyte)* sigbuf,
uint siglen,EVP_PKEY* pkey);
int EVP_DigestSignInit(EVP_MD_CTX* ctx, EVP_PKEY_CTX** pctx,
const(EVP_MD)* type, ENGINE* e, EVP_PKEY* pkey);
int EVP_DigestSignFinal(EVP_MD_CTX* ctx,
ubyte* sigret, size_t* siglen);
int EVP_DigestVerifyInit(EVP_MD_CTX* ctx, EVP_PKEY_CTX** pctx,
const(EVP_MD)* type, ENGINE* e, EVP_PKEY* pkey);
int EVP_DigestVerifyFinal(EVP_MD_CTX* ctx,
ubyte* sig, size_t siglen);
int EVP_OpenInit(EVP_CIPHER_CTX* ctx,const(EVP_CIPHER)* type,
const(ubyte)* ek, int ekl, const(ubyte)* iv,
EVP_PKEY* priv);
int EVP_OpenFinal(EVP_CIPHER_CTX* ctx, ubyte* out_, int* outl);
int EVP_SealInit(EVP_CIPHER_CTX* ctx, const(EVP_CIPHER)* type,
ubyte** ek, int* ekl, ubyte* iv,
EVP_PKEY** pubk, int npubk);
int EVP_SealFinal(EVP_CIPHER_CTX* ctx,ubyte* out_,int* outl);
void EVP_EncodeInit(EVP_ENCODE_CTX* ctx);
void EVP_EncodeUpdate(EVP_ENCODE_CTX* ctx,ubyte* out_,int* outl,
const(ubyte)* in_,int inl);
void EVP_EncodeFinal(EVP_ENCODE_CTX* ctx,ubyte* out_,int* outl);
int EVP_EncodeBlock(ubyte* t, const(ubyte)* f, int n);
void EVP_DecodeInit(EVP_ENCODE_CTX* ctx);
int EVP_DecodeUpdate(EVP_ENCODE_CTX* ctx,ubyte* out_,int* outl,
const(ubyte)* in_, int inl);
int EVP_DecodeFinal(EVP_ENCODE_CTX* ctx, ubyte* out_, int* outl);
int EVP_DecodeBlock(ubyte* t, const(ubyte)* f, int n);
void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX* a);
int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX* a);
EVP_CIPHER_CTX* EVP_CIPHER_CTX_new();
void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX* a);
int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX* x, int keylen);
int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX* c, int pad);
int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX* ctx, int type, int arg, void* ptr);
int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX* ctx, ubyte* key);
version(OPENSSL_NO_BIO) {} else {
BIO_METHOD* BIO_f_md();
BIO_METHOD* BIO_f_base64();
BIO_METHOD* BIO_f_cipher();
BIO_METHOD* BIO_f_reliable();
void BIO_set_cipher(BIO* b,const(EVP_CIPHER)* c,const(ubyte)* k,
const(ubyte)* i, int enc);
}
const(EVP_MD)* EVP_md_null();
version(OPENSSL_NO_MD2) {} else {
const(EVP_MD)* EVP_md2();
}
version(OPENSSL_NO_MD4) {} else {
const(EVP_MD)* EVP_md4();
}
version(OPENSSL_NO_MD5) {} else {
const(EVP_MD)* EVP_md5();
}
version(OPENSSL_NO_SHA) {} else {
const(EVP_MD)* EVP_sha();
const(EVP_MD)* EVP_sha1();
const(EVP_MD)* EVP_dss();
const(EVP_MD)* EVP_dss1();
const(EVP_MD)* EVP_ecdsa();
}
version(OPENSSL_NO_SHA256) {} else {
const(EVP_MD)* EVP_sha224();
const(EVP_MD)* EVP_sha256();
}
version(OPENSSL_NO_SHA512) {} else {
const(EVP_MD)* EVP_sha384();
const(EVP_MD)* EVP_sha512();
}
version(OPENSSL_NO_MDC2) {} else {
const(EVP_MD)* EVP_mdc2();
}
version(OPENSSL_NO_RIPEMD) {} else {
const(EVP_MD)* EVP_ripemd160();
}
version(OPENSSL_NO_WHIRLPOOL) {} else {
const(EVP_MD)* EVP_whirlpool();
}
const(EVP_CIPHER)* EVP_enc_null(); /* does nothing :-) */
version (OPENSSL_NO_DES) {} else {
const(EVP_CIPHER)* EVP_des_ecb();
const(EVP_CIPHER)* EVP_des_ede();
const(EVP_CIPHER)* EVP_des_ede3();
const(EVP_CIPHER)* EVP_des_ede_ecb();
const(EVP_CIPHER)* EVP_des_ede3_ecb();
const(EVP_CIPHER)* EVP_des_cfb64();
alias EVP_des_cfb64 EVP_des_cfb;
const(EVP_CIPHER)* EVP_des_cfb1();
const(EVP_CIPHER)* EVP_des_cfb8();
const(EVP_CIPHER)* EVP_des_ede_cfb64();
alias EVP_des_ede_cfb64 EVP_des_ede_cfb;
version (none) {
const(EVP_CIPHER)* EVP_des_ede_cfb1();
const(EVP_CIPHER)* EVP_des_ede_cfb8();
}
const(EVP_CIPHER)* EVP_des_ede3_cfb64();
alias EVP_des_ede3_cfb64 EVP_des_ede3_cfb;
const(EVP_CIPHER)* EVP_des_ede3_cfb1();
const(EVP_CIPHER)* EVP_des_ede3_cfb8();
const(EVP_CIPHER)* EVP_des_ofb();
const(EVP_CIPHER)* EVP_des_ede_ofb();
const(EVP_CIPHER)* EVP_des_ede3_ofb();
const(EVP_CIPHER)* EVP_des_cbc();
const(EVP_CIPHER)* EVP_des_ede_cbc();
const(EVP_CIPHER)* EVP_des_ede3_cbc();
const(EVP_CIPHER)* EVP_desx_cbc();
/* This should now be supported through the dev_crypto ENGINE. But also, why are
* rc4 and md5 declarations made here inside a "NO_DES" precompiler branch? */
//#if 0
//# ifdef OPENSSL_OPENBSD_DEV_CRYPTO
//const(EVP_CIPHER)* EVP_dev_crypto_des_ede3_cbc();
//const(EVP_CIPHER)* EVP_dev_crypto_rc4();
//const(EVP_MD)* EVP_dev_crypto_md5();
//# endif
//#endif
}
version(OPENSSL_NO_RC4) {} else {
const(EVP_CIPHER)* EVP_rc4();
const(EVP_CIPHER)* EVP_rc4_40();
version(OPENSSL_NO_MD5) {} else {
const(EVP_CIPHER)* EVP_rc4_hmac_md5();
}
}
version(OPENSSL_NO_IDEA) {} else {
const(EVP_CIPHER)* EVP_idea_ecb();
const(EVP_CIPHER)* EVP_idea_cfb64();
alias EVP_idea_cfb64 EVP_idea_cfb;
const(EVP_CIPHER)* EVP_idea_ofb();
const(EVP_CIPHER)* EVP_idea_cbc();
}
version(OPENSSL_NO_RC2) {} else {
const(EVP_CIPHER)* EVP_rc2_ecb();
const(EVP_CIPHER)* EVP_rc2_cbc();
const(EVP_CIPHER)* EVP_rc2_40_cbc();
const(EVP_CIPHER)* EVP_rc2_64_cbc();
const(EVP_CIPHER)* EVP_rc2_cfb64();
alias EVP_rc2_cfb64 EVP_rc2_cfb;
const(EVP_CIPHER)* EVP_rc2_ofb();
}
version(OPENSSL_NO_BF) {} else {
const(EVP_CIPHER)* EVP_bf_ecb();
const(EVP_CIPHER)* EVP_bf_cbc();
const(EVP_CIPHER)* EVP_bf_cfb64();
alias EVP_bf_cfb64 EVP_bf_cfb;
const(EVP_CIPHER)* EVP_bf_ofb();
}
version(OPENSSL_NO_CAST) {} else {
const(EVP_CIPHER)* EVP_cast5_ecb();
const(EVP_CIPHER)* EVP_cast5_cbc();
const(EVP_CIPHER)* EVP_cast5_cfb64();
alias EVP_cast5_cfb64 EVP_cast5_cfb;
const(EVP_CIPHER)* EVP_cast5_ofb();
}
version(OPENSSL_NO_RC5) {} else {
const(EVP_CIPHER)* EVP_rc5_32_12_16_cbc();
const(EVP_CIPHER)* EVP_rc5_32_12_16_ecb();
const(EVP_CIPHER)* EVP_rc5_32_12_16_cfb64();
alias EVP_rc5_32_12_16_cfb64 EVP_rc5_32_12_16_cfb;
const(EVP_CIPHER)* EVP_rc5_32_12_16_ofb();
}
version(OPENSSL_NO_AES) {} else {
const(EVP_CIPHER)* EVP_aes_128_ecb();
const(EVP_CIPHER)* EVP_aes_128_cbc();
const(EVP_CIPHER)* EVP_aes_128_cfb1();
const(EVP_CIPHER)* EVP_aes_128_cfb8();
const(EVP_CIPHER)* EVP_aes_128_cfb128();
alias EVP_aes_128_cfb128 EVP_aes_128_cfb;
const(EVP_CIPHER)* EVP_aes_128_ofb();
const(EVP_CIPHER)* EVP_aes_128_ctr();
const(EVP_CIPHER)* EVP_aes_128_ccm();
const(EVP_CIPHER)* EVP_aes_128_gcm();
const(EVP_CIPHER)* EVP_aes_128_xts();
const(EVP_CIPHER)* EVP_aes_192_ecb();
const(EVP_CIPHER)* EVP_aes_192_cbc();
const(EVP_CIPHER)* EVP_aes_192_cfb1();
const(EVP_CIPHER)* EVP_aes_192_cfb8();
const(EVP_CIPHER)* EVP_aes_192_cfb128();
alias EVP_aes_192_cfb128 EVP_aes_192_cfb;
const(EVP_CIPHER)* EVP_aes_192_ofb();
const(EVP_CIPHER)* EVP_aes_192_ctr();
const(EVP_CIPHER)* EVP_aes_192_ccm();
const(EVP_CIPHER)* EVP_aes_192_gcm();
const(EVP_CIPHER)* EVP_aes_256_ecb();
const(EVP_CIPHER)* EVP_aes_256_cbc();
const(EVP_CIPHER)* EVP_aes_256_cfb1();
const(EVP_CIPHER)* EVP_aes_256_cfb8();
const(EVP_CIPHER)* EVP_aes_256_cfb128();
alias EVP_aes_256_cfb128 EVP_aes_256_cfb;
const(EVP_CIPHER)* EVP_aes_256_ofb();
const(EVP_CIPHER)* EVP_aes_256_ctr();
const(EVP_CIPHER)* EVP_aes_256_ccm();
const(EVP_CIPHER)* EVP_aes_256_gcm();
const(EVP_CIPHER)* EVP_aes_256_xts();
version(OPENSSL_NO_SHA) {} else version(OPENSSL_NO_SHA1) {} else {
const(EVP_CIPHER)* EVP_aes_128_cbc_hmac_sha1();
const(EVP_CIPHER)* EVP_aes_256_cbc_hmac_sha1();
}
}
version(OPENSSL_NO_CAMELLIA) {} else {
const(EVP_CIPHER)* EVP_camellia_128_ecb();
const(EVP_CIPHER)* EVP_camellia_128_cbc();
const(EVP_CIPHER)* EVP_camellia_128_cfb1();
const(EVP_CIPHER)* EVP_camellia_128_cfb8();
const(EVP_CIPHER)* EVP_camellia_128_cfb128();
alias EVP_camellia_128_cfb128 EVP_camellia_128_cfb;
const(EVP_CIPHER)* EVP_camellia_128_ofb();
const(EVP_CIPHER)* EVP_camellia_192_ecb();
const(EVP_CIPHER)* EVP_camellia_192_cbc();
const(EVP_CIPHER)* EVP_camellia_192_cfb1();
const(EVP_CIPHER)* EVP_camellia_192_cfb8();
const(EVP_CIPHER)* EVP_camellia_192_cfb128();
alias EVP_camellia_192_cfb128 EVP_camellia_192_cfb;
const(EVP_CIPHER)* EVP_camellia_192_ofb();
const(EVP_CIPHER)* EVP_camellia_256_ecb();
const(EVP_CIPHER)* EVP_camellia_256_cbc();
const(EVP_CIPHER)* EVP_camellia_256_cfb1();
const(EVP_CIPHER)* EVP_camellia_256_cfb8();
const(EVP_CIPHER)* EVP_camellia_256_cfb128();
alias EVP_camellia_256_cfb128 EVP_camellia_256_cfb;
const(EVP_CIPHER)* EVP_camellia_256_ofb();
}
version(OPENSSL_NO_SEED) {} else {
const(EVP_CIPHER)* EVP_seed_ecb();
const(EVP_CIPHER)* EVP_seed_cbc();
const(EVP_CIPHER)* EVP_seed_cfb128();
alias EVP_seed_cfb128 EVP_seed_cfb;
const(EVP_CIPHER)* EVP_seed_ofb();
}
void OPENSSL_add_all_algorithms_noconf();
void OPENSSL_add_all_algorithms_conf();
version (OPENSSL_LOAD_CONF) {
alias OPENSSL_add_all_algorithms_conf OpenSSL_add_all_algorithms;
} else {
alias OPENSSL_add_all_algorithms_noconf OpenSSL_add_all_algorithms;
}
void OpenSSL_add_all_ciphers();
void OpenSSL_add_all_digests();
alias OpenSSL_add_all_algorithms SSLeay_add_all_algorithms;
alias OpenSSL_add_all_ciphers SSLeay_add_all_ciphers;
alias OpenSSL_add_all_digests SSLeay_add_all_digests;
int EVP_add_cipher(const(EVP_CIPHER)* cipher);
int EVP_add_digest(const(EVP_MD)* digest);
const(EVP_CIPHER)* EVP_get_cipherbyname(const(char)* name);
const(EVP_MD)* EVP_get_digestbyname(const(char)* name);
void EVP_cleanup();
void EVP_CIPHER_do_all(ExternC!(void function(const(EVP_CIPHER)* ciph,
const(char)* from, const(char)* to, void* x)) fn, void* arg);
void EVP_CIPHER_do_all_sorted(ExternC!(void function(const(EVP_CIPHER)* ciph,
const(char)* from, const(char)* to, void* x)) fn, void* arg);
void EVP_MD_do_all(ExternC!(void function(const(EVP_MD)* ciph,
const(char)* from, const(char)* to, void* x)) fn, void* arg);
void EVP_MD_do_all_sorted(ExternC!(void function(const(EVP_MD)* ciph,
const(char)* from, const(char)* to, void* x)) fn, void* arg);
int EVP_PKEY_decrypt_old(ubyte* dec_key,
const(ubyte)* enc_key,int enc_key_len,
EVP_PKEY* private_key);
int EVP_PKEY_encrypt_old(ubyte* enc_key,
const(ubyte)* key,int key_len,
EVP_PKEY* pub_key);
int EVP_PKEY_type(int type);
int EVP_PKEY_id(const(EVP_PKEY)* pkey);
int EVP_PKEY_base_id(const(EVP_PKEY)* pkey);
int EVP_PKEY_bits(EVP_PKEY* pkey);
int EVP_PKEY_size(EVP_PKEY* pkey);
int EVP_PKEY_set_type(EVP_PKEY* pkey,int type);
int EVP_PKEY_set_type_str(EVP_PKEY* pkey, const(char)* str, int len);
int EVP_PKEY_assign(EVP_PKEY* pkey,int type,void* key);
void* EVP_PKEY_get0(EVP_PKEY* pkey);
version(OPENSSL_NO_RSA) {} else {
import deimos.openssl.rsa; /*struct rsa_st;*/
int EVP_PKEY_set1_RSA(EVP_PKEY* pkey,rsa_st* key);
rsa_st* EVP_PKEY_get1_RSA(EVP_PKEY* pkey);
}
version(OPENSSL_NO_DSA) {} else {
import deimos.openssl.dsa; /*struct dsa_st;*/
int EVP_PKEY_set1_DSA(EVP_PKEY* pkey,dsa_st* key);
dsa_st* EVP_PKEY_get1_DSA(EVP_PKEY* pkey);
}
version(OPENSSL_NO_DH) {} else {
import deimos.openssl.dh; /*struct dh_st;*/
int EVP_PKEY_set1_DH(EVP_PKEY* pkey,dh_st* key);
dh_st* EVP_PKEY_get1_DH(EVP_PKEY* pkey);
}
version(OPENSSL_NO_EC) {} else {
struct ec_key_st;
int EVP_PKEY_set1_EC_KEY(EVP_PKEY* pkey,ec_key_st* key);
ec_key_st* EVP_PKEY_get1_EC_KEY(EVP_PKEY* pkey);
}
EVP_PKEY* EVP_PKEY_new();
void EVP_PKEY_free(EVP_PKEY* pkey);
EVP_PKEY* d2i_PublicKey(int type,EVP_PKEY** a, const(ubyte)** pp,
c_long length);
int i2d_PublicKey(EVP_PKEY* a, ubyte** pp);
EVP_PKEY* d2i_PrivateKey(int type,EVP_PKEY** a, const(ubyte)** pp,
c_long length);
EVP_PKEY* d2i_AutoPrivateKey(EVP_PKEY** a, const(ubyte)** pp,
c_long length);
int i2d_PrivateKey(EVP_PKEY* a, ubyte** pp);
int EVP_PKEY_copy_parameters(EVP_PKEY* to, const(EVP_PKEY)* from);
int EVP_PKEY_missing_parameters(const(EVP_PKEY)* pkey);
int EVP_PKEY_save_parameters(EVP_PKEY* pkey,int mode);
int EVP_PKEY_cmp_parameters(const(EVP_PKEY)* a, const(EVP_PKEY)* b);
int EVP_PKEY_cmp(const(EVP_PKEY)* a, const(EVP_PKEY)* b);
int EVP_PKEY_print_public(BIO* out_, const(EVP_PKEY)* pkey,
int indent, ASN1_PCTX* pctx);
int EVP_PKEY_print_private(BIO* out_, const(EVP_PKEY)* pkey,
int indent, ASN1_PCTX* pctx);
int EVP_PKEY_print_params(BIO* out_, const(EVP_PKEY)* pkey,
int indent, ASN1_PCTX* pctx);
int EVP_PKEY_get_default_digest_nid(EVP_PKEY* pkey, int* pnid);
int EVP_CIPHER_type(const(EVP_CIPHER)* ctx);
/* calls methods */
int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX* c, ASN1_TYPE* type);
int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX* c, ASN1_TYPE* type);
/* These are used by EVP_CIPHER methods */
int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX* c,ASN1_TYPE* type);
int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX* c,ASN1_TYPE* type);
/* PKCS5 password based encryption */
int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX* ctx, const(char)* pass, int passlen,
ASN1_TYPE* param, const(EVP_CIPHER)* cipher, const(EVP_MD)* md,
int en_de);
int PKCS5_PBKDF2_HMAC_SHA1(const(char)* pass, int passlen,
const(ubyte)* salt, int saltlen, int iter,
int keylen, ubyte* out_);
int PKCS5_PBKDF2_HMAC(const(char)* pass, int passlen,
const(ubyte)* salt, int saltlen, int iter,
const(EVP_MD)* digest,
int keylen, ubyte* out_);
int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX* ctx, const(char)* pass, int passlen,
ASN1_TYPE* param, const(EVP_CIPHER)* cipher, const(EVP_MD)* md,
int en_de);
void PKCS5_PBE_add();
int EVP_PBE_CipherInit (ASN1_OBJECT* pbe_obj, const(char)* pass, int passlen,
ASN1_TYPE* param, EVP_CIPHER_CTX* ctx, int en_de);
/* PBE type */
/* Can appear as the outermost AlgorithmIdentifier */
enum EVP_PBE_TYPE_OUTER = 0x0;
/* Is an PRF type OID */
enum EVP_PBE_TYPE_PRF = 0x1;
int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid, int md_nid,
EVP_PBE_KEYGEN* keygen);
int EVP_PBE_alg_add(int nid, const(EVP_CIPHER)* cipher, const(EVP_MD)* md,
EVP_PBE_KEYGEN* keygen);
int EVP_PBE_find(int type, int pbe_nid,
int* pcnid, int* pmnid, EVP_PBE_KEYGEN** pkeygen);
void EVP_PBE_cleanup();
enum ASN1_PKEY_ALIAS = 0x1;
enum ASN1_PKEY_DYNAMIC = 0x2;
enum ASN1_PKEY_SIGPARAM_NULL = 0x4;
enum ASN1_PKEY_CTRL_PKCS7_SIGN = 0x1;
enum ASN1_PKEY_CTRL_PKCS7_ENCRYPT = 0x2;
enum ASN1_PKEY_CTRL_DEFAULT_MD_NID = 0x3;
enum ASN1_PKEY_CTRL_CMS_SIGN = 0x5;
enum ASN1_PKEY_CTRL_CMS_ENVELOPE = 0x7;
int EVP_PKEY_asn1_get_count();
const(EVP_PKEY_ASN1_METHOD)* EVP_PKEY_asn1_get0(int idx);
const(EVP_PKEY_ASN1_METHOD)* EVP_PKEY_asn1_find(ENGINE** pe, int type);
const(EVP_PKEY_ASN1_METHOD)* EVP_PKEY_asn1_find_str(ENGINE** pe,
const(char)* str, int len);
int EVP_PKEY_asn1_add0(const(EVP_PKEY_ASN1_METHOD)* ameth);
int EVP_PKEY_asn1_add_alias(int to, int from);
int EVP_PKEY_asn1_get0_info(int* ppkey_id, int* pkey_base_id, int* ppkey_flags,
const(char)** pinfo, const(char)** ppem_str,
const(EVP_PKEY_ASN1_METHOD)* ameth);
const(EVP_PKEY_ASN1_METHOD)* EVP_PKEY_get0_asn1(EVP_PKEY* pkey);
EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id, int flags,
const(char)* pem_str, const(char)* info);
void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD* dst,
const(EVP_PKEY_ASN1_METHOD)* src);
void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD* ameth);
void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD* ameth,
ExternC!(int function(EVP_PKEY* pk, X509_PUBKEY* pub)) pub_decode,
ExternC!(int function(X509_PUBKEY* pub, const(EVP_PKEY)* pk)) pub_encode,
ExternC!(int function(const(EVP_PKEY)* a, const(EVP_PKEY)* b)) pub_cmp,
ExternC!(int function(BIO* out_, const(EVP_PKEY)* pkey, int indent,
ASN1_PCTX* pctx)) pub_print,
ExternC!(int function(const(EVP_PKEY)* pk)) pkey_size,
ExternC!(int function(const(EVP_PKEY)* pk)) pkey_bits);
void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD* ameth,
ExternC!(int function(EVP_PKEY* pk, PKCS8_PRIV_KEY_INFO* p8inf)) priv_decode,
ExternC!(int function(PKCS8_PRIV_KEY_INFO* p8, const(EVP_PKEY)* pk)) priv_encode,
ExternC!(int function(BIO* out_, const(EVP_PKEY)* pkey, int indent,
ASN1_PCTX* pctx)) priv_print);
void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD* ameth,
ExternC!(int function(EVP_PKEY* pkey,
const(ubyte)** pder, int derlen)) param_decode,
ExternC!(int function(const(EVP_PKEY)* pkey, ubyte** pder)) param_encode,
ExternC!(int function(const(EVP_PKEY)* pk)) param_missing,
ExternC!(int function(EVP_PKEY* to, const(EVP_PKEY)* from)) param_copy,
ExternC!(int function(const(EVP_PKEY)* a, const(EVP_PKEY)* b)) param_cmp,
ExternC!(int function(BIO* out_, const(EVP_PKEY)* pkey, int indent,
ASN1_PCTX* pctx)) param_print);
void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD* ameth,
ExternC!(void function(EVP_PKEY* pkey)) pkey_free);
void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD* ameth,
ExternC!(int function(EVP_PKEY* pkey, int op,
c_long arg1, void* arg2)) pkey_ctrl);
enum EVP_PKEY_OP_UNDEFINED = 0;
enum EVP_PKEY_OP_PARAMGEN = (1<<1);
enum EVP_PKEY_OP_KEYGEN = (1<<2);
enum EVP_PKEY_OP_SIGN = (1<<3);
enum EVP_PKEY_OP_VERIFY = (1<<4);
enum EVP_PKEY_OP_VERIFYRECOVER = (1<<5);
enum EVP_PKEY_OP_SIGNCTX = (1<<6);
enum EVP_PKEY_OP_VERIFYCTX = (1<<7);
enum EVP_PKEY_OP_ENCRYPT = (1<<8);
enum EVP_PKEY_OP_DECRYPT = (1<<9);
enum EVP_PKEY_OP_DERIVE = (1<<10);
enum EVP_PKEY_OP_TYPE_SIG =
(EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY | EVP_PKEY_OP_VERIFYRECOVER
| EVP_PKEY_OP_SIGNCTX | EVP_PKEY_OP_VERIFYCTX);
enum EVP_PKEY_OP_TYPE_CRYPT =
(EVP_PKEY_OP_ENCRYPT | EVP_PKEY_OP_DECRYPT);
/+ BUG in original headers: EVP_PKEY_OP_SIG, EVP_PKEY_OP_CRYPT are not defined.
enum EVP_PKEY_OP_TYPE_NOGEN =
(EVP_PKEY_OP_SIG | EVP_PKEY_OP_CRYPT | EVP_PKEY_OP_DERIVE);
+/
enum EVP_PKEY_OP_TYPE_GEN =
(EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN);
auto EVP_PKEY_CTX_set_signature_md()(EVP_PKEY_CTX* ctx, void* md) {
return EVP_PKEY_CTX_ctrl(ctx, -1, EVP_PKEY_OP_TYPE_SIG,
EVP_PKEY_CTRL_MD, 0, md);
}
enum EVP_PKEY_CTRL_MD = 1;
enum EVP_PKEY_CTRL_PEER_KEY = 2;
enum EVP_PKEY_CTRL_PKCS7_ENCRYPT = 3;
enum EVP_PKEY_CTRL_PKCS7_DECRYPT = 4;
enum EVP_PKEY_CTRL_PKCS7_SIGN = 5;
enum EVP_PKEY_CTRL_SET_MAC_KEY = 6;
enum EVP_PKEY_CTRL_DIGESTINIT = 7;
/* Used by GOST key encryption in TLS */
enum EVP_PKEY_CTRL_SET_IV = 8;
enum EVP_PKEY_CTRL_CMS_ENCRYPT = 9;
enum EVP_PKEY_CTRL_CMS_DECRYPT = 10;
enum EVP_PKEY_CTRL_CMS_SIGN = 11;
enum EVP_PKEY_CTRL_CIPHER = 12;
enum EVP_PKEY_ALG_CTRL = 0x1000;
enum EVP_PKEY_FLAG_AUTOARGLEN = 2;
/* Method handles all operations: don't assume any digest related
* defaults.
*/
enum EVP_PKEY_FLAG_SIGCTX_CUSTOM = 4;
const(EVP_PKEY_METHOD)* EVP_PKEY_meth_find(int type);
EVP_PKEY_METHOD* EVP_PKEY_meth_new(int id, int flags);
void EVP_PKEY_meth_get0_info(int* ppkey_id, int* pflags,
const(EVP_PKEY_METHOD)* meth);
void EVP_PKEY_meth_copy(EVP_PKEY_METHOD* dst, const(EVP_PKEY_METHOD)* src);
void EVP_PKEY_meth_free(EVP_PKEY_METHOD* pmeth);
int EVP_PKEY_meth_add0(const(EVP_PKEY_METHOD)* pmeth);
EVP_PKEY_CTX* EVP_PKEY_CTX_new(EVP_PKEY* pkey, ENGINE* e);
EVP_PKEY_CTX* EVP_PKEY_CTX_new_id(int id, ENGINE* e);
EVP_PKEY_CTX* EVP_PKEY_CTX_dup(EVP_PKEY_CTX* ctx);
void EVP_PKEY_CTX_free(EVP_PKEY_CTX* ctx);
int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX* ctx, int keytype, int optype,
int cmd, int p1, void* p2);
int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX* ctx, const(char)* type,
const(char)* value);
int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX* ctx);
void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX* ctx, int* dat, int datlen);
EVP_PKEY* EVP_PKEY_new_mac_key(int type, ENGINE* e,
const(ubyte)* key, int keylen);
void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX* ctx, void* data);
void* EVP_PKEY_CTX_get_data(EVP_PKEY_CTX* ctx);
EVP_PKEY* EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX* ctx);
EVP_PKEY* EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX* ctx);
void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX* ctx, void* data);
void* EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX* ctx);
int EVP_PKEY_sign_init(EVP_PKEY_CTX* ctx);
int EVP_PKEY_sign(EVP_PKEY_CTX* ctx,
ubyte* sig, size_t* siglen,
const(ubyte)* tbs, size_t tbslen);
int EVP_PKEY_verify_init(EVP_PKEY_CTX* ctx);
int EVP_PKEY_verify(EVP_PKEY_CTX* ctx,
const(ubyte)* sig, size_t siglen,
const(ubyte)* tbs, size_t tbslen);
int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX* ctx);
int EVP_PKEY_verify_recover(EVP_PKEY_CTX* ctx,
ubyte* rout, size_t* routlen,
const(ubyte)* sig, size_t siglen);
int EVP_PKEY_encrypt_init(EVP_PKEY_CTX* ctx);
int EVP_PKEY_encrypt(EVP_PKEY_CTX* ctx,
ubyte* out_, size_t* outlen,
const(ubyte)* in_, size_t inlen);
int EVP_PKEY_decrypt_init(EVP_PKEY_CTX* ctx);
int EVP_PKEY_decrypt(EVP_PKEY_CTX* ctx,
ubyte* out_, size_t* outlen,
const(ubyte)* in_, size_t inlen);
int EVP_PKEY_derive_init(EVP_PKEY_CTX* ctx);
int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX* ctx, EVP_PKEY* peer);
int EVP_PKEY_derive(EVP_PKEY_CTX* ctx, ubyte* key, size_t* keylen);
alias typeof(*(ExternC!(int function(EVP_PKEY_CTX* ctx))).init) EVP_PKEY_gen_cb;
int EVP_PKEY_paramgen_init(EVP_PKEY_CTX* ctx);
int EVP_PKEY_paramgen(EVP_PKEY_CTX* ctx, EVP_PKEY** ppkey);
int EVP_PKEY_keygen_init(EVP_PKEY_CTX* ctx);
int EVP_PKEY_keygen(EVP_PKEY_CTX* ctx, EVP_PKEY** ppkey);
void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX* ctx, EVP_PKEY_gen_cb* cb);
EVP_PKEY_gen_cb* EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX* ctx);
int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX* ctx, int idx);
void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* ctx)) init);
void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* dst, EVP_PKEY_CTX* src)) copy);
void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD* pmeth,
ExternC!(void function(EVP_PKEY_CTX* ctx)) cleanup);
void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* ctx)) paramgen_init,
ExternC!(int function(EVP_PKEY_CTX* ctx, EVP_PKEY* pkey)) paramgen);
void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* ctx)) keygen_init,
ExternC!(int function(EVP_PKEY_CTX* ctx, EVP_PKEY* pkey)) keygen);
void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* ctx)) sign_init,
ExternC!(int function(EVP_PKEY_CTX* ctx, ubyte* sig, size_t* siglen,
const(ubyte)* tbs, size_t tbslen)) sign);
void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* ctx)) verify_init,
ExternC!(int function(EVP_PKEY_CTX* ctx, const(ubyte)* sig, size_t siglen,
const(ubyte)* tbs, size_t tbslen)) verify);
void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* ctx)) verify_recover_init,
ExternC!(int function(EVP_PKEY_CTX* ctx,
ubyte* sig, size_t* siglen,
const(ubyte)* tbs, size_t tbslen)) verify_recover);
void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* ctx, EVP_MD_CTX* mctx)) signctx_init,
ExternC!(int function(EVP_PKEY_CTX* ctx, ubyte* sig, size_t* siglen,
EVP_MD_CTX* mctx)) signctx);
void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* ctx, EVP_MD_CTX* mctx)) verifyctx_init,
ExternC!(int function(EVP_PKEY_CTX* ctx, const(ubyte)* sig,int siglen,
EVP_MD_CTX* mctx)) verifyctx);
void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* ctx)) encrypt_init,
ExternC!(int function(EVP_PKEY_CTX* ctx, ubyte* out_, size_t* outlen,
const(ubyte)* in_, size_t inlen)) encryptfn);
void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* ctx)) decrypt_init,
ExternC!(int function(EVP_PKEY_CTX* ctx, ubyte* out_, size_t* outlen,
const(ubyte)* in_, size_t inlen)) decrypt);
void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* ctx)) derive_init,
ExternC!(int function(EVP_PKEY_CTX* ctx, ubyte* key, size_t* keylen)) derive);
void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD* pmeth,
ExternC!(int function(EVP_PKEY_CTX* ctx, int type, int p1, void* p2)) ctrl,
ExternC!(int function(EVP_PKEY_CTX* ctx,
const(char)* type, const(char)* value)) ctrl_str);
void EVP_add_alg_module();
/* BEGIN ERROR CODES */
/* The following lines are auto generated by the script mkerr.pl. Any changes
* made after this point may be overwritten when the script is next run.
*/
void ERR_load_EVP_strings();
/* Error codes for the EVP functions. */
/* Function codes. */
enum EVP_F_AESNI_INIT_KEY = 165;
enum EVP_F_AESNI_XTS_CIPHER = 176;
enum EVP_F_AES_INIT_KEY = 133;
enum EVP_F_AES_XTS = 172;
enum EVP_F_AES_XTS_CIPHER = 175;
enum EVP_F_ALG_MODULE_INIT = 177;
enum EVP_F_CAMELLIA_INIT_KEY = 159;
enum EVP_F_CMAC_INIT = 173;
enum EVP_F_D2I_PKEY = 100;
enum EVP_F_DO_SIGVER_INIT = 161;
enum EVP_F_DSAPKEY2PKCS8 = 134;
enum EVP_F_DSA_PKEY2PKCS8 = 135;
enum EVP_F_ECDSA_PKEY2PKCS8 = 129;
enum EVP_F_ECKEY_PKEY2PKCS8 = 132;
enum EVP_F_EVP_CIPHERINIT_EX = 123;
enum EVP_F_EVP_CIPHER_CTX_COPY = 163;
enum EVP_F_EVP_CIPHER_CTX_CTRL = 124;
enum EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH = 122;
enum EVP_F_EVP_DECRYPTFINAL_EX = 101;
enum EVP_F_EVP_DIGESTINIT_EX = 128;
enum EVP_F_EVP_ENCRYPTFINAL_EX = 127;
enum EVP_F_EVP_MD_CTX_COPY_EX = 110;
enum EVP_F_EVP_MD_SIZE = 162;
enum EVP_F_EVP_OPENINIT = 102;
enum EVP_F_EVP_PBE_ALG_ADD = 115;
enum EVP_F_EVP_PBE_ALG_ADD_TYPE = 160;
enum EVP_F_EVP_PBE_CIPHERINIT = 116;
enum EVP_F_EVP_PKCS82PKEY = 111;
enum EVP_F_EVP_PKCS82PKEY_BROKEN = 136;
enum EVP_F_EVP_PKEY2PKCS8_BROKEN = 113;
enum EVP_F_EVP_PKEY_COPY_PARAMETERS = 103;
enum EVP_F_EVP_PKEY_CTX_CTRL = 137;
enum EVP_F_EVP_PKEY_CTX_CTRL_STR = 150;
enum EVP_F_EVP_PKEY_CTX_DUP = 156;
enum EVP_F_EVP_PKEY_DECRYPT = 104;
enum EVP_F_EVP_PKEY_DECRYPT_INIT = 138;
enum EVP_F_EVP_PKEY_DECRYPT_OLD = 151;
enum EVP_F_EVP_PKEY_DERIVE = 153;
enum EVP_F_EVP_PKEY_DERIVE_INIT = 154;
enum EVP_F_EVP_PKEY_DERIVE_SET_PEER = 155;
enum EVP_F_EVP_PKEY_ENCRYPT = 105;
enum EVP_F_EVP_PKEY_ENCRYPT_INIT = 139;
enum EVP_F_EVP_PKEY_ENCRYPT_OLD = 152;
enum EVP_F_EVP_PKEY_GET1_DH = 119;
enum EVP_F_EVP_PKEY_GET1_DSA = 120;
enum EVP_F_EVP_PKEY_GET1_ECDSA = 130;
enum EVP_F_EVP_PKEY_GET1_EC_KEY = 131;
enum EVP_F_EVP_PKEY_GET1_RSA = 121;
enum EVP_F_EVP_PKEY_KEYGEN = 146;
enum EVP_F_EVP_PKEY_KEYGEN_INIT = 147;
enum EVP_F_EVP_PKEY_NEW = 106;
enum EVP_F_EVP_PKEY_PARAMGEN = 148;
enum EVP_F_EVP_PKEY_PARAMGEN_INIT = 149;
enum EVP_F_EVP_PKEY_SIGN = 140;
enum EVP_F_EVP_PKEY_SIGN_INIT = 141;
enum EVP_F_EVP_PKEY_VERIFY = 142;
enum EVP_F_EVP_PKEY_VERIFY_INIT = 143;
enum EVP_F_EVP_PKEY_VERIFY_RECOVER = 144;
enum EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT = 145;
enum EVP_F_EVP_RIJNDAEL = 126;
enum EVP_F_EVP_SIGNFINAL = 107;
enum EVP_F_EVP_VERIFYFINAL = 108;
enum EVP_F_FIPS_CIPHERINIT = 166;
enum EVP_F_FIPS_CIPHER_CTX_COPY = 170;
enum EVP_F_FIPS_CIPHER_CTX_CTRL = 167;
enum EVP_F_FIPS_CIPHER_CTX_SET_KEY_LENGTH = 171;
enum EVP_F_FIPS_DIGESTINIT = 168;
enum EVP_F_FIPS_MD_CTX_COPY = 169;
enum EVP_F_HMAC_INIT_EX = 174;
enum EVP_F_INT_CTX_NEW = 157;
enum EVP_F_PKCS5_PBE_KEYIVGEN = 117;
enum EVP_F_PKCS5_V2_PBE_KEYIVGEN = 118;
enum EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN = 164;
enum EVP_F_PKCS8_SET_BROKEN = 112;
enum EVP_F_PKEY_SET_TYPE = 158;
enum EVP_F_RC2_MAGIC_TO_METH = 109;
enum EVP_F_RC5_CTRL = 125;
/* Reason codes. */
enum EVP_R_AES_IV_SETUP_FAILED = 162;
enum EVP_R_AES_KEY_SETUP_FAILED = 143;
enum EVP_R_ASN1_LIB = 140;
enum EVP_R_BAD_BLOCK_LENGTH = 136;
enum EVP_R_BAD_DECRYPT = 100;
enum EVP_R_BAD_KEY_LENGTH = 137;
enum EVP_R_BN_DECODE_ERROR = 112;
enum EVP_R_BN_PUBKEY_ERROR = 113;
enum EVP_R_BUFFER_TOO_SMALL = 155;
enum EVP_R_CAMELLIA_KEY_SETUP_FAILED = 157;
enum EVP_R_CIPHER_PARAMETER_ERROR = 122;
enum EVP_R_COMMAND_NOT_SUPPORTED = 147;
enum EVP_R_CTRL_NOT_IMPLEMENTED = 132;
enum EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED = 133;
enum EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH = 138;
enum EVP_R_DECODE_ERROR = 114;
enum EVP_R_DIFFERENT_KEY_TYPES = 101;
enum EVP_R_DIFFERENT_PARAMETERS = 153;
enum EVP_R_DISABLED_FOR_FIPS = 163;
enum EVP_R_ENCODE_ERROR = 115;
enum EVP_R_ERROR_LOADING_SECTION = 165;
enum EVP_R_ERROR_SETTING_FIPS_MODE = 166;
enum EVP_R_EVP_PBE_CIPHERINIT_ERROR = 119;
enum EVP_R_EXPECTING_AN_RSA_KEY = 127;
enum EVP_R_EXPECTING_A_DH_KEY = 128;
enum EVP_R_EXPECTING_A_DSA_KEY = 129;
enum EVP_R_EXPECTING_A_ECDSA_KEY = 141;
enum EVP_R_EXPECTING_A_EC_KEY = 142;
enum EVP_R_FIPS_MODE_NOT_SUPPORTED = 167;
enum EVP_R_INITIALIZATION_ERROR = 134;
enum EVP_R_INPUT_NOT_INITIALIZED = 111;
enum EVP_R_INVALID_DIGEST = 152;
enum EVP_R_INVALID_FIPS_MODE = 168;
enum EVP_R_INVALID_KEY_LENGTH = 130;
enum EVP_R_INVALID_OPERATION = 148;
enum EVP_R_IV_TOO_LARGE = 102;
enum EVP_R_KEYGEN_FAILURE = 120;
enum EVP_R_MESSAGE_DIGEST_IS_NULL = 159;
enum EVP_R_METHOD_NOT_SUPPORTED = 144;
enum EVP_R_MISSING_PARAMETERS = 103;
enum EVP_R_NO_CIPHER_SET = 131;
enum EVP_R_NO_DEFAULT_DIGEST = 158;
enum EVP_R_NO_DIGEST_SET = 139;
enum EVP_R_NO_DSA_PARAMETERS = 116;
enum EVP_R_NO_KEY_SET = 154;
enum EVP_R_NO_OPERATION_SET = 149;
enum EVP_R_NO_SIGN_FUNCTION_CONFIGURED = 104;
enum EVP_R_NO_VERIFY_FUNCTION_CONFIGURED = 105;
enum EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE = 150;
enum EVP_R_OPERATON_NOT_INITIALIZED = 151;
enum EVP_R_PKCS8_UNKNOWN_BROKEN_TYPE = 117;
enum EVP_R_PRIVATE_KEY_DECODE_ERROR = 145;
enum EVP_R_PRIVATE_KEY_ENCODE_ERROR = 146;
enum EVP_R_PUBLIC_KEY_NOT_RSA = 106;
enum EVP_R_TOO_LARGE = 164;
enum EVP_R_UNKNOWN_CIPHER = 160;
enum EVP_R_UNKNOWN_DIGEST = 161;
enum EVP_R_UNKNOWN_OPTION = 169;
enum EVP_R_UNKNOWN_PBE_ALGORITHM = 121;
enum EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS = 135;
enum EVP_R_UNSUPPORTED_ALGORITHM = 156;
enum EVP_R_UNSUPPORTED_CIPHER = 107;
enum EVP_R_UNSUPPORTED_KEYLENGTH = 123;
enum EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION = 124;
enum EVP_R_UNSUPPORTED_KEY_SIZE = 108;
enum EVP_R_UNSUPPORTED_PRF = 125;
enum EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM = 118;
enum EVP_R_UNSUPPORTED_SALT_TYPE = 126;
enum EVP_R_WRONG_FINAL_BLOCK_LENGTH = 109;
enum EVP_R_WRONG_PUBLIC_KEY_TYPE = 110;
Reference in New Issue View Git Blame Copy Permalink