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