Enum Algorithm 

#[repr(u16)]
pub enum Algorithm {
    Classical = 80,
    PasswordClassical = 81,
    Hybrid = 256,
    PostQuantum = 512,
    MultiAlgorithm = 513,
    MlKem1024 = 514,
    MultiKem = 515,
    MultiKemTriple = 516,
    QuadLayer = 517,
    LatticeCodeHybrid = 518,
    Pq3Stack = 519,
    MaxSecureLightweight = 768,
    MaxSecurePurePq = 769,
    MaxSecureHybrid = 770,
    MaxSecureStateless = 771,
    MaxSecureCryptoAgile = 772,
    MaxSecurePqcZk = 773,
    MaxSecureHybridTransition = 774,
    FnDsa512Compact = 1_024,
    FnDsa1024Security = 1_025,
    FnDsaFpHardened = 1_026,
    FnDsaDualSignature = 1_027,
    FnDsaTransition = 1_028,
    FnDsaZk = 1_029,
    FnDsaZkStack = 1_030,
    FnDsaTransitionStack = 1_031,
    QuantumLatticeFusion = 1_280,
    PostZkHomomorphic = 1_281,
    QuantumResistantConsensus = 1_282,
    EntropyOrchestrated = 1_283,
    LatticeCodeHybridFn = 1_284,
    AiSynthesizedCryptoAgile = 1_285,
    Experimental = 1_286,
    Hqc128 = 1_536,
    Hqc192 = 1_537,
    Hqc256 = 1_538,
}

Supported cryptographic algorithms with unique identifiers

Each algorithm has a unique 16-bit identifier used in the binary format. Identifiers are grouped by algorithm family for easy categorization.

Variants

Classical = 80

Classical cryptography: X25519 + Ed25519 + AES-256-GCM

PasswordClassical = 81

Password-based classical encryption

Hybrid = 256

Hybrid: ML-KEM-1024 + X25519 + ML-DSA-87 + Ed25519 + AES-256-GCM

PostQuantum = 512

Post-quantum: ML-KEM-1024 + ML-DSA-87 + AES-256-GCM

MultiAlgorithm = 513

Multi-algorithm runtime selection

MlKem1024 = 514

ML-KEM-1024 with AES-256-GCM

MultiKem = 515

Multi-KEM dual layer

MultiKemTriple = 516

Multi-KEM triple layer

QuadLayer = 517

Quad-layer redundant security

LatticeCodeHybrid = 518

Lattice-Code hybrid stack

Pq3Stack = 519

PQ3-Stack with forward secrecy

MaxSecureLightweight = 768

Max Secure: PQ Lightweight

MaxSecurePurePq = 769

Max Secure: Pure PQ

MaxSecureHybrid = 770

Max Secure: Hybrid Transition

MaxSecureStateless = 771

Max Secure: Stateless

MaxSecureCryptoAgile = 772

Max Secure: Crypto-Agile

MaxSecurePqcZk = 773

Max Secure: PQC + Zero-Knowledge

MaxSecureHybridTransition = 774

Max Secure: Hybrid Transition

FnDsa512Compact = 1_024

FN-DSA 512: Compact

FnDsa1024Security = 1_025

FN-DSA 1024: High-Security

FnDsaFpHardened = 1_026

FN-DSA: Floating-Point Hardened

FnDsaDualSignature = 1_027

FN-DSA: Dual Signature

FnDsaTransition = 1_028

FN-DSA: Transition Stack

FnDsaZk = 1_029

FN-DSA + Zero-Knowledge Stack

FnDsaZkStack = 1_030

FN-DSA + ZK Stack Enhanced

FnDsaTransitionStack = 1_031

FN-DSA: Transition Stack Enhanced

QuantumLatticeFusion = 1_280

Quantum-Inspired Lattice Fusion

PostZkHomomorphic = 1_281

Post-ZK Homomorphic with LFHE 2023

QuantumResistantConsensus = 1_282

Quantum-Resistant Consensus

EntropyOrchestrated = 1_283

Entropy-Orchestrated PQ Stack

LatticeCodeHybridFn = 1_284

Lattice-Code Hybrid FN

AiSynthesizedCryptoAgile = 1_285

AI-Synthesized Crypto-Agile

Experimental = 1_286

Experimental Engine (generic)

Hqc128 = 1_536

HQC-128 (NIST Level 1, 128-bit security)

Hqc192 = 1_537

HQC-192 (NIST Level 3, 192-bit security)

Hqc256 = 1_538

HQC-256 (NIST Level 5, 256-bit security)

Implementations

impl Algorithm

pub fn from_id(id: u16) -> Option<Self>

Convert u16 identifier to Algorithm enum

Example

use pqc_binary_format::Algorithm;

let algo = Algorithm::from_id(0x0100).unwrap();
assert_eq!(algo, Algorithm::Hybrid);

pub const fn as_id(self) -> u16

Get u16 identifier for this algorithm

Example

use pqc_binary_format::Algorithm;

assert_eq!(Algorithm::Hybrid.as_id(), 0x0100);

pub const fn name(self) -> &'static str

Get human-readable name for this algorithm

Example

use pqc_binary_format::Algorithm;

assert_eq!(Algorithm::Hybrid.name(), "Hybrid");

pub const fn is_experimental(self) -> bool

Check if this algorithm is marked as experimental

Experimental algorithms may have reduced security guarantees and are intended for research purposes.

pub fn all() -> Vec<Self>

Get all defined algorithm identifiers

Useful for iteration and testing.

Trait Implementations

impl Clone for Algorithm

fn clone(&self) -> Algorithm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Algorithm

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Algorithm

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Algorithm

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Algorithm

fn eq(&self, other: &Algorithm) -> 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 Algorithm

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Algorithm

impl Eq for Algorithm

impl StructuralPartialEq for Algorithm