Skip to main content

PQC Binary Format

Crates.io Documentation License Build Status

A standardized, self-describing binary format for post-quantum cryptography encrypted data interchange.

🌟 The Problem

Post-quantum cryptography (PQC) implementations suffer from the "Babel Tower problem": different implementations cannot interoperate because there is no standardized format for encrypted data. Each library uses its own proprietary format, making cross-platform and cross-language encryption impossible.

💡 The Solution

PQC Binary Format provides a universal, algorithm-agnostic format that:

  • ✅ Works across 51 cryptographic algorithms
  • ✅ Self-describing metadata enables seamless decryption
  • ✅ Integrity verification with SHA-256 checksums
  • ✅ Cross-platform compatible (Rust, Python, JavaScript, Go, etc.)
  • ✅ Future-proof design allows algorithm migration
  • ✅ Minimal dependencies: serde, serde_json, sha2, base64

🚀 Quick Start

Rust

Add to your Cargo.toml:

[dependencies]
pqc-binary-format = "3"

Basic Usage (Rust)

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

// Create metadata with encryption parameters
let metadata = PqcMetadata {
    enc_params: EncParameters {
        iv: vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],  // 12-byte nonce
        tag: vec![0; 16],                                  // 16-byte auth tag
        params: HashMap::new(),
    },
    ..Default::default()
};

// Create encrypted data container
let encrypted_data = vec![1, 2, 3, 4, 5];  // Your encrypted bytes
let format = PqcBinaryFormat::new(Algorithm::Hybrid, metadata, encrypted_data);

// Serialize to bytes (for transmission or storage)
let bytes = format.to_bytes().unwrap();

// Deserialize from bytes (includes automatic checksum verification)
let recovered = PqcBinaryFormat::from_bytes(&bytes).unwrap();

assert_eq!(format, recovered);
println!("Algorithm: {}", recovered.algorithm().name());

Python

Install the Python bindings:

cd bindings/python
pip install maturin
maturin develop --release
from pqc_binary_format import Algorithm, EncParameters, PqcMetadata, PqcBinaryFormat

# Create algorithm and metadata
algorithm = Algorithm("hybrid")
enc_params = EncParameters(
    iv=bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]),
    tag=bytes([0] * 16)
)
metadata = PqcMetadata(enc_params=enc_params, kem_params=None, sig_params=None, compression_params=None)

# Create and serialize format
pqc_format = PqcBinaryFormat(algorithm, metadata, bytes([1, 2, 3, 4, 5]))
serialized = pqc_format.to_bytes()

# Deserialize and verify
deserialized = PqcBinaryFormat.from_bytes(serialized)
deserialized.validate()  # Verify checksum integrity
print(f"Algorithm: {deserialized.algorithm.name}")

JavaScript/TypeScript

Build the WebAssembly bindings:

cd bindings/javascript
npm install
npm run build
import init, { WasmAlgorithm, WasmEncParameters, WasmPqcMetadata, WasmPqcBinaryFormat } from './pqc_binary_format.js';

await init();

const algorithm = new WasmAlgorithm('hybrid');
const encParams = new WasmEncParameters(
    new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]),
    new Uint8Array(16)
);
const metadata = new WasmPqcMetadata(encParams);
const pqcFormat = new WasmPqcBinaryFormat(algorithm, metadata, new Uint8Array([1, 2, 3, 4, 5]));

const serialized = pqcFormat.toBytes();
const deserialized = WasmPqcBinaryFormat.fromBytes(serialized);
console.log(`Algorithm: ${deserialized.algorithm.name}`);

Go

Build the Rust library first, then use the Go bindings:

cargo build --release
cd bindings/go
go build example.go
package main

import (
    "fmt"
    "log"
    pqc "github.com/PQCrypta/pqc-binary-format/bindings/go/v3"
)

func main() {
    // Metadata is an opaque, length-prefixed section (UTF-8 JSON by convention).
    metadata := []byte(`{"encryption_params":{"iv":"...","tag":"...","params":{}}}`)
    data := []byte{1, 2, 3, 4, 5}

    format := pqc.New(pqc.AlgorithmHybrid, metadata, data)

    serialized, err := format.Serialize()
    if err != nil {
        log.Fatal(err)
    }
    deserialized, err := pqc.Parse(serialized) // verifies the checksum
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Algorithm: %s (0x%04X)\n", deserialized.AlgorithmName(), deserialized.AlgorithmID)
}

C/C++

Build the Rust library and generate the C header:

cargo build --release
cbindgen --config cbindgen.toml --output include/pqc_binary_format.h
cd bindings/c-cpp
make
#include "pqc_binary_format.h"
#include <iostream>
#include <vector>

int main() {
    std::vector<uint8_t> iv = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
    std::vector<uint8_t> tag(16, 0);
    std::vector<uint8_t> data = {1, 2, 3, 4, 5};

    PqcFormatHandle* format = pqc_format_new(
        PQC_ALGORITHM_HYBRID,
        iv.data(), iv.size(),
        tag.data(), tag.size(),
        data.data(), data.size()
    );

    ByteBuffer serialized = pqc_format_to_bytes(format);
    PqcFormatHandle* deserialized = pqc_format_from_bytes(serialized.data, serialized.len);

    char* alg_name = pqc_format_get_algorithm_name(deserialized);
    std::cout << "Algorithm: " << alg_name << std::endl;

    pqc_free_string(alg_name);
    pqc_free_buffer(serialized);
    pqc_format_free(deserialized);
    pqc_format_free(format);

    return 0;
}

🌐 Language Bindings

PQC Binary Format provides production-ready, fully tested bindings for multiple programming languages. All bindings support the complete API and produce cross-compatible binary formats.

Available Bindings

Language Status Package Documentation Examples
Rust ✅ Native pqc-binary-format docs.rs 3 examples
Python ✅ Tested pqc_binary_format Python README 2 examples
JavaScript/WASM ✅ Tested pqc-binary-format (npm) JS README 1 example
Go ✅ Tested github.com/PQCrypta/pqc-binary-format/bindings/go/v3 pkg.go.dev 1 example
C ✅ Tested FFI via Rust C/C++ README 1 example
C++ ✅ Tested FFI via Rust C/C++ README 1 example

Installation Quick Reference

# Rust
cargo add pqc-binary-format

# Python
pip install pqc-binary-format

# JavaScript/WASM
npm install pqc-binary-format

# Go
go get github.com/PQCrypta/pqc-binary-format/bindings/go/v3

# C/C++ (build from source)
cargo build --release --no-default-features
# Link against target/release/libpqc_binary_format.so

Cross-Language Compatibility

All language bindings are fully interoperable! You can:

  • ✅ Encrypt data in Python, decrypt in Rust
  • ✅ Serialize in Go, deserialize in JavaScript
  • ✅ Create format in C++, validate in Python
  • ✅ Mix any combination across platforms

Example workflow:

# Create encrypted data with Python
python3 examples/python/basic_usage.py > data.bin

# Verify with C++
LD_LIBRARY_PATH=target/release ./examples/cpp/basic_usage < data.bin

# Process with Go
cd examples/go && go run basic_usage.go < ../../data.bin

Binding Features

All bindings support:

  • ✅ Full algorithm suite (51 algorithms)
  • ✅ Metadata serialization/deserialization
  • ✅ SHA-256 integrity verification
  • ✅ Feature flags (compression, streaming, etc.)
  • ✅ Error handling with detailed messages
  • ✅ Memory safety (Rust-backed)

Package Distribution Status

Platform Status Notes
crates.io (Rust) ✅ Published crates.io
PyPI (Python) ✅ Published PyPI
npm (JavaScript) ✅ Published npm
Go module proxy ✅ Published from 3.0.0 Go

📦 Binary Format Specification

All multi-byte integers are little-endian; the metadata section is a UTF-8 JSON object. Fields appear in this exact order (see draft-riddel-pqc-binary-format-00, Section 3):

+-------------------+
| Magic (4 bytes)   | "PQC\x01" - Format identifier
+-------------------+
| Version (1 byte)  | 0x01 - Format version
+-------------------+
| Algorithm (2 bytes)| Algorithm identifier (0x0050 - 0x0905), little-endian
+-------------------+
| Flags (1 byte)    | Feature flags (reserved, 0x00 in v1)
+-------------------+
| Metadata Len (4)  | Length of metadata section, little-endian
+-------------------+
| Metadata (var)    | Algorithm-specific parameters (UTF-8 JSON)
+-------------------+
| Data Len (8)      | Length of encrypted payload, little-endian
+-------------------+
| Data (var)        | Encrypted data
+-------------------+
| Checksum (32)     | SHA-256 over all preceding bytes
+-------------------+

Fixed-header size (excluding the variable metadata/data sections) is 52 bytes. The checksum is SHA-256(magic ‖ version ‖ algorithm_id ‖ flags ‖ metadata_len ‖ metadata ‖ data_len ‖ data); because the JSON metadata is emitted with sorted keys it is deterministic across implementations.

🔐 Supported Algorithms

The format supports 51 cryptographic algorithm identifiers, the registry in src/algorithm.rs (Algorithm::ALL); tests/registry.rs holds this list to it:

Classical Algorithms (0x0050-0x00FF)

  • Classical (0x0050): Classical cryptography: X25519 + Ed25519 + AES-256-GCM
  • Password Classical (0x0051): Password-based classical encryption

Hybrid Algorithms (0x0100-0x01FF)

  • Hybrid (0x0100): Hybrid: ML-KEM-1024 + X25519 + ML-DSA-87 + Ed25519 + AES-256-GCM

Post-Quantum Algorithms (0x0200-0x02FF)

  • Post-Quantum (0x0200): Post-quantum: ML-KEM-1024 + ML-DSA-87 + AES-256-GCM
  • Multi-Algorithm (0x0201): Multi-algorithm runtime selection
  • ML-KEM-1024 (0x0202): ML-KEM-1024 with AES-256-GCM
  • Multi-KEM Dual Layer (0x0203): Multi-KEM dual layer
  • Multi-KEM Triple Layer (0x0204): Multi-KEM triple layer
  • Quad-Layer (0x0205): Quad-layer redundant security
  • Lattice-Code Hybrid (0x0206): Lattice-Code hybrid stack
  • PQ3-Stack (0x0207): PQ3-Stack with forward secrecy
  • X25519MLKEM768 (0x0208): X-Wing hybrid KEM: ML-KEM-768 (FIPS 203) combined with X25519, the pair TLS negotiates as X25519MLKEM768
  • FrodoKEM-1344 (0x0209): FrodoKEM-1344: unstructured-lattice KEM, NIST level 5 (ISO/IEC 18033-2)
  • Classic-McEliece-6960119 (0x020A): Classic McEliece 6960119: code-based KEM (ISO/IEC 18033-2)
  • FrodoKEM-976 (0x020B): FrodoKEM-976: unstructured-lattice KEM, NIST level 3

Max Secure Series (0x0300-0x03FF)

  • Max Secure: PQ Lightweight (0x0300): Max Secure: PQ Lightweight
  • Max Secure: Pure PQ (0x0301): Max Secure: Pure PQ
  • Max Secure: Hybrid (0x0302): Max Secure: Hybrid Transition
  • Max Secure: Stateless (0x0303): Max Secure: Stateless
  • Max Secure: Crypto-Agile (0x0304): Max Secure: Crypto-Agile
  • Max Secure: PQC + ZK (0x0305): Max Secure: PQC + Zero-Knowledge
  • Max Secure: Hybrid Transition (0x0306): Max Secure: Hybrid Transition

FN-DSA Series, Falcon-based (0x0400-0x04FF)

  • FN-DSA 512: Compact (0x0400): FN-DSA 512: Compact
  • FN-DSA 1024: High-Security (0x0401): FN-DSA 1024: High-Security
  • FN-DSA: Floating-Point Hardened (0x0402): FN-DSA: Floating-Point Hardened
  • FN-DSA: Dual Signature (0x0403): FN-DSA: Dual Signature
  • FN-DSA: Transition Stack (0x0404): FN-DSA: Transition Stack
  • FN-DSA + ZK Stack (0x0405): FN-DSA + Zero-Knowledge Stack
  • FN-DSA + ZK Stack Enhanced (0x0406): FN-DSA + ZK Stack Enhanced
  • FN-DSA: Transition Stack Enhanced (0x0407): FN-DSA: Transition Stack Enhanced

Experimental (0x0500-0x05FF)

  • Quantum-Inspired Lattice Fusion (0x0500): Quantum-Inspired Lattice Fusion
  • Post-ZK Homomorphic (0x0501): Post-ZK Homomorphic with LFHE 2023
  • Quantum-Resistant Consensus (0x0502): Quantum-Resistant Consensus
  • Entropy-Orchestrated (0x0503): Entropy-Orchestrated PQ Stack
  • Lattice-Code Hybrid FN (0x0504): Lattice-Code Hybrid FN
  • AI-Synthesized Crypto-Agile (0x0505): AI-Synthesized Crypto-Agile
  • Experimental Engine (0x0506): Experimental Engine (generic)

HQC Code-Based Series, NIST 2025 Backup KEM (0x0600-0x06FF)

  • HQC-128 (0x0600): HQC-128 (NIST Level 1, 128-bit security)
  • HQC-192 (0x0601): HQC-192 (NIST Level 3, 192-bit security)
  • HQC-256 (0x0602): HQC-256 (NIST Level 5, 256-bit security)

NIST ML-KEM Variants - FIPS 203 (0x0700-0x07FF)

  • ML-KEM-512 (0x0700): ML-KEM-512 (NIST Level 1, 128-bit security)
  • ML-KEM-768 (0x0701): ML-KEM-768 (NIST Level 3, 192-bit security)

NIST ML-DSA Variants - FIPS 204 (0x0800-0x08FF)

  • ML-DSA-44 (0x0800): ML-DSA-44 (NIST Level 2, 128-bit security)
  • ML-DSA-65 (0x0801): ML-DSA-65 (NIST Level 3, 192-bit security)
  • ML-DSA-87 (0x0802): ML-DSA-87 (NIST Level 5, 256-bit security)

NIST SLH-DSA Variants - FIPS 205 (0x0900-0x09FF)

  • SLH-DSA-SHA2-128s (0x0900): SLH-DSA-SHA2-128s (NIST Level 1, small signatures)
  • SLH-DSA-SHA2-128f (0x0901): SLH-DSA-SHA2-128f (NIST Level 1, fast signatures)
  • SLH-DSA-SHA2-192s (0x0902): SLH-DSA-SHA2-192s (NIST Level 3, small signatures)
  • SLH-DSA-SHA2-192f (0x0903): SLH-DSA-SHA2-192f (NIST Level 3, fast signatures)
  • SLH-DSA-SHA2-256s (0x0904): SLH-DSA-SHA2-256s (NIST Level 5, small signatures)
  • SLH-DSA-SHA2-256f (0x0905): SLH-DSA-SHA2-256f (NIST Level 5, fast signatures)

View full algorithm list

🎯 Features

Feature Flags

Control optional behavior with feature flags:

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

let flags = FormatFlags::new()
    .with_compression()       // Data was compressed before encryption
    .with_streaming()         // Streaming encryption mode
    .with_additional_auth();  // Additional authentication layer

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

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

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

Metadata Structure

The format includes rich metadata for decryption:

use pqc_binary_format::{PqcMetadata, KemParameters, SigParameters, EncParameters, CompressionParameters};
use std::collections::HashMap;

let metadata = PqcMetadata {
    // Key Encapsulation (optional)
    kem_params: Some(KemParameters {
        public_key: vec![/* ML-KEM public key */],
        ciphertext: vec![/* encapsulated key */],
        params: HashMap::new(),
    }),

    // Digital Signature (optional)
    sig_params: Some(SigParameters {
        public_key: vec![/* ML-DSA public key */],
        signature: vec![/* signature bytes */],
        params: HashMap::new(),
    }),

    // Symmetric Encryption (required)
    enc_params: EncParameters {
        iv: vec![1; 12],              // Nonce/IV
        tag: vec![1; 16],             // AEAD auth tag
        params: HashMap::new(),
    },

    // Compression (optional)
    compression_params: Some(CompressionParameters {
        algorithm: "zstd".to_string(),
        level: 3,
        original_size: 1024,
        params: HashMap::new(),
    }),

    // Custom parameters (extensible)
    custom: HashMap::new(),
};

Custom Parameters

Add your own metadata:

use pqc_binary_format::PqcMetadata;

let mut metadata = PqcMetadata::new();
metadata.add_custom("my_param".to_string(), vec![1, 2, 3]);

// Later...
if let Some(value) = metadata.get_custom("my_param") {
    println!("Custom param: {:?}", value);
}

🔍 Integrity Verification

Every format includes a SHA-256 checksum calculated over all fields:

use pqc_binary_format::PqcBinaryFormat;

let bytes = format.to_bytes().unwrap();

// Tamper with the data
// let mut corrupted = bytes.clone();
// corrupted[50] ^= 0xFF;

// Deserialization automatically verifies checksum
match PqcBinaryFormat::from_bytes(&bytes) {
    Ok(format) => println!("✓ Checksum valid"),
    Err(e) => println!("✗ Checksum failed: {}", e),
}

📚 Examples

Example 1: Basic Encryption Format

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

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

    let format = PqcBinaryFormat::new(
        Algorithm::Hybrid,
        metadata,
        vec![/* your encrypted data */],
    );

    // Save to file
    let bytes = format.to_bytes().unwrap();
    std::fs::write("encrypted.pqc", &bytes).unwrap();

    // Load from file
    let loaded_bytes = std::fs::read("encrypted.pqc").unwrap();
    let loaded = PqcBinaryFormat::from_bytes(&loaded_bytes).unwrap();

    println!("Algorithm: {}", loaded.algorithm().name());
}

Example 2: Cross-Language Interoperability

Rust (Encryption)

let format = PqcBinaryFormat::new(Algorithm::PostQuantum, metadata, data);
let bytes = format.to_bytes().unwrap();
// Send bytes to Python/JavaScript/Go/C++

Python (Decryption)

from pqc_binary_format import PqcBinaryFormat

format = PqcBinaryFormat.from_bytes(bytes)
print(f"Algorithm: {format.algorithm.name}")
print(f"Data: {len(format.data)} bytes")

JavaScript (Decryption)

const format = WasmPqcBinaryFormat.fromBytes(bytes);
console.log(`Algorithm: ${format.algorithm.name}`);
console.log(`Data: ${format.data.length} bytes`);

Go (Decryption)

format, _ := pqc.FromBytes(bytes)
defer format.Free()
fmt.Printf("Algorithm: %s\n", format.GetAlgorithmName())
fmt.Printf("Data: %d bytes\n", len(format.GetData()))

Example 3: Algorithm Migration

// Old data encrypted with Classical algorithm
let old_format = PqcBinaryFormat::from_bytes(&old_encrypted_data)?;
assert_eq!(old_format.algorithm(), Algorithm::Classical);

// Re-encrypt with Post-Quantum algorithm
let plaintext = decrypt_with_classical(&old_format)?;
let new_metadata = create_pq_metadata()?;
let new_format = PqcBinaryFormat::new(
    Algorithm::PostQuantum,
    new_metadata,
    encrypt_with_pq(&plaintext)?,
);

// Same format, different algorithm!

🎓 Use Cases

1. Cross-Platform Encryption

Encrypt in Rust, decrypt in Python, JavaScript, or Go using the same format.

2. Long-Term Archival

Self-describing format ensures data can be decrypted decades later even as algorithms evolve.

3. Algorithm Agility

Switch between algorithms without changing application code.

4. Compliance & Audit

Embedded metadata provides audit trail for regulatory compliance (GDPR, HIPAA, etc.).

5. Research & Benchmarking

Standardized format enables fair comparison of PQC algorithm performance.

🧪 Testing

# Run tests
cargo test

# Run tests with output
cargo test -- --nocapture

# Run specific test
cargo test test_binary_format_roundtrip

📊 Benchmarks

# Run benchmarks
cargo bench

# View benchmark results
open target/criterion/report/index.html

Performance characteristics:

  • Serialization: ~50 MB/s for typical payloads
  • Deserialization: ~45 MB/s (includes checksum verification)
  • Overhead: ~100 bytes + metadata size

🔧 Development

Building from Source

git clone https://github.com/PQCrypta/pqc-binary-format.git
cd pqc-binary-format
cargo build --release

Running Examples

cargo run --example basic_usage
cargo run --example with_compression
cargo run --example cross_platform

🤝 Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

Current Status

  • Language Bindings: ✅ Rust (native, tested on Linux, macOS and Windows), ✅ Python, ✅ JavaScript/WASM, ✅ Go, ✅ C/C++: every binding's example is built and run by CI's bindings job on every pull request
  • Examples: ✅ 9 validated examples across 6 languages
  • Package Distribution: ✅ All platforms published! crates.io, PyPI, npm, pkg.go.dev

Areas for Contribution

  • Additional Language Bindings: Java, C#, Ruby, Swift, Kotlin - help us expand!
  • Documentation: Tutorials, integration guides, video walkthroughs
  • Testing: Additional test cases, fuzzing, property-based testing
  • Performance: SIMD optimizations, benchmark improvements
  • Standards: Help draft RFC for IETF standardization submission

📄 License

Licensed under either of:

at your option.

🙏 Acknowledgments

This format was developed as part of the PQCrypta enterprise post-quantum cryptography platform. Special thanks to:

  • NIST Post-Quantum Cryptography Project
  • The Rust cryptography community
  • Contributors to pqcrypto, ring, and other foundational crates

📖 References

💬 Community & Support


Made with ❤️ by the PQCrypta Community

Securing the future, one byte at a time.

Metadata

Release files for pqc-binary-format 3.0.1

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for pqc-binary-format 3.0.1
File Size Uploaded Provenance Actions
pqc_binary_format-3.0.1.tar.gz 97.3 kB With provenance Details for pqc_binary_format-3.0.1.tar.gz

Built distributions (wheels)

Table of built distributions (wheels) for pqc-binary-format 3.0.1
File Actions
pqc_binary_format-3.0.1-cp310-abi3-win_amd64.whl CPython 3.10 abi3 Windows x86-64 Details for pqc_binary_format-3.0.1-cp310-abi3-win_amd64.whl
pqc_binary_format-3.0.1-cp310-abi3-musllinux_1_2_x86_64.whl CPython 3.10 abi3 Linux musl 1.2+ x86-64 Details for pqc_binary_format-3.0.1-cp310-abi3-musllinux_1_2_x86_64.whl
pqc_binary_format-3.0.1-cp310-abi3-musllinux_1_2_aarch64.whl CPython 3.10 abi3 Linux musl 1.2+ ARM64 Details for pqc_binary_format-3.0.1-cp310-abi3-musllinux_1_2_aarch64.whl
pqc_binary_format-3.0.1-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl CPython 3.10 abi3 Linux glibc 2.17+ x86-64 Details for pqc_binary_format-3.0.1-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
pqc_binary_format-3.0.1-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl CPython 3.10 abi3 Linux glibc 2.17+ ARM64 Details for pqc_binary_format-3.0.1-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl
pqc_binary_format-3.0.1-cp310-abi3-macosx_11_0_arm64.whl CPython 3.10 abi3 macOS 11.0+ ARM64 Details for pqc_binary_format-3.0.1-cp310-abi3-macosx_11_0_arm64.whl
pqc_binary_format-3.0.1-cp310-abi3-macosx_10_12_x86_64.whl CPython 3.10 abi3 macOS 10.12+ x86-64 Details for pqc_binary_format-3.0.1-cp310-abi3-macosx_10_12_x86_64.whl

Total release size: 2.7 MB

Release files / pqc_binary_format-3.0.1.tar.gz

Download URL pqc_binary_format-3.0.1.tar.gz
Size 97.3 kB
Tags Source
SHA-256 checksum
How to use checksums
26d528a2b6495c5c0995a9869d68f4f2b289fa7e57a20ec270f8a5c59180fb4d
BLAKE2b-256 checksum
How to use checksums
73153e64f07654fb8c4d5158a78628eb51348d6fc9ffa74eef7ab6151fb4518c
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.14

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 15, 2026.

Transparency log

Release files / pqc_binary_format-3.0.1-cp310-abi3-win_amd64.whl

Download URL pqc_binary_format-3.0.1-cp310-abi3-win_amd64.whl
Size 233.0 kB
Tags CPython 3.10 Windows x86-64 abi3
SHA-256 checksum
How to use checksums
485ea2cde95849477a2b7676936262d15ad93143244b92a05fba7619044f76a5
BLAKE2b-256 checksum
How to use checksums
ee2aa8beb53455f967b3b967ad6f1ffed71ecb319a1be5a8b8deab32beab2467
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.14

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 15, 2026.

Transparency log

Release files / pqc_binary_format-3.0.1-cp310-abi3-musllinux_1_2_x86_64.whl

Download URL pqc_binary_format-3.0.1-cp310-abi3-musllinux_1_2_x86_64.whl
Size 559.4 kB
Tags CPython 3.10 Linux musl 1.2+ x86-64 abi3
SHA-256 checksum
How to use checksums
b9c9225224c6015522d944dec8f099bb0d5d23f056660d0823bff2b3eff8e0fe
BLAKE2b-256 checksum
How to use checksums
63562fa66e80e828bd91bc28c43ee315bedd76206edb583c86a14c91650d7bd2
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.14

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 15, 2026.

Transparency log

Release files / pqc_binary_format-3.0.1-cp310-abi3-musllinux_1_2_aarch64.whl

Download URL pqc_binary_format-3.0.1-cp310-abi3-musllinux_1_2_aarch64.whl
Size 520.1 kB
Tags CPython 3.10 Linux musl 1.2+ ARM64 abi3
SHA-256 checksum
How to use checksums
301f410a1f9851fc525127b6917c779993be383eecf46d9db684efd4b936c68c
BLAKE2b-256 checksum
How to use checksums
54e11f71bc21a5d47767ba17922c5299878b1cbd6da13a22f30d20bacbfcf11d
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.14

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 15, 2026.

Transparency log

Release files / pqc_binary_format-3.0.1-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

Download URL pqc_binary_format-3.0.1-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
Size 348.1 kB
Tags CPython 3.10 Linux glibc 2.17+ x86-64 abi3
SHA-256 checksum
How to use checksums
fca39d5b8238b76ed63e156b29cce23a0d02f52531338ffe46f46bacc8ce34ae
BLAKE2b-256 checksum
How to use checksums
9ecbd160fe383104c36e3417b8a3296b63a54f02f134a9611318569d423c5a34
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.14

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 15, 2026.

Transparency log

Release files / pqc_binary_format-3.0.1-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

Download URL pqc_binary_format-3.0.1-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl
Size 341.9 kB
Tags CPython 3.10 Linux glibc 2.17+ ARM64 abi3
SHA-256 checksum
How to use checksums
bc6b25f8de75e4e0ffe011c90863831fe08eb3567ded1a5a2abd4c87fa2568f0
BLAKE2b-256 checksum
How to use checksums
f4914a329ae8f00cbd5814324274077c7108f11922df3d71dbedb37e175c49d4
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.14

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 15, 2026.

Transparency log

Release files / pqc_binary_format-3.0.1-cp310-abi3-macosx_11_0_arm64.whl

Download URL pqc_binary_format-3.0.1-cp310-abi3-macosx_11_0_arm64.whl
Size 318.2 kB
Tags CPython 3.10 abi3 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
44ec34065997bb80e5d0c777625de9be9ac4db9f377820258d1c552c38e43ae2
BLAKE2b-256 checksum
How to use checksums
f0d573032b63268135d942abc648b2ca47bce5c08f3e552f911259b1eeadd3c2
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.14

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 15, 2026.

Transparency log

Release files / pqc_binary_format-3.0.1-cp310-abi3-macosx_10_12_x86_64.whl

Download URL pqc_binary_format-3.0.1-cp310-abi3-macosx_10_12_x86_64.whl
Size 330.6 kB
Tags CPython 3.10 abi3 macOS 10.12+ x86-64
SHA-256 checksum
How to use checksums
5114143d6af6fe0f9a800ba13d35cdd9d6de96831c47731388fe28a6e6f90751
BLAKE2b-256 checksum
How to use checksums
ad814a8fe84034c405f3e3c5a5430e903868cc6f77ee809a251338844dd8c770
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.14

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 15, 2026.

Transparency log

Security for pqc-binary-format 3.0.1

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

All 8 files in this release have been uploaded with provenance metadata.

Select from 8 files

Attestation for pqc_binary_format-3.0.1.tar.gz

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 15, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page