mbedtls 0.13.5

Idiomatic Rust wrapper for MbedTLS, allowing you to use MbedTLS with only safe code while being able to use such great Rust features like error handling and closures. Building on MbedTLS's focus on embedded use, this crate can be used in a no_std environment.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

/* Copyright (c) Fortanix, Inc.
 *
 * Licensed under the GNU General Public License, version 2 <LICENSE-GPL or
 * https://www.gnu.org/licenses/gpl-2.0.html> or the Apache License, Version
 * 2.0 <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0>, at your
 * option. This file may not be copied, modified, or distributed except
 * according to those terms. */

#[cfg(feature = "std")]
use std::sync::Arc;

use mbedtls_sys::types::raw_types::{c_int, c_uchar, c_void};
use mbedtls_sys::types::size_t;
use mbedtls_sys::*;

#[cfg(not(feature = "std"))]
use crate::alloc_prelude::*;
use crate::cipher::raw::CipherType;
use crate::error::{IntoResult, Result};
use crate::rng::RngCallback;

pub trait TicketCallback: Sync {
    unsafe extern "C" fn call_write(
        p_ticket: *mut c_void,
        session: *const ssl_session,
        start: *mut c_uchar,
        end: *const c_uchar,
        tlen: *mut size_t,
        lifetime: *mut u32,
    ) -> c_int
    where
        Self: Sized;
    unsafe extern "C" fn call_parse(p_ticket: *mut c_void, session: *mut ssl_session, buf: *mut c_uchar, len: size_t) -> c_int
    where
        Self: Sized;

    fn data_ptr(&self) -> *mut c_void;
}

define!(
    #[c_ty(ssl_ticket_context)]
    #[repr(C)]
    struct TicketContext {
        // We set rng from constructur, we never read it directly. It is only used to ensure rng lives as long as we need.
        #[allow(dead_code)]
        rng: Arc<dyn RngCallback + Send + 'static>,
    };
    const drop: fn(&mut Self) = ssl_ticket_free;
    impl<'a> Into<ptr> {}
);

unsafe impl Sync for TicketContext {}

impl TicketContext {
    pub fn new<T: RngCallback + Send + 'static>(rng: Arc<T>, cipher: CipherType, lifetime: u32) -> Result<TicketContext> {
        let mut ret = TicketContext {
            inner: ssl_ticket_context::default(),
            rng,
        };

        unsafe {
            ssl_ticket_init(&mut ret.inner);
            ssl_ticket_setup(&mut ret.inner, Some(T::call), ret.rng.data_ptr(), cipher.into(), lifetime).into_result()?;
        }

        Ok(ret)
    }
}

impl TicketCallback for TicketContext {
    unsafe extern "C" fn call_write(
        p_ticket: *mut c_void,
        session: *const ssl_session,
        start: *mut c_uchar,
        end: *const c_uchar,
        tlen: *mut size_t,
        lifetime: *mut u32,
    ) -> c_int {
        ssl_ticket_write(p_ticket, session, start, end, tlen, lifetime)
    }

    unsafe extern "C" fn call_parse(p_ticket: *mut c_void, session: *mut ssl_session, buf: *mut c_uchar, len: size_t) -> c_int {
        ssl_ticket_parse(p_ticket, session, buf, len)
    }

    fn data_ptr(&self) -> *mut c_void {
        self.handle() as *const _ as *mut _
    }
}