Шифрование на уровне протокола

use brec::prelude::*;
use serde::{Deserialize, Serialize};
use std::io::{Error, ErrorKind};
#[block]
pub struct MetaBlock {
    pub request_id: u32,
    pub level: u8,
}
#[payload]
#[derive(Serialize, Deserialize)]
pub struct GreetingPayload {
    pub message: String,
}

#[payload(ctx)]
pub struct CounterContext {
    pub encoded: u32,
    pub decoded: u32,
}
impl CounterContext {
    fn extract<'a>(ctx: &'a mut crate::PayloadContext<'_>) -> std::io::Result<&'a mut Self> {
        match ctx {
            crate::PayloadContext::CounterContext(ctx) => Ok(ctx),
            crate::PayloadContext::None => Err(Error::new(
                ErrorKind::InvalidInput,
                "GreetingPayload expects PayloadContext::CounterContext",
            )),
        }
    }
    fn inc_encoded<'a>(ctx: &'a mut crate::PayloadContext<'_>) -> std::io::Result<()> {
        Self::extract(ctx)?.encoded += 1;
        Ok(())
    }
    fn inc_decoded<'a>(ctx: &'a mut crate::PayloadContext<'_>) -> std::io::Result<()> {
        Self::extract(ctx)?.decoded += 1;
        Ok(())
    }
}

impl GreetingPayload {
    fn to_bytes(&self) -> std::io::Result<Vec<u8>> {
        bincode::serde::encode_to_vec(self, bincode::config::standard())
            .map_err(|err| Error::new(ErrorKind::InvalidData, err))
    }
    fn from_bytes(buf: &[u8]) -> std::io::Result<Self> {
        let (payload, _): (Self, usize) =
            bincode::serde::decode_from_slice(buf, bincode::config::standard())
                .map_err(|err| Error::new(ErrorKind::InvalidData, err))?;
        Ok(payload)
    }
}
impl PayloadEncode for GreetingPayload {
    fn encode(&self, ctx: &mut Self::Context<'_>) -> std::io::Result<Vec<u8>> {
        // Увеличим счётчик
        CounterContext::inc_encoded(ctx)?;
        // Кодируем наш Payload
        self.to_bytes()
    }
}
impl PayloadEncodeReferred for GreetingPayload {
    fn encode(&self, _ctx: &mut Self::Context<'_>) -> std::io::Result<Option<&[u8]>> {
        // Это можно имплементировать опционально, если хотим "дешёвый" доступ к нашим данным, что
        // увы не всегда возможно
        Ok(None)
    }
}
impl PayloadDecode<GreetingPayload> for GreetingPayload {
    fn decode(buf: &[u8], ctx: &mut Self::Context<'_>) -> std::io::Result<GreetingPayload> {
        // Увеличим счётчик
        CounterContext::inc_decoded(ctx)?;
        // Декодируем наш Payload
        Self::from_bytes(buf)
    }
}
impl PayloadSize for GreetingPayload {
    fn size(&self, _ctx: &mut Self::Context<'_>) -> std::io::Result<u64> {
        // Реализуем возможность узнать размер Payload
        Ok(self.to_bytes()?.len() as u64)
    }
}
impl PayloadCrc for GreetingPayload {
    // Это зачастую не нуждается в собственной имплементации.
    // Достаточно дефалтного
}
// Всё готово, вызываем генератор, который подвезёт
// - `Block`
// - `Payload`
// - `Packet`
// - `PayloadContext<'a>`
// - `PacketBufReader`
// - `Reader` / `Writer`
brec::generate!();

[dependencies]
brec = { version = "...", features = ["bincode", "crypt"] }
serde = { version = "1.0", features = ["derive"] }

use brec::prelude::*;
use serde::{Deserialize, Serialize};
#[block]
pub struct MetaBlock {
    pub request_id: u32,
    pub level: u8,
}
#[payload(bincode, crypt)]
#[derive(Serialize, Deserialize)]
pub struct GreetingPayload {
    pub message: String,
}
brec::generate!();

const EXAMPLE_PUBLIC_KEY_PEM: &str = r#"-----BEGIN PUBLIC KEY----- ... -----END PUBLIC KEY-----"#;
const EXAMPLE_PRIVATE_KEY_PEM: &str = r#"-----BEGIN PRIVATE KEY----- ... -----END PRIVATE KEY-----"#;
const KEY_ID: &[u8] = b"some_crypt_demo-key";
fn encode(
    message: String,
    request_id: u32,
    level: u8,
) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    // Создадим пакет. Никакого шифрования.
    let mut packet = Packet::new(
        vec![Block::MetaBlock(MetaBlock { request_id, level })],
        Some(Payload::GreetingPayload(GreetingPayload {
            message,
        })),
    );
    // Теперь создадим контекст, который нам стал доступен при активации фичи `crypt`
    let mut encrypt = EncryptOptions::from_public_key_pem(EXAMPLE_PUBLIC_KEY_PEM)?
        .with_key_id(KEY_ID.to_vec());
    let mut encrypt_ctx = PayloadContext::Encrypt(&mut encrypt);
    // Записали пакет, наш GreetingPayload внутри пакета будет зашифрован
    let mut bytes = Vec::new();
    packet.write_all(&mut bytes, &mut encrypt_ctx)?;
    Ok(bytes)
}
fn decode(
    bytes: Vec<u8>,
) -> Result<Packet, Box<dyn std::error::Error>> {
    use std::io::Cursor;
    // Создаём контекст для декодирования
    let mut decrypt = DecryptOptions::from_private_key_pem(EXAMPLE_PRIVATE_KEY_PEM)?
        .with_expected_key_id(KEY_ID.to_vec());
    let mut decrypt_ctx = PayloadContext::Decrypt(&mut decrypt);
    // Читаем пакет
    let mut source = Cursor::new(bytes.as_slice());
    let mut reader = PacketBufReader::new(&mut source);
    match reader.read(&mut decrypt_ctx)? {
        NextPacket::Found(packet) => Ok(packet),
        NextPacket::NotEnoughData(_) =>
            Err("unexpected read status: NotEnoughData".into()),
        NextPacket::NoData => Err("unexpected read status: NoData".into()),
        NextPacket::NotFound => Err("unexpected read status: NotFound".into()),
        NextPacket::Skipped => Err("unexpected read status: Skipped".into()),
    }
}