Struct zappot::ot_ext::Receiver

pub struct Receiver<BaseOT = Sender> { /* private fields */ }

Implementations

impl<BaseOT> Receiver<BaseOT>

where BaseOT: BaseROTSender + Send, BaseOT::Msg: RemoteSend + Debug,

pub async fn perform_base_ots<RNG: RngCore + CryptoRng + Send>( &mut self, rng: &mut RNG, sender: &Sender<<Self as ExtROTReceiver>::Msg>, receiver: &mut Receiver<<Self as ExtROTReceiver>::Msg> ) -> Result<(), Error<<Self as ExtROTReceiver>::Msg>>

impl<BaseOt> Receiver<BaseOt>

pub fn new(base_ot_sender: BaseOt) -> Self

Examples found in repository

crates/zappot/examples/alsz_ot_extension.rs (line 59)

async fn receiver(args: Args) -> (Vec<Block>, BitVec) {
    // Create a secure RNG to use in the protocol
    let mut rng = OsRng;
    // Create the ot extension receiver. A base OT **sender** is passed as an argument and used
    // to create the base_ots
    let mut receiver = Receiver::new(base_ot::Sender);
    let (mut base_sender, _, mut base_receiver, _) =
        seec_channel::tcp::connect::<seec_channel::Sender<_>>(("127.0.0.1", args.port))
            .await
            .expect("Error listening for channel connection");
    let (ch_sender, mut ch_receiver) = sub_channel(&mut base_sender, &mut base_receiver, 128)
        .await
        .expect("Establishing sub channel");

    // Randomly choose one of the blocks
    let choices: BitVec = {
        let mut bv = bitvec![usize, Lsb0; 0; args.num_ots];
        rng.fill(bv.as_raw_mut_slice());
        bv
    };

    // Perform the random ot extension
    let ots = receiver
        .receive_random(&choices, &mut rng, &ch_sender, &mut ch_receiver)
        .await
        .expect("Failed to generate ROTs");
    (ots, choices)
}

Trait Implementations

impl Default for Receiver

fn default() -> Self

Returns the “default value” for a type.

impl<BaseOT> ExtROTReceiver for Receiver<BaseOT>

where BaseOT: BaseROTSender + Send, BaseOT::Msg: RemoteSend + Debug,

type Msg = ExtOTMsg<<BaseOT as BaseROTSender>::Msg>

fn receive_random<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait, C, RNG>( &'life0 mut self, choices: &'life1 BitSlice<C>, rng: &'life2 mut RNG, sender: &'life3 Sender<Self::Msg>, receiver: &'life4 mut Receiver<Self::Msg> ) -> Pin<Box<dyn Future<Output = Result<Vec<Block>, Error<Self::Msg>>> + Send + 'async_trait>>

where RNG: RngCore + CryptoRng + Send + 'async_trait, C: Pod + BitStore + Sync + 'async_trait, <C as BitStore>::Unalias: Pod, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

fn receive_correlated<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait, C, RNG>( &'life0 mut self, choices: &'life1 BitSlice<C>, rng: &'life2 mut RNG, sender: &'life3 Sender<Self::Msg>, receiver: &'life4 mut Receiver<Self::Msg> ) -> Pin<Box<dyn Future<Output = Result<Vec<Block>, Error<Self::Msg>>> + Send + 'async_trait>>

where RNG: RngCore + CryptoRng + Send + 'async_trait, C: Pod + BitStore + Sync + 'async_trait, <C as BitStore>::Unalias: Pod, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

fn receive_correlated_bytes<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait, const LEN: usize, C, RNG>( &'life0 mut self, choices: &'life1 BitSlice<C>, rng: &'life2 mut RNG, sender: &'life3 Sender<Self::Msg>, receiver: &'life4 mut Receiver<Self::Msg> ) -> Pin<Box<dyn Future<Output = Result<Vec<[u8; LEN]>, Error<Self::Msg>>> + Send + 'async_trait>>

where RNG: RngCore + CryptoRng + Send + 'async_trait, [u8; LEN]: Pod, C: Pod + BitStore + Sync + 'async_trait, <C as BitStore>::Unalias: Pod, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,