Skip to main content

security/
cms.rs

1use crate::bridge;
2use crate::certificate::Certificate;
3use crate::error::Result;
4
5pub struct Cms;
6
7impl Cms {
8    pub fn encode_supporting_certificates(certificates: &[Certificate]) -> Result<Vec<u8>> {
9        let handles = certificates.iter().map(Certificate::handle).collect::<Vec<_>>();
10        let pointers = bridge::handle_pointer_array(&handles);
11        let mut status = 0;
12        let mut error = std::ptr::null_mut();
13        let raw = unsafe {
14            bridge::security_cms_encode_certificates(
15                pointers.as_ptr(),
16                bridge::len_to_isize(pointers.len())?,
17                &mut status,
18                &mut error,
19            )
20        };
21        bridge::required_data("security_cms_encode_certificates", raw, status, error)
22    }
23
24    pub fn decode_all_certificates(data: &[u8]) -> Result<Vec<Certificate>> {
25        let mut status = 0;
26        let mut error = std::ptr::null_mut();
27        let raw = unsafe {
28            bridge::security_cms_decode_all_certificates(
29                data.as_ptr().cast(),
30                bridge::len_to_isize(data.len())?,
31                &mut status,
32                &mut error,
33            )
34        };
35        let array_handle = bridge::required_handle(
36            "security_cms_decode_all_certificates",
37            raw,
38            status,
39            error,
40        )?;
41        let count = usize::try_from(unsafe {
42            bridge::security_certificate_array_get_count(array_handle.as_ptr())
43        })
44        .unwrap_or_default();
45        let mut certificates = Vec::with_capacity(count);
46        for index in 0..count {
47            let mut status = 0;
48            let mut error = std::ptr::null_mut();
49            let raw = unsafe {
50                bridge::security_certificate_array_copy_item(
51                    array_handle.as_ptr(),
52                    bridge::len_to_isize(index)?,
53                    &mut status,
54                    &mut error,
55                )
56            };
57            let handle = bridge::required_handle(
58                "security_certificate_array_copy_item",
59                raw,
60                status,
61                error,
62            )?;
63            certificates.push(Certificate::from_handle(handle));
64        }
65        Ok(certificates)
66    }
67}