1 use libc::*;
2 use *;
3 
4 pub const EVP_MAX_MD_SIZE: c_uint = 64;
5 
6 pub const PKCS5_SALT_LEN: c_int = 8;
7 pub const PKCS12_DEFAULT_ITER: c_int = 2048;
8 
9 pub const EVP_PKEY_RSA: c_int = NID_rsaEncryption;
10 pub const EVP_PKEY_DSA: c_int = NID_dsa;
11 pub const EVP_PKEY_DH: c_int = NID_dhKeyAgreement;
12 pub const EVP_PKEY_EC: c_int = NID_X9_62_id_ecPublicKey;
13 #[cfg(ossl111)]
14 pub const EVP_PKEY_X25519: c_int = NID_X25519;
15 #[cfg(ossl111)]
16 pub const EVP_PKEY_ED25519: c_int = NID_ED25519;
17 #[cfg(ossl111)]
18 pub const EVP_PKEY_X448: c_int = NID_X448;
19 #[cfg(ossl111)]
20 pub const EVP_PKEY_ED448: c_int = NID_ED448;
21 pub const EVP_PKEY_HMAC: c_int = NID_hmac;
22 pub const EVP_PKEY_CMAC: c_int = NID_cmac;
23 #[cfg(ossl110)]
24 pub const EVP_PKEY_HKDF: c_int = NID_hkdf;
25 
26 pub const EVP_CTRL_GCM_SET_IVLEN: c_int = 0x9;
27 pub const EVP_CTRL_GCM_GET_TAG: c_int = 0x10;
28 pub const EVP_CTRL_GCM_SET_TAG: c_int = 0x11;
29 
EVP_get_digestbynid(type_: c_int) -> *const EVP_MD30 pub unsafe fn EVP_get_digestbynid(type_: c_int) -> *const EVP_MD {
31     EVP_get_digestbyname(OBJ_nid2sn(type_))
32 }
33 
34 cfg_if! {
35     if #[cfg(ossl300)] {
36         extern "C" {
37             pub fn EVP_MD_get_size(md: *const EVP_MD) -> c_int;
38             pub fn EVP_MD_get_type(md: *const EVP_MD) -> c_int;
39 
40             pub fn EVP_CIPHER_get_key_length(cipher: *const EVP_CIPHER) -> c_int;
41             pub fn EVP_CIPHER_get_block_size(cipher: *const EVP_CIPHER) -> c_int;
42             pub fn EVP_CIPHER_get_iv_length(cipher: *const EVP_CIPHER) -> c_int;
43             pub fn EVP_CIPHER_get_nid(cipher: *const EVP_CIPHER) -> c_int;
44             pub fn EVP_CIPHER_fetch(
45                 ctx: *mut OSSL_LIB_CTX,
46                 algorithm: *const c_char,
47                 properties: *const c_char,
48             ) -> *mut EVP_CIPHER;
49             pub fn EVP_CIPHER_free(cipher: *mut EVP_CIPHER);
50 
51             pub fn EVP_CIPHER_CTX_get0_cipher(ctx: *const EVP_CIPHER_CTX) -> *const EVP_CIPHER;
52             pub fn EVP_CIPHER_CTX_get_block_size(ctx: *const EVP_CIPHER_CTX) -> c_int;
53             pub fn EVP_CIPHER_CTX_get_key_length(ctx: *const EVP_CIPHER_CTX) -> c_int;
54             pub fn EVP_CIPHER_CTX_get_iv_length(ctx: *const EVP_CIPHER_CTX) -> c_int;
55             pub fn EVP_CIPHER_CTX_get_tag_length(ctx: *const EVP_CIPHER_CTX) -> c_int;
56         }
57 
58         #[inline]
59         pub unsafe fn EVP_MD_size(md: *const EVP_MD) -> c_int {
60             EVP_MD_get_size(md)
61         }
62 
63         #[inline]
64         pub unsafe fn EVP_MD_type(md: *const EVP_MD) -> c_int {
65             EVP_MD_get_type(md)
66         }
67 
68         #[inline]
69         pub unsafe fn EVP_CIPHER_key_length(cipher: *const EVP_CIPHER) -> c_int {
70             EVP_CIPHER_get_key_length(cipher)
71         }
72 
73         #[inline]
74         pub unsafe fn EVP_CIPHER_block_size(cipher: *const EVP_CIPHER) -> c_int {
75             EVP_CIPHER_get_block_size(cipher)
76         }
77 
78         #[inline]
79         pub unsafe fn EVP_CIPHER_iv_length(cipher: *const EVP_CIPHER) -> c_int {
80             EVP_CIPHER_get_iv_length(cipher)
81         }
82 
83         #[inline]
84         pub unsafe fn EVP_CIPHER_nid(cipher: *const EVP_CIPHER) -> c_int {
85             EVP_CIPHER_get_nid(cipher)
86         }
87 
88         #[inline]
89         pub unsafe fn EVP_CIPHER_CTX_block_size(ctx: *const EVP_CIPHER_CTX) -> c_int {
90             EVP_CIPHER_CTX_get_block_size(ctx)
91         }
92 
93         #[inline]
94         pub unsafe fn EVP_CIPHER_CTX_key_length(ctx: *const EVP_CIPHER_CTX) -> c_int {
95             EVP_CIPHER_CTX_get_key_length(ctx)
96         }
97 
98         #[inline]
99         pub unsafe fn EVP_CIPHER_CTX_iv_length(ctx: *const EVP_CIPHER_CTX) -> c_int {
100             EVP_CIPHER_CTX_get_iv_length(ctx)
101         }
102     } else {
103         extern "C" {
104             pub fn EVP_MD_size(md: *const EVP_MD) -> c_int;
105             pub fn EVP_MD_type(md: *const EVP_MD) -> c_int;
106 
107             pub fn EVP_CIPHER_key_length(cipher: *const EVP_CIPHER) -> c_int;
108             pub fn EVP_CIPHER_block_size(cipher: *const EVP_CIPHER) -> c_int;
109             pub fn EVP_CIPHER_iv_length(cipher: *const EVP_CIPHER) -> c_int;
110             pub fn EVP_CIPHER_nid(cipher: *const EVP_CIPHER) -> c_int;
111 
112             pub fn EVP_CIPHER_CTX_cipher(ctx: *const EVP_CIPHER_CTX) -> *const EVP_CIPHER;
113             pub fn EVP_CIPHER_CTX_block_size(ctx: *const EVP_CIPHER_CTX) -> c_int;
114             pub fn EVP_CIPHER_CTX_key_length(ctx: *const EVP_CIPHER_CTX) -> c_int;
115             pub fn EVP_CIPHER_CTX_iv_length(ctx: *const EVP_CIPHER_CTX) -> c_int;
116         }
117     }
118 }
119 
120 cfg_if! {
121     if #[cfg(ossl110)] {
122         extern "C" {
123             pub fn EVP_MD_CTX_new() -> *mut EVP_MD_CTX;
124             pub fn EVP_MD_CTX_free(ctx: *mut EVP_MD_CTX);
125         }
126     } else {
127         extern "C" {
128             pub fn EVP_MD_CTX_create() -> *mut EVP_MD_CTX;
129             pub fn EVP_MD_CTX_destroy(ctx: *mut EVP_MD_CTX);
130         }
131     }
132 }
133 
134 extern "C" {
EVP_DigestInit_ex(ctx: *mut EVP_MD_CTX, typ: *const EVP_MD, imple: *mut ENGINE) -> c_int135     pub fn EVP_DigestInit_ex(ctx: *mut EVP_MD_CTX, typ: *const EVP_MD, imple: *mut ENGINE)
136         -> c_int;
EVP_DigestUpdate(ctx: *mut EVP_MD_CTX, data: *const c_void, n: size_t) -> c_int137     pub fn EVP_DigestUpdate(ctx: *mut EVP_MD_CTX, data: *const c_void, n: size_t) -> c_int;
EVP_DigestFinal_ex(ctx: *mut EVP_MD_CTX, res: *mut u8, n: *mut u32) -> c_int138     pub fn EVP_DigestFinal_ex(ctx: *mut EVP_MD_CTX, res: *mut u8, n: *mut u32) -> c_int;
139     #[cfg(ossl300)]
EVP_Q_digest( libctx: *mut OSSL_LIB_CTX, name: *const c_char, propq: *const c_char, data: *const c_void, count: size_t, md: *mut c_uchar, size: *mut size_t, ) -> c_int140     pub fn EVP_Q_digest(
141         libctx: *mut OSSL_LIB_CTX,
142         name: *const c_char,
143         propq: *const c_char,
144         data: *const c_void,
145         count: size_t,
146         md: *mut c_uchar,
147         size: *mut size_t,
148     ) -> c_int;
EVP_DigestInit(ctx: *mut EVP_MD_CTX, typ: *const EVP_MD) -> c_int149     pub fn EVP_DigestInit(ctx: *mut EVP_MD_CTX, typ: *const EVP_MD) -> c_int;
EVP_DigestFinal(ctx: *mut EVP_MD_CTX, res: *mut u8, n: *mut u32) -> c_int150     pub fn EVP_DigestFinal(ctx: *mut EVP_MD_CTX, res: *mut u8, n: *mut u32) -> c_int;
151     #[cfg(ossl111)]
EVP_DigestFinalXOF(ctx: *mut EVP_MD_CTX, res: *mut u8, len: usize) -> c_int152     pub fn EVP_DigestFinalXOF(ctx: *mut EVP_MD_CTX, res: *mut u8, len: usize) -> c_int;
153 
154     #[cfg(ossl300)]
EVP_MD_fetch( ctx: *mut OSSL_LIB_CTX, algorithm: *const c_char, properties: *const c_char, ) -> *mut EVP_MD155     pub fn EVP_MD_fetch(
156         ctx: *mut OSSL_LIB_CTX,
157         algorithm: *const c_char,
158         properties: *const c_char,
159     ) -> *mut EVP_MD;
160 
161     #[cfg(ossl300)]
EVP_MD_free(md: *mut EVP_MD)162     pub fn EVP_MD_free(md: *mut EVP_MD);
163 
EVP_BytesToKey( typ: *const EVP_CIPHER, md: *const EVP_MD, salt: *const u8, data: *const u8, datalen: c_int, count: c_int, key: *mut u8, iv: *mut u8, ) -> c_int164     pub fn EVP_BytesToKey(
165         typ: *const EVP_CIPHER,
166         md: *const EVP_MD,
167         salt: *const u8,
168         data: *const u8,
169         datalen: c_int,
170         count: c_int,
171         key: *mut u8,
172         iv: *mut u8,
173     ) -> c_int;
174 
EVP_CipherInit( ctx: *mut EVP_CIPHER_CTX, evp: *const EVP_CIPHER, key: *const u8, iv: *const u8, mode: c_int, ) -> c_int175     pub fn EVP_CipherInit(
176         ctx: *mut EVP_CIPHER_CTX,
177         evp: *const EVP_CIPHER,
178         key: *const u8,
179         iv: *const u8,
180         mode: c_int,
181     ) -> c_int;
EVP_CipherInit_ex( ctx: *mut EVP_CIPHER_CTX, type_: *const EVP_CIPHER, impl_: *mut ENGINE, key: *const c_uchar, iv: *const c_uchar, enc: c_int, ) -> c_int182     pub fn EVP_CipherInit_ex(
183         ctx: *mut EVP_CIPHER_CTX,
184         type_: *const EVP_CIPHER,
185         impl_: *mut ENGINE,
186         key: *const c_uchar,
187         iv: *const c_uchar,
188         enc: c_int,
189     ) -> c_int;
EVP_CipherUpdate( ctx: *mut EVP_CIPHER_CTX, outbuf: *mut u8, outlen: *mut c_int, inbuf: *const u8, inlen: c_int, ) -> c_int190     pub fn EVP_CipherUpdate(
191         ctx: *mut EVP_CIPHER_CTX,
192         outbuf: *mut u8,
193         outlen: *mut c_int,
194         inbuf: *const u8,
195         inlen: c_int,
196     ) -> c_int;
EVP_CipherFinal(ctx: *mut EVP_CIPHER_CTX, res: *mut u8, len: *mut c_int) -> c_int197     pub fn EVP_CipherFinal(ctx: *mut EVP_CIPHER_CTX, res: *mut u8, len: *mut c_int) -> c_int;
198 
EVP_DigestSignInit( ctx: *mut EVP_MD_CTX, pctx: *mut *mut EVP_PKEY_CTX, type_: *const EVP_MD, e: *mut ENGINE, pkey: *mut EVP_PKEY, ) -> c_int199     pub fn EVP_DigestSignInit(
200         ctx: *mut EVP_MD_CTX,
201         pctx: *mut *mut EVP_PKEY_CTX,
202         type_: *const EVP_MD,
203         e: *mut ENGINE,
204         pkey: *mut EVP_PKEY,
205     ) -> c_int;
206 }
207 cfg_if! {
208     if #[cfg(ossl300)] {
209         extern "C" {
210             pub fn EVP_DigestSignUpdate(
211                 ctx: *mut EVP_MD_CTX,
212                 data: *const c_void,
213                 dsize: size_t,
214             ) -> c_int;
215         }
216     } else {
217         #[inline]
218         pub unsafe fn EVP_DigestSignUpdate(
219             ctx: *mut EVP_MD_CTX,
220             data: *const c_void,
221             dsize: size_t,
222         ) -> c_int {
223             EVP_DigestUpdate(ctx, data, dsize)
224         }
225     }
226 }
227 extern "C" {
EVP_DigestSignFinal( ctx: *mut EVP_MD_CTX, sig: *mut c_uchar, siglen: *mut size_t, ) -> c_int228     pub fn EVP_DigestSignFinal(
229         ctx: *mut EVP_MD_CTX,
230         sig: *mut c_uchar,
231         siglen: *mut size_t,
232     ) -> c_int;
EVP_DigestVerifyInit( ctx: *mut EVP_MD_CTX, pctx: *mut *mut EVP_PKEY_CTX, type_: *const EVP_MD, e: *mut ENGINE, pkey: *mut EVP_PKEY, ) -> c_int233     pub fn EVP_DigestVerifyInit(
234         ctx: *mut EVP_MD_CTX,
235         pctx: *mut *mut EVP_PKEY_CTX,
236         type_: *const EVP_MD,
237         e: *mut ENGINE,
238         pkey: *mut EVP_PKEY,
239     ) -> c_int;
240 }
241 cfg_if! {
242     if #[cfg(ossl300)] {
243         extern "C" {
244             pub fn EVP_DigestVerifyUpdate(
245                 ctx: *mut EVP_MD_CTX,
246                 data: *const c_void,
247                 dsize: size_t,
248             ) -> c_int;
249         }
250     } else {
251         #[inline]
252         pub unsafe fn EVP_DigestVerifyUpdate(
253             ctx: *mut EVP_MD_CTX,
254             data: *const c_void,
255             dsize: size_t,
256         ) -> c_int {
257             EVP_DigestUpdate(ctx, data, dsize)
258         }
259     }
260 }
261 extern "C" {
EVP_SealInit( ctx: *mut EVP_CIPHER_CTX, type_: *const EVP_CIPHER, ek: *mut *mut c_uchar, ekl: *mut c_int, iv: *mut c_uchar, pubk: *mut *mut EVP_PKEY, npubk: c_int, ) -> c_int262     pub fn EVP_SealInit(
263         ctx: *mut EVP_CIPHER_CTX,
264         type_: *const EVP_CIPHER,
265         ek: *mut *mut c_uchar,
266         ekl: *mut c_int,
267         iv: *mut c_uchar,
268         pubk: *mut *mut EVP_PKEY,
269         npubk: c_int,
270     ) -> c_int;
EVP_SealFinal(ctx: *mut EVP_CIPHER_CTX, out: *mut c_uchar, outl: *mut c_int) -> c_int271     pub fn EVP_SealFinal(ctx: *mut EVP_CIPHER_CTX, out: *mut c_uchar, outl: *mut c_int) -> c_int;
EVP_EncryptInit_ex( ctx: *mut EVP_CIPHER_CTX, cipher: *const EVP_CIPHER, impl_: *mut ENGINE, key: *const c_uchar, iv: *const c_uchar, ) -> c_int272     pub fn EVP_EncryptInit_ex(
273         ctx: *mut EVP_CIPHER_CTX,
274         cipher: *const EVP_CIPHER,
275         impl_: *mut ENGINE,
276         key: *const c_uchar,
277         iv: *const c_uchar,
278     ) -> c_int;
EVP_EncryptUpdate( ctx: *mut EVP_CIPHER_CTX, out: *mut c_uchar, outl: *mut c_int, in_: *const u8, inl: c_int, ) -> c_int279     pub fn EVP_EncryptUpdate(
280         ctx: *mut EVP_CIPHER_CTX,
281         out: *mut c_uchar,
282         outl: *mut c_int,
283         in_: *const u8,
284         inl: c_int,
285     ) -> c_int;
EVP_EncryptFinal_ex( ctx: *mut EVP_CIPHER_CTX, out: *mut c_uchar, outl: *mut c_int, ) -> c_int286     pub fn EVP_EncryptFinal_ex(
287         ctx: *mut EVP_CIPHER_CTX,
288         out: *mut c_uchar,
289         outl: *mut c_int,
290     ) -> c_int;
EVP_OpenInit( ctx: *mut EVP_CIPHER_CTX, type_: *const EVP_CIPHER, ek: *const c_uchar, ekl: c_int, iv: *const c_uchar, priv_: *mut EVP_PKEY, ) -> c_int291     pub fn EVP_OpenInit(
292         ctx: *mut EVP_CIPHER_CTX,
293         type_: *const EVP_CIPHER,
294         ek: *const c_uchar,
295         ekl: c_int,
296         iv: *const c_uchar,
297         priv_: *mut EVP_PKEY,
298     ) -> c_int;
EVP_OpenFinal(ctx: *mut EVP_CIPHER_CTX, out: *mut c_uchar, outl: *mut c_int) -> c_int299     pub fn EVP_OpenFinal(ctx: *mut EVP_CIPHER_CTX, out: *mut c_uchar, outl: *mut c_int) -> c_int;
EVP_DecryptInit_ex( ctx: *mut EVP_CIPHER_CTX, cipher: *const EVP_CIPHER, impl_: *mut ENGINE, key: *const c_uchar, iv: *const c_uchar, ) -> c_int300     pub fn EVP_DecryptInit_ex(
301         ctx: *mut EVP_CIPHER_CTX,
302         cipher: *const EVP_CIPHER,
303         impl_: *mut ENGINE,
304         key: *const c_uchar,
305         iv: *const c_uchar,
306     ) -> c_int;
EVP_DecryptUpdate( ctx: *mut EVP_CIPHER_CTX, out: *mut c_uchar, outl: *mut c_int, in_: *const u8, inl: c_int, ) -> c_int307     pub fn EVP_DecryptUpdate(
308         ctx: *mut EVP_CIPHER_CTX,
309         out: *mut c_uchar,
310         outl: *mut c_int,
311         in_: *const u8,
312         inl: c_int,
313     ) -> c_int;
EVP_DecryptFinal_ex( ctx: *mut EVP_CIPHER_CTX, outm: *mut c_uchar, outl: *mut c_int, ) -> c_int314     pub fn EVP_DecryptFinal_ex(
315         ctx: *mut EVP_CIPHER_CTX,
316         outm: *mut c_uchar,
317         outl: *mut c_int,
318     ) -> c_int;
319 }
320 cfg_if! {
321     if #[cfg(ossl300)] {
322         extern "C" {
323             pub fn EVP_PKEY_get_size(pkey: *const EVP_PKEY) -> c_int;
324         }
325 
326         #[inline]
327         pub unsafe fn EVP_PKEY_size(pkey: *const EVP_PKEY) -> c_int {
328             EVP_PKEY_get_size(pkey)
329         }
330     } else {
331         const_ptr_api! {
332             extern "C" {
333                 pub fn EVP_PKEY_size(pkey: #[const_ptr_if(any(ossl111b, libressl280))] EVP_PKEY) -> c_int;
334             }
335         }
336     }
337 }
338 cfg_if! {
339     if #[cfg(ossl111)] {
340         extern "C" {
341             pub fn EVP_DigestSign(
342                 ctx: *mut EVP_MD_CTX,
343                 sigret: *mut c_uchar,
344                 siglen: *mut size_t,
345                 tbs: *const c_uchar,
346                 tbslen: size_t
347             ) -> c_int;
348 
349             pub fn EVP_DigestVerify(
350                 ctx: *mut EVP_MD_CTX,
351                 sigret: *const c_uchar,
352                 siglen: size_t,
353                 tbs: *const c_uchar,
354                 tbslen: size_t
355             ) -> c_int;
356         }
357     }
358 }
359 const_ptr_api! {
360     extern "C" {
361         pub fn EVP_DigestVerifyFinal(
362             ctx: *mut EVP_MD_CTX,
363             sigret: #[const_ptr_if(any(ossl102, libressl280))] c_uchar,
364             siglen: size_t,
365         ) -> c_int;
366     }
367 }
368 
369 extern "C" {
EVP_CIPHER_CTX_new() -> *mut EVP_CIPHER_CTX370     pub fn EVP_CIPHER_CTX_new() -> *mut EVP_CIPHER_CTX;
EVP_CIPHER_CTX_free(ctx: *mut EVP_CIPHER_CTX)371     pub fn EVP_CIPHER_CTX_free(ctx: *mut EVP_CIPHER_CTX);
EVP_MD_CTX_copy_ex(dst: *mut EVP_MD_CTX, src: *const EVP_MD_CTX) -> c_int372     pub fn EVP_MD_CTX_copy_ex(dst: *mut EVP_MD_CTX, src: *const EVP_MD_CTX) -> c_int;
EVP_CIPHER_CTX_set_key_length(ctx: *mut EVP_CIPHER_CTX, keylen: c_int) -> c_int373     pub fn EVP_CIPHER_CTX_set_key_length(ctx: *mut EVP_CIPHER_CTX, keylen: c_int) -> c_int;
EVP_CIPHER_CTX_set_padding(ctx: *mut EVP_CIPHER_CTX, padding: c_int) -> c_int374     pub fn EVP_CIPHER_CTX_set_padding(ctx: *mut EVP_CIPHER_CTX, padding: c_int) -> c_int;
EVP_CIPHER_CTX_ctrl( ctx: *mut EVP_CIPHER_CTX, type_: c_int, arg: c_int, ptr: *mut c_void, ) -> c_int375     pub fn EVP_CIPHER_CTX_ctrl(
376         ctx: *mut EVP_CIPHER_CTX,
377         type_: c_int,
378         arg: c_int,
379         ptr: *mut c_void,
380     ) -> c_int;
EVP_CIPHER_CTX_rand_key(ctx: *mut EVP_CIPHER_CTX, key: *mut c_uchar) -> c_int381     pub fn EVP_CIPHER_CTX_rand_key(ctx: *mut EVP_CIPHER_CTX, key: *mut c_uchar) -> c_int;
382 
EVP_md_null() -> *const EVP_MD383     pub fn EVP_md_null() -> *const EVP_MD;
EVP_md5() -> *const EVP_MD384     pub fn EVP_md5() -> *const EVP_MD;
EVP_sha1() -> *const EVP_MD385     pub fn EVP_sha1() -> *const EVP_MD;
EVP_sha224() -> *const EVP_MD386     pub fn EVP_sha224() -> *const EVP_MD;
EVP_sha256() -> *const EVP_MD387     pub fn EVP_sha256() -> *const EVP_MD;
EVP_sha384() -> *const EVP_MD388     pub fn EVP_sha384() -> *const EVP_MD;
EVP_sha512() -> *const EVP_MD389     pub fn EVP_sha512() -> *const EVP_MD;
390     #[cfg(ossl111)]
EVP_sha3_224() -> *const EVP_MD391     pub fn EVP_sha3_224() -> *const EVP_MD;
392     #[cfg(ossl111)]
EVP_sha3_256() -> *const EVP_MD393     pub fn EVP_sha3_256() -> *const EVP_MD;
394     #[cfg(ossl111)]
EVP_sha3_384() -> *const EVP_MD395     pub fn EVP_sha3_384() -> *const EVP_MD;
396     #[cfg(ossl111)]
EVP_sha3_512() -> *const EVP_MD397     pub fn EVP_sha3_512() -> *const EVP_MD;
398     #[cfg(ossl111)]
EVP_shake128() -> *const EVP_MD399     pub fn EVP_shake128() -> *const EVP_MD;
400     #[cfg(ossl111)]
EVP_shake256() -> *const EVP_MD401     pub fn EVP_shake256() -> *const EVP_MD;
EVP_ripemd160() -> *const EVP_MD402     pub fn EVP_ripemd160() -> *const EVP_MD;
403     #[cfg(all(any(ossl111, libressl291), not(osslconf = "OPENSSL_NO_SM3")))]
EVP_sm3() -> *const EVP_MD404     pub fn EVP_sm3() -> *const EVP_MD;
EVP_des_ecb() -> *const EVP_CIPHER405     pub fn EVP_des_ecb() -> *const EVP_CIPHER;
EVP_des_ede3() -> *const EVP_CIPHER406     pub fn EVP_des_ede3() -> *const EVP_CIPHER;
EVP_des_ede3_cbc() -> *const EVP_CIPHER407     pub fn EVP_des_ede3_cbc() -> *const EVP_CIPHER;
EVP_des_ede3_cfb64() -> *const EVP_CIPHER408     pub fn EVP_des_ede3_cfb64() -> *const EVP_CIPHER;
EVP_des_cbc() -> *const EVP_CIPHER409     pub fn EVP_des_cbc() -> *const EVP_CIPHER;
EVP_rc4() -> *const EVP_CIPHER410     pub fn EVP_rc4() -> *const EVP_CIPHER;
EVP_bf_ecb() -> *const EVP_CIPHER411     pub fn EVP_bf_ecb() -> *const EVP_CIPHER;
EVP_bf_cbc() -> *const EVP_CIPHER412     pub fn EVP_bf_cbc() -> *const EVP_CIPHER;
EVP_bf_cfb64() -> *const EVP_CIPHER413     pub fn EVP_bf_cfb64() -> *const EVP_CIPHER;
EVP_bf_ofb() -> *const EVP_CIPHER414     pub fn EVP_bf_ofb() -> *const EVP_CIPHER;
EVP_aes_128_ecb() -> *const EVP_CIPHER415     pub fn EVP_aes_128_ecb() -> *const EVP_CIPHER;
EVP_aes_128_cbc() -> *const EVP_CIPHER416     pub fn EVP_aes_128_cbc() -> *const EVP_CIPHER;
EVP_aes_128_cfb1() -> *const EVP_CIPHER417     pub fn EVP_aes_128_cfb1() -> *const EVP_CIPHER;
EVP_aes_128_cfb8() -> *const EVP_CIPHER418     pub fn EVP_aes_128_cfb8() -> *const EVP_CIPHER;
EVP_aes_128_cfb128() -> *const EVP_CIPHER419     pub fn EVP_aes_128_cfb128() -> *const EVP_CIPHER;
EVP_aes_128_ctr() -> *const EVP_CIPHER420     pub fn EVP_aes_128_ctr() -> *const EVP_CIPHER;
EVP_aes_128_ccm() -> *const EVP_CIPHER421     pub fn EVP_aes_128_ccm() -> *const EVP_CIPHER;
EVP_aes_128_gcm() -> *const EVP_CIPHER422     pub fn EVP_aes_128_gcm() -> *const EVP_CIPHER;
EVP_aes_128_xts() -> *const EVP_CIPHER423     pub fn EVP_aes_128_xts() -> *const EVP_CIPHER;
EVP_aes_128_ofb() -> *const EVP_CIPHER424     pub fn EVP_aes_128_ofb() -> *const EVP_CIPHER;
425     #[cfg(ossl110)]
EVP_aes_128_ocb() -> *const EVP_CIPHER426     pub fn EVP_aes_128_ocb() -> *const EVP_CIPHER;
EVP_aes_192_ecb() -> *const EVP_CIPHER427     pub fn EVP_aes_192_ecb() -> *const EVP_CIPHER;
EVP_aes_192_cbc() -> *const EVP_CIPHER428     pub fn EVP_aes_192_cbc() -> *const EVP_CIPHER;
EVP_aes_192_cfb1() -> *const EVP_CIPHER429     pub fn EVP_aes_192_cfb1() -> *const EVP_CIPHER;
EVP_aes_192_cfb8() -> *const EVP_CIPHER430     pub fn EVP_aes_192_cfb8() -> *const EVP_CIPHER;
EVP_aes_192_cfb128() -> *const EVP_CIPHER431     pub fn EVP_aes_192_cfb128() -> *const EVP_CIPHER;
EVP_aes_192_ctr() -> *const EVP_CIPHER432     pub fn EVP_aes_192_ctr() -> *const EVP_CIPHER;
EVP_aes_192_ccm() -> *const EVP_CIPHER433     pub fn EVP_aes_192_ccm() -> *const EVP_CIPHER;
EVP_aes_192_gcm() -> *const EVP_CIPHER434     pub fn EVP_aes_192_gcm() -> *const EVP_CIPHER;
EVP_aes_192_ofb() -> *const EVP_CIPHER435     pub fn EVP_aes_192_ofb() -> *const EVP_CIPHER;
436     #[cfg(ossl110)]
EVP_aes_192_ocb() -> *const EVP_CIPHER437     pub fn EVP_aes_192_ocb() -> *const EVP_CIPHER;
EVP_aes_256_ecb() -> *const EVP_CIPHER438     pub fn EVP_aes_256_ecb() -> *const EVP_CIPHER;
EVP_aes_256_cbc() -> *const EVP_CIPHER439     pub fn EVP_aes_256_cbc() -> *const EVP_CIPHER;
EVP_aes_256_cfb1() -> *const EVP_CIPHER440     pub fn EVP_aes_256_cfb1() -> *const EVP_CIPHER;
EVP_aes_256_cfb8() -> *const EVP_CIPHER441     pub fn EVP_aes_256_cfb8() -> *const EVP_CIPHER;
EVP_aes_256_cfb128() -> *const EVP_CIPHER442     pub fn EVP_aes_256_cfb128() -> *const EVP_CIPHER;
EVP_aes_256_ctr() -> *const EVP_CIPHER443     pub fn EVP_aes_256_ctr() -> *const EVP_CIPHER;
EVP_aes_256_ccm() -> *const EVP_CIPHER444     pub fn EVP_aes_256_ccm() -> *const EVP_CIPHER;
EVP_aes_256_gcm() -> *const EVP_CIPHER445     pub fn EVP_aes_256_gcm() -> *const EVP_CIPHER;
EVP_aes_256_xts() -> *const EVP_CIPHER446     pub fn EVP_aes_256_xts() -> *const EVP_CIPHER;
EVP_aes_256_ofb() -> *const EVP_CIPHER447     pub fn EVP_aes_256_ofb() -> *const EVP_CIPHER;
448     #[cfg(ossl110)]
EVP_aes_256_ocb() -> *const EVP_CIPHER449     pub fn EVP_aes_256_ocb() -> *const EVP_CIPHER;
450     #[cfg(all(ossl110, not(osslconf = "OPENSSL_NO_CHACHA")))]
EVP_chacha20() -> *const ::EVP_CIPHER451     pub fn EVP_chacha20() -> *const ::EVP_CIPHER;
452     #[cfg(all(ossl110, not(osslconf = "OPENSSL_NO_CHACHA")))]
EVP_chacha20_poly1305() -> *const ::EVP_CIPHER453     pub fn EVP_chacha20_poly1305() -> *const ::EVP_CIPHER;
454     #[cfg(not(osslconf = "OPENSSL_NO_SEED"))]
EVP_seed_cbc() -> *const EVP_CIPHER455     pub fn EVP_seed_cbc() -> *const EVP_CIPHER;
456     #[cfg(not(osslconf = "OPENSSL_NO_SEED"))]
EVP_seed_cfb128() -> *const EVP_CIPHER457     pub fn EVP_seed_cfb128() -> *const EVP_CIPHER;
458     #[cfg(not(osslconf = "OPENSSL_NO_SEED"))]
EVP_seed_ecb() -> *const EVP_CIPHER459     pub fn EVP_seed_ecb() -> *const EVP_CIPHER;
460     #[cfg(not(osslconf = "OPENSSL_NO_SEED"))]
EVP_seed_ofb() -> *const EVP_CIPHER461     pub fn EVP_seed_ofb() -> *const EVP_CIPHER;
462 
463     #[cfg(not(ossl110))]
OPENSSL_add_all_algorithms_noconf()464     pub fn OPENSSL_add_all_algorithms_noconf();
465 
EVP_get_digestbyname(name: *const c_char) -> *const EVP_MD466     pub fn EVP_get_digestbyname(name: *const c_char) -> *const EVP_MD;
EVP_get_cipherbyname(name: *const c_char) -> *const EVP_CIPHER467     pub fn EVP_get_cipherbyname(name: *const c_char) -> *const EVP_CIPHER;
468 }
469 
470 cfg_if! {
471     if #[cfg(ossl300)] {
472         extern "C" {
473             pub fn EVP_PKEY_get_id(pkey: *const EVP_PKEY) -> c_int;
474             pub fn EVP_PKEY_get_bits(key: *const EVP_PKEY) -> c_int;
475         }
476 
477         #[inline]
478         pub unsafe fn EVP_PKEY_id(pkey: *const EVP_PKEY) -> c_int {
479             EVP_PKEY_get_id(pkey)
480         }
481 
482         #[inline]
483         pub unsafe fn EVP_PKEY_bits(pkey: *const EVP_PKEY) -> c_int {
484             EVP_PKEY_get_bits(pkey)
485         }
486     } else {
487         extern "C" {
488             pub fn EVP_PKEY_id(pkey: *const EVP_PKEY) -> c_int;
489         }
490         const_ptr_api! {
491             extern "C" {
492                 pub fn EVP_PKEY_bits(key: #[const_ptr_if(any(ossl110, libressl280))] EVP_PKEY) -> c_int;
493             }
494         }
495     }
496 }
497 extern "C" {
EVP_PKEY_assign(pkey: *mut EVP_PKEY, typ: c_int, key: *mut c_void) -> c_int498     pub fn EVP_PKEY_assign(pkey: *mut EVP_PKEY, typ: c_int, key: *mut c_void) -> c_int;
499 
EVP_PKEY_set1_RSA(k: *mut EVP_PKEY, r: *mut RSA) -> c_int500     pub fn EVP_PKEY_set1_RSA(k: *mut EVP_PKEY, r: *mut RSA) -> c_int;
EVP_PKEY_get1_RSA(k: *mut EVP_PKEY) -> *mut RSA501     pub fn EVP_PKEY_get1_RSA(k: *mut EVP_PKEY) -> *mut RSA;
EVP_PKEY_get1_DSA(k: *mut EVP_PKEY) -> *mut DSA502     pub fn EVP_PKEY_get1_DSA(k: *mut EVP_PKEY) -> *mut DSA;
EVP_PKEY_get1_DH(k: *mut EVP_PKEY) -> *mut DH503     pub fn EVP_PKEY_get1_DH(k: *mut EVP_PKEY) -> *mut DH;
EVP_PKEY_get1_EC_KEY(k: *mut EVP_PKEY) -> *mut EC_KEY504     pub fn EVP_PKEY_get1_EC_KEY(k: *mut EVP_PKEY) -> *mut EC_KEY;
505 
EVP_PKEY_new() -> *mut EVP_PKEY506     pub fn EVP_PKEY_new() -> *mut EVP_PKEY;
EVP_PKEY_free(k: *mut EVP_PKEY)507     pub fn EVP_PKEY_free(k: *mut EVP_PKEY);
508     #[cfg(any(ossl110, libressl270))]
EVP_PKEY_up_ref(pkey: *mut EVP_PKEY) -> c_int509     pub fn EVP_PKEY_up_ref(pkey: *mut EVP_PKEY) -> c_int;
510 
d2i_AutoPrivateKey( a: *mut *mut EVP_PKEY, pp: *mut *const c_uchar, length: c_long, ) -> *mut EVP_PKEY511     pub fn d2i_AutoPrivateKey(
512         a: *mut *mut EVP_PKEY,
513         pp: *mut *const c_uchar,
514         length: c_long,
515     ) -> *mut EVP_PKEY;
516 
EVP_PKEY_cmp(a: *const EVP_PKEY, b: *const EVP_PKEY) -> c_int517     pub fn EVP_PKEY_cmp(a: *const EVP_PKEY, b: *const EVP_PKEY) -> c_int;
518 
EVP_PKEY_copy_parameters(to: *mut EVP_PKEY, from: *const EVP_PKEY) -> c_int519     pub fn EVP_PKEY_copy_parameters(to: *mut EVP_PKEY, from: *const EVP_PKEY) -> c_int;
520 
PKCS5_PBKDF2_HMAC_SHA1( pass: *const c_char, passlen: c_int, salt: *const u8, saltlen: c_int, iter: c_int, keylen: c_int, out: *mut u8, ) -> c_int521     pub fn PKCS5_PBKDF2_HMAC_SHA1(
522         pass: *const c_char,
523         passlen: c_int,
524         salt: *const u8,
525         saltlen: c_int,
526         iter: c_int,
527         keylen: c_int,
528         out: *mut u8,
529     ) -> c_int;
PKCS5_PBKDF2_HMAC( pass: *const c_char, passlen: c_int, salt: *const c_uchar, saltlen: c_int, iter: c_int, digest: *const EVP_MD, keylen: c_int, out: *mut u8, ) -> c_int530     pub fn PKCS5_PBKDF2_HMAC(
531         pass: *const c_char,
532         passlen: c_int,
533         salt: *const c_uchar,
534         saltlen: c_int,
535         iter: c_int,
536         digest: *const EVP_MD,
537         keylen: c_int,
538         out: *mut u8,
539     ) -> c_int;
540 
541     #[cfg(ossl110)]
EVP_PBE_scrypt( pass: *const c_char, passlen: size_t, salt: *const c_uchar, saltlen: size_t, N: u64, r: u64, p: u64, maxmem: u64, key: *mut c_uchar, keylen: size_t, ) -> c_int542     pub fn EVP_PBE_scrypt(
543         pass: *const c_char,
544         passlen: size_t,
545         salt: *const c_uchar,
546         saltlen: size_t,
547         N: u64,
548         r: u64,
549         p: u64,
550         maxmem: u64,
551         key: *mut c_uchar,
552         keylen: size_t,
553     ) -> c_int;
554 }
555 
556 pub const EVP_PKEY_OP_KEYGEN: c_int = 1 << 2;
557 cfg_if! {
558     if #[cfg(ossl300)] {
559         pub const EVP_PKEY_OP_SIGN: c_int = 1 << 4;
560         pub const EVP_PKEY_OP_VERIFY: c_int = 1 << 5;
561         pub const EVP_PKEY_OP_VERIFYRECOVER: c_int = 1 << 6;
562         pub const EVP_PKEY_OP_SIGNCTX: c_int = 1 << 7;
563         pub const EVP_PKEY_OP_VERIFYCTX: c_int = 1 << 8;
564         pub const EVP_PKEY_OP_ENCRYPT: c_int = 1 << 9;
565         pub const EVP_PKEY_OP_DECRYPT: c_int = 1 << 10;
566         pub const EVP_PKEY_OP_DERIVE: c_int = 1 << 11;
567     } else {
568         pub const EVP_PKEY_OP_SIGN: c_int = 1 << 3;
569         pub const EVP_PKEY_OP_VERIFY: c_int = 1 << 4;
570         pub const EVP_PKEY_OP_VERIFYRECOVER: c_int = 1 << 5;
571         pub const EVP_PKEY_OP_SIGNCTX: c_int = 1 << 6;
572         pub const EVP_PKEY_OP_VERIFYCTX: c_int = 1 << 7;
573         pub const EVP_PKEY_OP_ENCRYPT: c_int = 1 << 8;
574         pub const EVP_PKEY_OP_DECRYPT: c_int = 1 << 9;
575         pub const EVP_PKEY_OP_DERIVE: c_int = 1 << 10;
576     }
577 }
578 
579 pub const EVP_PKEY_OP_TYPE_SIG: c_int = EVP_PKEY_OP_SIGN
580     | EVP_PKEY_OP_VERIFY
581     | EVP_PKEY_OP_VERIFYRECOVER
582     | EVP_PKEY_OP_SIGNCTX
583     | EVP_PKEY_OP_VERIFYCTX;
584 
585 pub const EVP_PKEY_OP_TYPE_CRYPT: c_int = EVP_PKEY_OP_ENCRYPT | EVP_PKEY_OP_DECRYPT;
586 
587 pub const EVP_PKEY_CTRL_SET_MAC_KEY: c_int = 6;
588 
589 pub const EVP_PKEY_CTRL_CIPHER: c_int = 12;
590 
591 pub const EVP_PKEY_ALG_CTRL: c_int = 0x1000;
592 
593 #[cfg(ossl111)]
594 pub const EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND: c_int = 0;
595 
596 #[cfg(ossl111)]
597 pub const EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY: c_int = 1;
598 
599 #[cfg(ossl111)]
600 pub const EVP_PKEY_HKDEF_MODE_EXPAND_ONLY: c_int = 2;
601 
602 #[cfg(ossl110)]
603 pub const EVP_PKEY_CTRL_HKDF_MD: c_int = EVP_PKEY_ALG_CTRL + 3;
604 
605 #[cfg(ossl110)]
606 pub const EVP_PKEY_CTRL_HKDF_SALT: c_int = EVP_PKEY_ALG_CTRL + 4;
607 
608 #[cfg(ossl110)]
609 pub const EVP_PKEY_CTRL_HKDF_KEY: c_int = EVP_PKEY_ALG_CTRL + 5;
610 
611 #[cfg(ossl110)]
612 pub const EVP_PKEY_CTRL_HKDF_INFO: c_int = EVP_PKEY_ALG_CTRL + 6;
613 
614 #[cfg(ossl111)]
615 pub const EVP_PKEY_CTRL_HKDF_MODE: c_int = EVP_PKEY_ALG_CTRL + 7;
616 
617 extern "C" {
EVP_PKEY_CTX_new(k: *mut EVP_PKEY, e: *mut ENGINE) -> *mut EVP_PKEY_CTX618     pub fn EVP_PKEY_CTX_new(k: *mut EVP_PKEY, e: *mut ENGINE) -> *mut EVP_PKEY_CTX;
EVP_PKEY_CTX_new_id(id: c_int, e: *mut ENGINE) -> *mut EVP_PKEY_CTX619     pub fn EVP_PKEY_CTX_new_id(id: c_int, e: *mut ENGINE) -> *mut EVP_PKEY_CTX;
EVP_PKEY_CTX_free(ctx: *mut EVP_PKEY_CTX)620     pub fn EVP_PKEY_CTX_free(ctx: *mut EVP_PKEY_CTX);
621 
EVP_PKEY_CTX_ctrl( ctx: *mut EVP_PKEY_CTX, keytype: c_int, optype: c_int, cmd: c_int, p1: c_int, p2: *mut c_void, ) -> c_int622     pub fn EVP_PKEY_CTX_ctrl(
623         ctx: *mut EVP_PKEY_CTX,
624         keytype: c_int,
625         optype: c_int,
626         cmd: c_int,
627         p1: c_int,
628         p2: *mut c_void,
629     ) -> c_int;
630 
EVP_PKEY_new_mac_key( type_: c_int, e: *mut ENGINE, key: *const c_uchar, keylen: c_int, ) -> *mut EVP_PKEY631     pub fn EVP_PKEY_new_mac_key(
632         type_: c_int,
633         e: *mut ENGINE,
634         key: *const c_uchar,
635         keylen: c_int,
636     ) -> *mut EVP_PKEY;
637 
EVP_PKEY_derive_init(ctx: *mut EVP_PKEY_CTX) -> c_int638     pub fn EVP_PKEY_derive_init(ctx: *mut EVP_PKEY_CTX) -> c_int;
EVP_PKEY_derive_set_peer(ctx: *mut EVP_PKEY_CTX, peer: *mut EVP_PKEY) -> c_int639     pub fn EVP_PKEY_derive_set_peer(ctx: *mut EVP_PKEY_CTX, peer: *mut EVP_PKEY) -> c_int;
EVP_PKEY_derive(ctx: *mut EVP_PKEY_CTX, key: *mut c_uchar, size: *mut size_t) -> c_int640     pub fn EVP_PKEY_derive(ctx: *mut EVP_PKEY_CTX, key: *mut c_uchar, size: *mut size_t) -> c_int;
641 
642     #[cfg(ossl300)]
EVP_PKEY_Q_keygen( libctx: *mut OSSL_LIB_CTX, propq: *const c_char, type_: *const c_char, ... ) -> *mut EVP_PKEY643     pub fn EVP_PKEY_Q_keygen(
644         libctx: *mut OSSL_LIB_CTX,
645         propq: *const c_char,
646         type_: *const c_char,
647         ...
648     ) -> *mut EVP_PKEY;
EVP_PKEY_keygen_init(ctx: *mut EVP_PKEY_CTX) -> c_int649     pub fn EVP_PKEY_keygen_init(ctx: *mut EVP_PKEY_CTX) -> c_int;
EVP_PKEY_keygen(ctx: *mut EVP_PKEY_CTX, key: *mut *mut EVP_PKEY) -> c_int650     pub fn EVP_PKEY_keygen(ctx: *mut EVP_PKEY_CTX, key: *mut *mut EVP_PKEY) -> c_int;
651 
EVP_PKEY_sign_init(ctx: *mut EVP_PKEY_CTX) -> c_int652     pub fn EVP_PKEY_sign_init(ctx: *mut EVP_PKEY_CTX) -> c_int;
EVP_PKEY_sign( ctx: *mut EVP_PKEY_CTX, sig: *mut c_uchar, siglen: *mut size_t, tbs: *const c_uchar, tbslen: size_t, ) -> c_int653     pub fn EVP_PKEY_sign(
654         ctx: *mut EVP_PKEY_CTX,
655         sig: *mut c_uchar,
656         siglen: *mut size_t,
657         tbs: *const c_uchar,
658         tbslen: size_t,
659     ) -> c_int;
EVP_PKEY_verify_init(ctx: *mut EVP_PKEY_CTX) -> c_int660     pub fn EVP_PKEY_verify_init(ctx: *mut EVP_PKEY_CTX) -> c_int;
EVP_PKEY_verify( ctx: *mut EVP_PKEY_CTX, sig: *const c_uchar, siglen: size_t, tbs: *const c_uchar, tbslen: size_t, ) -> c_int661     pub fn EVP_PKEY_verify(
662         ctx: *mut EVP_PKEY_CTX,
663         sig: *const c_uchar,
664         siglen: size_t,
665         tbs: *const c_uchar,
666         tbslen: size_t,
667     ) -> c_int;
EVP_PKEY_encrypt_init(ctx: *mut EVP_PKEY_CTX) -> c_int668     pub fn EVP_PKEY_encrypt_init(ctx: *mut EVP_PKEY_CTX) -> c_int;
EVP_PKEY_encrypt( ctx: *mut EVP_PKEY_CTX, pout: *mut c_uchar, poutlen: *mut size_t, pin: *const c_uchar, pinlen: size_t, ) -> c_int669     pub fn EVP_PKEY_encrypt(
670         ctx: *mut EVP_PKEY_CTX,
671         pout: *mut c_uchar,
672         poutlen: *mut size_t,
673         pin: *const c_uchar,
674         pinlen: size_t,
675     ) -> c_int;
EVP_PKEY_decrypt_init(ctx: *mut EVP_PKEY_CTX) -> c_int676     pub fn EVP_PKEY_decrypt_init(ctx: *mut EVP_PKEY_CTX) -> c_int;
EVP_PKEY_decrypt( ctx: *mut EVP_PKEY_CTX, pout: *mut c_uchar, poutlen: *mut size_t, pin: *const c_uchar, pinlen: size_t, ) -> c_int677     pub fn EVP_PKEY_decrypt(
678         ctx: *mut EVP_PKEY_CTX,
679         pout: *mut c_uchar,
680         poutlen: *mut size_t,
681         pin: *const c_uchar,
682         pinlen: size_t,
683     ) -> c_int;
684 }
685 
686 // HKDF Functions
687 cfg_if! {
688     if #[cfg(ossl300)] {
689         extern "C" {
690             pub fn EVP_PKEY_CTX_set_hkdf_mode(ctx: *mut EVP_PKEY_CTX, mode: c_int) -> c_int;
691             pub fn EVP_PKEY_CTX_set_hkdf_md(ctx: *mut EVP_PKEY_CTX, md: *const EVP_MD) -> c_int;
692             pub fn EVP_PKEY_CTX_set1_hkdf_salt(
693                 ctx: *mut EVP_PKEY_CTX,
694                 salt: *const u8,
695                 saltlen: c_int,
696             ) -> c_int;
697             pub fn EVP_PKEY_CTX_set1_hkdf_key(
698                 ctx: *mut EVP_PKEY_CTX,
699                 key: *const u8,
700                 keylen: c_int,
701             ) -> c_int;
702             pub fn EVP_PKEY_CTX_add1_hkdf_info(
703                 ctx: *mut EVP_PKEY_CTX,
704                 info: *const u8,
705                 infolen: c_int,
706             ) -> c_int;
707         }
708     } else {
709         #[cfg(ossl111)]
710         pub unsafe fn EVP_PKEY_CTX_set_hkdf_mode(ctx: *mut EVP_PKEY_CTX, mode: c_int) -> c_int {
711             EVP_PKEY_CTX_ctrl(
712                 ctx,
713                 -1,
714                 EVP_PKEY_OP_DERIVE,
715                 EVP_PKEY_CTRL_HKDF_MODE,
716                 mode, std::ptr::null_mut(),
717             )
718         }
719 
720         #[cfg(ossl110)]
721         pub unsafe fn EVP_PKEY_CTX_set_hkdf_md(ctx: *mut EVP_PKEY_CTX, md: *const EVP_MD) -> c_int {
722             EVP_PKEY_CTX_ctrl(
723                 ctx,
724                 -1,
725                 EVP_PKEY_OP_DERIVE,
726                 EVP_PKEY_CTRL_HKDF_MD,
727                 0,
728                 md as *mut c_void,
729             )
730         }
731 
732         #[cfg(ossl110)]
733         pub unsafe fn EVP_PKEY_CTX_set1_hkdf_salt(
734             ctx: *mut EVP_PKEY_CTX,
735             salt: *const u8,
736             saltlen: c_int,
737         ) -> c_int {
738             EVP_PKEY_CTX_ctrl(
739                 ctx,
740                 -1,
741                 EVP_PKEY_OP_DERIVE,
742                 EVP_PKEY_CTRL_HKDF_SALT,
743                 saltlen,
744                 salt as *mut c_void,
745             )
746         }
747 
748         #[cfg(ossl110)]
749         pub unsafe fn EVP_PKEY_CTX_set1_hkdf_key(
750             ctx: *mut EVP_PKEY_CTX,
751             key: *const u8,
752             keylen: c_int,
753         ) -> c_int {
754             EVP_PKEY_CTX_ctrl(
755                 ctx,
756                 -1,
757                 EVP_PKEY_OP_DERIVE,
758                 EVP_PKEY_CTRL_HKDF_KEY,
759                 keylen,
760                 key as *mut c_void,
761             )
762         }
763 
764         #[cfg(ossl110)]
765         pub unsafe fn EVP_PKEY_CTX_add1_hkdf_info(
766             ctx: *mut EVP_PKEY_CTX,
767             info: *const u8,
768             infolen: c_int,
769         ) -> c_int {
770             EVP_PKEY_CTX_ctrl(
771                 ctx,
772                 -1,
773                 EVP_PKEY_OP_DERIVE,
774                 EVP_PKEY_CTRL_HKDF_INFO,
775                 infolen,
776                 info as *mut c_void,
777             )
778         }
779     }
780 }
781 
782 const_ptr_api! {
783     extern "C" {
784         pub fn EVP_PKCS82PKEY(p8: #[const_ptr_if(any(ossl110, libressl280))] PKCS8_PRIV_KEY_INFO) -> *mut EVP_PKEY;
785     }
786 }
787 
788 cfg_if! {
789     if #[cfg(any(ossl111))] {
790         extern "C" {
791             pub fn EVP_PKEY_get_raw_public_key(
792                 pkey: *const EVP_PKEY,
793                 ppub: *mut c_uchar,
794                 len: *mut size_t,
795             ) -> c_int;
796             pub fn EVP_PKEY_new_raw_public_key(
797                 ttype: c_int,
798                 e: *mut ENGINE,
799                 key: *const c_uchar,
800                 keylen: size_t,
801             ) -> *mut EVP_PKEY;
802             pub fn EVP_PKEY_get_raw_private_key(
803                 pkey: *const EVP_PKEY,
804                 ppriv: *mut c_uchar,
805                 len: *mut size_t,
806             ) -> c_int;
807             pub fn EVP_PKEY_new_raw_private_key(
808                 ttype: c_int,
809                 e: *mut ENGINE,
810                 key: *const c_uchar,
811                 keylen: size_t,
812             ) -> *mut EVP_PKEY;
813         }
814     }
815 }
816 
817 extern "C" {
EVP_EncodeBlock(dst: *mut c_uchar, src: *const c_uchar, src_len: c_int) -> c_int818     pub fn EVP_EncodeBlock(dst: *mut c_uchar, src: *const c_uchar, src_len: c_int) -> c_int;
EVP_DecodeBlock(dst: *mut c_uchar, src: *const c_uchar, src_len: c_int) -> c_int819     pub fn EVP_DecodeBlock(dst: *mut c_uchar, src: *const c_uchar, src_len: c_int) -> c_int;
820 }
821