Struct PqcBinaryFormat 

pub struct PqcBinaryFormat {
    pub magic: [u8; 4],
    pub version: u8,
    pub algorithm: Algorithm,
    pub flags: u8,
    pub metadata: PqcMetadata,
    pub data: Vec<u8>,
    pub checksum: [u8; 32],
}

PQC Binary Format v1.0 specification

This structure represents encrypted data in a standardized, self-describing format compatible across all post-quantum cryptographic algorithms.

Example

use pqc_binary_format::{PqcBinaryFormat, Algorithm, PqcMetadata, EncParameters};
use std::collections::HashMap;

let metadata = PqcMetadata {
    enc_params: EncParameters {
        iv: vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
        tag: vec![1; 16],
        params: HashMap::new(),
    },
    ..Default::default()
};

let format = PqcBinaryFormat::new(
    Algorithm::Hybrid,
    metadata,
    vec![1, 2, 3, 4, 5],
);

// Serialize to bytes
let bytes = format.to_bytes().unwrap();

// Deserialize and verify
let recovered = PqcBinaryFormat::from_bytes(&bytes).unwrap();
assert_eq!(format, recovered);

Fields

magic: [u8; 4]

Magic bytes - always “PQC\x01”

version: u8

Format version - currently 0x01

algorithm: Algorithm

Algorithm identifier

flags: u8

Feature flags

metadata: PqcMetadata

Algorithm-specific metadata

data: Vec<u8>

Encrypted data payload

checksum: [u8; 32]

SHA-256 checksum of the entire structure (excluding this field)

Implementations

impl PqcBinaryFormat

pub fn new(algorithm: Algorithm, metadata: PqcMetadata, data: Vec<u8>) -> Self

Create a new PQC binary format structure with default flags

The checksum is automatically calculated and set.

Example

use pqc_binary_format::{PqcBinaryFormat, Algorithm, PqcMetadata, EncParameters};
use std::collections::HashMap;

let metadata = PqcMetadata {
    enc_params: EncParameters {
        iv: vec![1; 12],
        tag: vec![1; 16],
        params: HashMap::new(),
    },
    ..Default::default()
};

let format = PqcBinaryFormat::new(
    Algorithm::PostQuantum,
    metadata,
    vec![1, 2, 3],
);

pub fn with_flags( algorithm: Algorithm, flags: FormatFlags, metadata: PqcMetadata, data: Vec<u8>, ) -> Self

Create with specific flags

Example

use pqc_binary_format::{PqcBinaryFormat, Algorithm, PqcMetadata, FormatFlags, EncParameters};
use std::collections::HashMap;

let metadata = PqcMetadata {
    enc_params: EncParameters {
        iv: vec![1; 12],
        tag: vec![1; 16],
        params: HashMap::new(),
    },
    ..Default::default()
};

let flags = FormatFlags::new().with_compression().with_streaming();

let format = PqcBinaryFormat::with_flags(
    Algorithm::Hybrid,
    flags,
    metadata,
    vec![1, 2, 3],
);

assert!(format.flags().has_compression());
assert!(format.flags().has_streaming());

pub fn to_bytes(&self) -> Result<Vec<u8>>

Serialize to binary format

Errors

Returns CryptoError::BinaryFormatError if:

• Format validation fails
• Binary serialization fails

Example

use pqc_binary_format::{PqcBinaryFormat, Algorithm, PqcMetadata, EncParameters};
use std::collections::HashMap;

let bytes = format.to_bytes().unwrap();
// Send bytes over network or save to file

pub fn from_bytes(data: &[u8]) -> Result<Self>

Deserialize from binary format with checksum verification

Errors

Returns CryptoError::BinaryFormatError if:

• Binary deserialization fails
• Format validation fails after deserialization
• Checksum verification fails

Example

use pqc_binary_format::PqcBinaryFormat;

let recovered = PqcBinaryFormat::from_bytes(&bytes).unwrap();

pub fn validate(&self) -> Result<()>

Validate the binary format structure

Errors

Returns CryptoError if:

• Magic bytes are invalid
• Version is unsupported
• Algorithm ID is invalid
• Metadata validation fails

pub fn update_checksum(&mut self)

Update the checksum field with the calculated checksum

Call this after modifying any fields to maintain integrity.

pub fn flags(&self) -> FormatFlags

Get format flags

pub const fn algorithm(&self) -> Algorithm

Get algorithm

pub fn data(&self) -> &[u8]

Get encrypted data

pub const fn metadata(&self) -> &PqcMetadata

Get metadata

pub fn total_size(&self) -> usize

Get total size of the binary format when serialized

Trait Implementations

impl Clone for PqcBinaryFormat

fn clone(&self) -> PqcBinaryFormat

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PqcBinaryFormat

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PqcBinaryFormat

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PqcBinaryFormat

fn eq(&self, other: &PqcBinaryFormat) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PqcBinaryFormat

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for PqcBinaryFormat

impl StructuralPartialEq for PqcBinaryFormat