Add wrappers for OSSL 3 encoders and decoders

openssl-sys/build/run_bindgen.rs

@@ -59,6 +59,10 @@ const INCLUDES: &str = "
 
 #if OPENSSL_VERSION_NUMBER >= 0x30000000
 #include <openssl/provider.h>
+#include <openssl/params.h>
+#include <openssl/param_build.h>
+#include <openssl/decoder.h>
+#include <openssl/encoder.h>
 #endif
 
 #if OPENSSL_VERSION_NUMBER >= 0x30200000

openssl-sys/src/evp.rs

@@ -341,3 +341,27 @@ pub unsafe fn EVP_PKEY_assign_DH(pkey: *mut EVP_PKEY, dh: *mut DH) -> c_int {
 pub unsafe fn EVP_PKEY_assign_EC_KEY(pkey: *mut EVP_PKEY, ec_key: *mut EC_KEY) -> c_int {
     EVP_PKEY_assign(pkey, EVP_PKEY_EC, ec_key as *mut c_void)
 }
+
+cfg_if! {
+    if #[cfg(ossl300)] {
+        // consts required for EVP_PKEY_fromdata selection value
+
+        // From <openssl/core_dispatch.h>
+        const OSSL_KEYMGMT_SELECT_PRIVATE_KEY: c_int = 0x01;
+        const OSSL_KEYMGMT_SELECT_PUBLIC_KEY: c_int = 0x02;
+        const OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS: c_int = 0x04;
+        const OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS: c_int = 0x80;
+        const OSSL_KEYMGMT_SELECT_ALL_PARAMETERS: c_int =
+            OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS | OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS;
+        const OSSL_KEYMGMT_SELECT_KEYPAIR: c_int =
+            OSSL_KEYMGMT_SELECT_PRIVATE_KEY | OSSL_KEYMGMT_SELECT_PUBLIC_KEY;
+        const OSSL_KEYMGMT_SELECT_ALL: c_int =
+            OSSL_KEYMGMT_SELECT_KEYPAIR | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS;
+
+        // From <openssl/evp.h>
+        pub const EVP_PKEY_KEY_PARAMETERS: c_int = OSSL_KEYMGMT_SELECT_ALL_PARAMETERS;
+        pub const EVP_PKEY_PRIVATE_KEY: c_int = EVP_PKEY_KEY_PARAMETERS | OSSL_KEYMGMT_SELECT_PRIVATE_KEY;
+        pub const EVP_PKEY_PUBLIC_KEY: c_int = EVP_PKEY_KEY_PARAMETERS | OSSL_KEYMGMT_SELECT_PUBLIC_KEY;
+        pub const EVP_PKEY_KEYPAIR: c_int = EVP_PKEY_PUBLIC_KEY | OSSL_KEYMGMT_SELECT_PRIVATE_KEY;
+    }
+}

openssl-sys/src/handwritten/decoder.rs

@@ -0,0 +1,53 @@
+use super::super::*;
+use libc::*;
+
+#[cfg(ossl300)]
+extern "C" {
+    pub fn OSSL_DECODER_CTX_new() -> *mut OSSL_DECODER_CTX;
+    pub fn OSSL_DECODER_CTX_free(ctx: *mut OSSL_DECODER_CTX);
+
+    pub fn OSSL_DECODER_CTX_new_for_pkey(
+        pkey: *mut *mut EVP_PKEY,
+        input_type: *const c_char,
+        input_struct: *const c_char,
+        keytype: *const c_char,
+        selection: c_int,
+        libctx: *mut OSSL_LIB_CTX,
+        propquery: *const c_char,
+    ) -> *mut OSSL_DECODER_CTX;
+
+    pub fn OSSL_DECODER_CTX_set_selection(ctx: *mut OSSL_DECODER_CTX, selection: c_int) -> c_int;
+    pub fn OSSL_DECODER_CTX_set_input_type(
+        ctx: *mut OSSL_DECODER_CTX,
+        input_type: *const c_char,
+    ) -> c_int;
+    pub fn OSSL_DECODER_CTX_set_input_structure(
+        ctx: *mut OSSL_DECODER_CTX,
+        input_structure: *const c_char,
+    ) -> c_int;
+
+    pub fn OSSL_DECODER_CTX_set_passphrase(
+        ctx: *mut OSSL_DECODER_CTX,
+        kstr: *const c_uchar,
+        klen: size_t,
+    ) -> c_int;
+    pub fn OSSL_DECODER_CTX_set_pem_password_cb(
+        ctx: *mut OSSL_DECODER_CTX,
+        cb: pem_password_cb,
+        cbarg: *mut c_void,
+    ) -> c_int;
+    pub fn OSSL_DECODER_CTX_set_passphrase_cb(
+        ctx: *mut OSSL_DECODER_CTX,
+        cb: OSSL_PASSPHRASE_CALLBACK,
+        cbarg: *mut c_void,
+    ) -> c_int;
+
+    pub fn OSSL_DECODER_from_bio(ctx: *mut OSSL_DECODER_CTX, b_in: *mut BIO) -> c_int;
+    #[cfg(not(osslconf = "OPENSSL_NO_STDIO"))]
+    pub fn OSSL_DECODER_from_fp(ctx: *mut OSSL_DECODER_CTX, fp: *mut FILE) -> c_int;
+    pub fn OSSL_DECODER_from_data(
+        ctx: *mut OSSL_DECODER_CTX,
+        pdata: *mut *const c_uchar,
+        pdata_len: *mut size_t,
+    ) -> c_int;
+}

openssl-sys/src/handwritten/encoder.rs

@@ -0,0 +1,56 @@
+use super::super::*;
+use libc::*;
+
+#[cfg(ossl300)]
+extern "C" {
+    pub fn OSSL_ENCODER_CTX_new() -> *mut OSSL_ENCODER_CTX;
+    pub fn OSSL_ENCODER_CTX_free(ctx: *mut OSSL_ENCODER_CTX);
+
+    pub fn OSSL_ENCODER_CTX_new_for_pkey(
+        pkey: *const EVP_PKEY,
+        selection: c_int,
+        output_type: *const c_char,
+        output_structure: *const c_char,
+        propquery: *const c_char,
+    ) -> *mut OSSL_ENCODER_CTX;
+
+    pub fn OSSL_ENCODER_CTX_set_selection(ctx: *mut OSSL_ENCODER_CTX, selection: c_int) -> c_int;
+    pub fn OSSL_ENCODER_CTX_set_output_type(
+        ctx: *mut OSSL_ENCODER_CTX,
+        output_type: *const c_char,
+    ) -> c_int;
+    pub fn OSSL_ENCODER_CTX_set_output_structure(
+        ctx: *mut OSSL_ENCODER_CTX,
+        output_structure: *const c_char,
+    ) -> c_int;
+
+    pub fn OSSL_ENCODER_CTX_set_cipher(
+        ctx: *mut OSSL_ENCODER_CTX,
+        cipher_name: *const c_char,
+        propquery: *const c_char,
+    ) -> c_int;
+    pub fn OSSL_ENCODER_CTX_set_passphrase(
+        ctx: *mut OSSL_ENCODER_CTX,
+        kstr: *const c_uchar,
+        klen: size_t,
+    ) -> c_int;
+    pub fn OSSL_ENCODER_CTX_set_pem_password_cb(
+        ctx: *mut OSSL_ENCODER_CTX,
+        cb: pem_password_cb,
+        cbarg: *mut c_void,
+    ) -> c_int;
+    pub fn OSSL_ENCODER_CTX_set_passphrase_cb(
+        ctx: *mut OSSL_ENCODER_CTX,
+        cb: OSSL_PASSPHRASE_CALLBACK,
+        cbarg: *mut c_void,
+    ) -> c_int;
+
+    pub fn OSSL_ENCODER_to_data(
+        ctx: *mut OSSL_ENCODER_CTX,
+        pdata: *mut *mut c_uchar,
+        pdata_len: *mut size_t,
+    ) -> c_int;
+    pub fn OSSL_ENCODER_to_bio(ctx: *mut OSSL_ENCODER_CTX, out: *mut BIO) -> c_int;
+    #[cfg(not(osslconf = "OPENSSL_NO_STDIO"))]
+    pub fn OSSL_ENCODER_to_fp(ctx: *mut OSSL_ENCODER_CTX, fp: *mut FILE) -> c_int;
+}

openssl-sys/src/handwritten/evp.rs

@@ -588,6 +588,16 @@ extern "C" {
     pub fn EVP_PKEY_keygen(ctx: *mut EVP_PKEY_CTX, key: *mut *mut EVP_PKEY) -> c_int;
     pub fn EVP_PKEY_paramgen(ctx: *mut EVP_PKEY_CTX, key: *mut *mut EVP_PKEY) -> c_int;
 
+    #[cfg(ossl300)]
+    pub fn EVP_PKEY_fromdata_init(ctx: *mut EVP_PKEY_CTX) -> c_int;
+    #[cfg(ossl300)]
+    pub fn EVP_PKEY_fromdata(
+        ctx: *mut EVP_PKEY_CTX,
+        ppkey: *mut *mut EVP_PKEY,
+        selection: c_int,
+        params: *mut OSSL_PARAM,
+    ) -> c_int;
+
     pub fn EVP_PKEY_sign_init(ctx: *mut EVP_PKEY_CTX) -> c_int;
     pub fn EVP_PKEY_sign(
         ctx: *mut EVP_PKEY_CTX,

openssl-sys/src/handwritten/mod.rs

@@ -6,9 +6,11 @@ pub use self::cmac::*;
 pub use self::cms::*;
 pub use self::conf::*;
 pub use self::crypto::*;
+pub use self::decoder::*;
 pub use self::dh::*;
 pub use self::dsa::*;
 pub use self::ec::*;
+pub use self::encoder::*;
 pub use self::err::*;
 pub use self::evp::*;
 pub use self::hmac::*;
@@ -45,9 +47,11 @@ mod cmac;
 mod cms;
 mod conf;
 mod crypto;
+mod decoder;
 mod dh;
 mod dsa;
 mod ec;
+mod encoder;
 mod err;
 mod evp;
 mod hmac;

openssl-sys/src/handwritten/params.rs

@@ -1,16 +1,73 @@
 use super::super::*;
 use libc::*;
 
+#[cfg(ossl300)]
 extern "C" {
-    #[cfg(ossl300)]
+    pub fn OSSL_PARAM_dup(params: *const OSSL_PARAM) -> *mut OSSL_PARAM;
+    pub fn OSSL_PARAM_free(params: *mut OSSL_PARAM);
+    pub fn OSSL_PARAM_merge(
+        params: *const OSSL_PARAM,
+        params1: *const OSSL_PARAM,
+    ) -> *mut OSSL_PARAM;
+    pub fn OSSL_PARAM_locate(params: *mut OSSL_PARAM, key: *const c_char) -> *mut OSSL_PARAM;
+    pub fn OSSL_PARAM_locate_const(
+        params: *const OSSL_PARAM,
+        key: *const c_char,
+    ) -> *const OSSL_PARAM;
     pub fn OSSL_PARAM_construct_uint(key: *const c_char, buf: *mut c_uint) -> OSSL_PARAM;
-    #[cfg(ossl300)]
     pub fn OSSL_PARAM_construct_end() -> OSSL_PARAM;
-    #[cfg(ossl300)]
     pub fn OSSL_PARAM_construct_octet_string(
         key: *const c_char,
         buf: *mut c_void,
         bsize: size_t,
     ) -> OSSL_PARAM;
 
+    pub fn OSSL_PARAM_BLD_new() -> *mut OSSL_PARAM_BLD;
+    pub fn OSSL_PARAM_BLD_free(bld: *mut OSSL_PARAM_BLD);
+    pub fn OSSL_PARAM_BLD_to_param(bld: *mut OSSL_PARAM_BLD) -> *mut OSSL_PARAM;
+    pub fn OSSL_PARAM_BLD_push_uint(
+        bld: *mut OSSL_PARAM_BLD,
+        key: *const c_char,
+        val: c_uint,
+    ) -> c_int;
+    pub fn OSSL_PARAM_BLD_push_size_t(
+        bld: *mut OSSL_PARAM_BLD,
+        key: *const c_char,
+        val: size_t,
+    ) -> c_int;
+    pub fn OSSL_PARAM_BLD_push_BN(
+        bld: *mut OSSL_PARAM_BLD,
+        key: *const c_char,
+        bn: *const BIGNUM,
+    ) -> c_int;
+    pub fn OSSL_PARAM_BLD_push_BN_pad(
+        bld: *mut OSSL_PARAM_BLD,
+        key: *const c_char,
+        bn: *const BIGNUM,
+        sz: size_t,
+    ) -> c_int;
+    pub fn OSSL_PARAM_BLD_push_utf8_string(
+        bld: *mut OSSL_PARAM_BLD,
+        key: *const c_char,
+        buf: *const c_char,
+        bsize: size_t,
+    ) -> c_int;
+    pub fn OSSL_PARAM_BLD_push_utf8_ptr(
+        bld: *mut OSSL_PARAM_BLD,
+        key: *const c_char,
+        buf: *mut c_char,
+        bsize: size_t,
+    ) -> c_int;
+    pub fn OSSL_PARAM_BLD_push_octet_string(
+        bld: *mut OSSL_PARAM_BLD,
+        key: *const c_char,
+        buf: *const c_void,
+        bsize: size_t,
+    ) -> c_int;
+    pub fn OSSL_PARAM_BLD_push_octet_ptr(
+        bld: *mut OSSL_PARAM_BLD,
+        key: *const c_char,
+        buf: *mut c_void,
+        bsize: size_t,
+    ) -> c_int;
 }

openssl-sys/src/handwritten/types.rs

@@ -1134,13 +1134,32 @@ pub enum OSSL_LIB_CTX {}
 #[repr(C)]
 pub struct OSSL_PARAM {
     key: *const c_char,
-    data_type: c_uchar,
+    data_type: c_uint,
     data: *mut c_void,
     data_size: size_t,
     return_size: size_t,
 }
 
+#[cfg(ossl300)]
+pub enum OSSL_PARAM_BLD {}
+
 #[cfg(ossl300)]
 pub enum EVP_KDF {}
 #[cfg(ossl300)]
 pub enum EVP_KDF_CTX {}
+
+#[cfg(ossl300)]
+pub enum OSSL_ENCODER_CTX {}
+#[cfg(ossl300)]
+pub enum OSSL_DECODER_CTX {}
+
+#[cfg(ossl300)]
+pub type OSSL_PASSPHRASE_CALLBACK = Option<
+    unsafe extern "C" fn(
+        pass: *mut c_char,
+        pass_size: size_t,
+        pass_len: *mut size_t,
+        params: *const OSSL_PARAM,
+        arg: *mut c_void,
+    ) -> c_int,
+>;