stoffelcrypto 0.1.0

Asynchronous HoneyBadgerMPC protocols, preprocessing, and arithmetic for Stoffel.
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
90
91
92
93
94
95
96

pub mod fake_network;
pub mod quic;
use std::slice;
use std::sync::Arc;

use stoffelmpc_network::fake_network::FakeNetwork;
use stoffelnet::network_utils::{Network, NetworkError};
use stoffelnet::transports::quic::QuicNetworkManager;

use crate::ffi::c_bindings::ByteSlice;
#[repr(C)]
pub enum NetworkErrorCode {
    NetworkSuccess,
    IncorrectNetworkType,
    IncorrectSockAddr,
    ConnectError,
    NetworkAlreadyInUse,
    RecvError,
    SendError,
    Timeout,
    PartyNotFound,
    ClientNotFound,
}

impl From<NetworkError> for NetworkErrorCode {
    fn from(value: NetworkError) -> Self {
        match value {
            NetworkError::SendError => Self::SendError,
            NetworkError::Timeout => Self::Timeout,
            NetworkError::PartyNotFound(_) => Self::PartyNotFound,
            NetworkError::ClientNotFound(_) => Self::ClientNotFound,
        }
    }
}

// opaque pointer for GenericNetwork
#[repr(C)]
pub struct NetworkOpaque {
    _data: (),
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub enum GenericNetwork {
    FakeNetwork(Arc<FakeNetwork>),
    QuicNetworkManager(Arc<QuicNetworkManager>),
}

#[no_mangle]
pub extern "C" fn free_network(network: *mut NetworkOpaque) {
    if !network.is_null() {
        unsafe {
            let _ = Box::from_raw(network as *mut GenericNetwork);
        }
    }
}

#[no_mangle]
pub extern "C" fn clone_network(network: *mut NetworkOpaque) -> *mut NetworkOpaque {
    if network.is_null() {
        return std::ptr::null_mut();
    }
    let net = unsafe { &*(network as *mut GenericNetwork) };
    let cloned = match net {
        GenericNetwork::FakeNetwork(n) => GenericNetwork::FakeNetwork(Arc::clone(n)),
        GenericNetwork::QuicNetworkManager(n) => GenericNetwork::QuicNetworkManager(Arc::clone(n)),
    };
    Box::into_raw(Box::new(cloned)) as *mut NetworkOpaque
}

#[no_mangle]
pub extern "C" fn network_send(
    net_ptr: *mut NetworkOpaque,
    recipient_id: usize,
    message: ByteSlice,
    sent_size: *mut usize,
) -> NetworkErrorCode {
    let network = unsafe { &*(net_ptr as *mut GenericNetwork) };
    let message = unsafe { slice::from_raw_parts(message.pointer, message.len) };
    let res = match &*network {
        GenericNetwork::FakeNetwork(n) => tokio::runtime::Runtime::new()
            .unwrap()
            .block_on(n.send(recipient_id, message)),
        GenericNetwork::QuicNetworkManager(n) => tokio::runtime::Runtime::new()
            .unwrap()
            .block_on(n.send(recipient_id, message)),
    };
    match res {
        Ok(u) => {
            unsafe {
                *sent_size = u;
            };
            return NetworkErrorCode::NetworkSuccess;
        }
        Err(e) => return e.into(),
    }
}