Struct DataCodec 

pub struct DataCodec { /* private fields */ }

Negotiated key material for exactly one endpoint-to-relay connection. Debug output intentionally never includes the secret.

Implementations

impl DataCodec

pub fn legacy(key: AesKeyType) -> Self

Wrap an existing legacy key without changing its wire encoding.

Examples found in repository

examples/data_codec_bench.rs (line 13)

fn measure(v2: bool, size: usize, iterations: usize) -> Result<f64, Box<dyn Error>> {
    let codec = if v2 {
        DataCodec::negotiate([42; 32], Some(2), HeaderProtocol::V2)?
    } else {
        DataCodec::legacy([42; 32])
    };
    if size == 0 {
        let start = Instant::now();
        for _ in 0..iterations {
            black_box(black_box(codec).endpoint_codecs()?);
        }
        return Ok(start.elapsed().as_secs_f64() * 1e9 / iterations as f64);
    }
    let (_, mut writer) = codec.endpoint_codecs()?;
    let (mut reader, _) = codec.relay_codecs()?;
    let mut bytes = vec![42; size + 16];
    let start = Instant::now();
    for _ in 0..iterations {
        let tag = writer
            .encrypt(black_box(&mut bytes[..size]))
            .map_err(|_| "encrypt failed")?;
        bytes[size..].copy_from_slice(tag.as_ref());
        black_box(
            reader
                .decrypt(black_box(&mut bytes))
                .map_err(|_| "decrypt failed")?,
        );
    }
    let elapsed = start.elapsed().as_secs_f64();
    assert!(bytes[..size].iter().all(|&byte| byte == 42));
    Ok(elapsed * 1e9 / iterations as f64)
}

pub fn from_response( key: Option<AesKeyType>, protocol: Option<u16>, offered_v2: bool, ) -> Result<Option<Self>>

Validate an authenticated response. Unknown selections are errors and must never cause another connection in a weaker mode.

pub fn negotiate( key: AesKeyType, offer: Option<u16>, header: HeaderProtocol, ) -> Result<Self>

Select only a capability received through authenticated control-v2.

Examples found in repository

examples/data_codec_bench.rs (line 11)

fn measure(v2: bool, size: usize, iterations: usize) -> Result<f64, Box<dyn Error>> {
    let codec = if v2 {
        DataCodec::negotiate([42; 32], Some(2), HeaderProtocol::V2)?
    } else {
        DataCodec::legacy([42; 32])
    };
    if size == 0 {
        let start = Instant::now();
        for _ in 0..iterations {
            black_box(black_box(codec).endpoint_codecs()?);
        }
        return Ok(start.elapsed().as_secs_f64() * 1e9 / iterations as f64);
    }
    let (_, mut writer) = codec.endpoint_codecs()?;
    let (mut reader, _) = codec.relay_codecs()?;
    let mut bytes = vec![42; size + 16];
    let start = Instant::now();
    for _ in 0..iterations {
        let tag = writer
            .encrypt(black_box(&mut bytes[..size]))
            .map_err(|_| "encrypt failed")?;
        bytes[size..].copy_from_slice(tag.as_ref());
        black_box(
            reader
                .decrypt(black_box(&mut bytes))
                .map_err(|_| "decrypt failed")?,
        );
    }
    let elapsed = start.elapsed().as_secs_f64();
    assert!(bytes[..size].iter().all(|&byte| byte == 42));
    Ok(elapsed * 1e9 / iterations as f64)
}

pub fn validate_offer(offer: Option<u16>, header: HeaderProtocol) -> Result<()>

Reject unknown or unauthenticated selections before any setup response.

pub fn key(self) -> AesKeyType

The per-leg secret sent inside the authenticated setup response.

pub fn protocol(self) -> Option<u16>

Omit the field completely when interoperating with a legacy peer.

pub fn endpoint_codecs(self) -> Result<(Aes256GcmDeCodec, Aes256GcmEnCodec)>

Receiving and sending codecs from the local endpoint’s perspective.

Examples found in repository

examples/data_codec_bench.rs (line 18)

fn measure(v2: bool, size: usize, iterations: usize) -> Result<f64, Box<dyn Error>> {
    let codec = if v2 {
        DataCodec::negotiate([42; 32], Some(2), HeaderProtocol::V2)?
    } else {
        DataCodec::legacy([42; 32])
    };
    if size == 0 {
        let start = Instant::now();
        for _ in 0..iterations {
            black_box(black_box(codec).endpoint_codecs()?);
        }
        return Ok(start.elapsed().as_secs_f64() * 1e9 / iterations as f64);
    }
    let (_, mut writer) = codec.endpoint_codecs()?;
    let (mut reader, _) = codec.relay_codecs()?;
    let mut bytes = vec![42; size + 16];
    let start = Instant::now();
    for _ in 0..iterations {
        let tag = writer
            .encrypt(black_box(&mut bytes[..size]))
            .map_err(|_| "encrypt failed")?;
        bytes[size..].copy_from_slice(tag.as_ref());
        black_box(
            reader
                .decrypt(black_box(&mut bytes))
                .map_err(|_| "decrypt failed")?,
        );
    }
    let elapsed = start.elapsed().as_secs_f64();
    assert!(bytes[..size].iter().all(|&byte| byte == 42));
    Ok(elapsed * 1e9 / iterations as f64)
}

pub fn relay_codecs(self) -> Result<(Aes256GcmDeCodec, Aes256GcmEnCodec)>

Receiving and sending codecs from the relay’s perspective.

Examples found in repository

examples/data_codec_bench.rs (line 23)

fn measure(v2: bool, size: usize, iterations: usize) -> Result<f64, Box<dyn Error>> {
    let codec = if v2 {
        DataCodec::negotiate([42; 32], Some(2), HeaderProtocol::V2)?
    } else {
        DataCodec::legacy([42; 32])
    };
    if size == 0 {
        let start = Instant::now();
        for _ in 0..iterations {
            black_box(black_box(codec).endpoint_codecs()?);
        }
        return Ok(start.elapsed().as_secs_f64() * 1e9 / iterations as f64);
    }
    let (_, mut writer) = codec.endpoint_codecs()?;
    let (mut reader, _) = codec.relay_codecs()?;
    let mut bytes = vec![42; size + 16];
    let start = Instant::now();
    for _ in 0..iterations {
        let tag = writer
            .encrypt(black_box(&mut bytes[..size]))
            .map_err(|_| "encrypt failed")?;
        bytes[size..].copy_from_slice(tag.as_ref());
        black_box(
            reader
                .decrypt(black_box(&mut bytes))
                .map_err(|_| "decrypt failed")?,
        );
    }
    let elapsed = start.elapsed().as_secs_f64();
    assert!(bytes[..size].iter().all(|&byte| byte == 42));
    Ok(elapsed * 1e9 / iterations as f64)
}

Trait Implementations

impl Clone for DataCodec

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for DataCodec