vortex-pqc 1.0.0

VORTEX-256: Novel post-quantum KEM based on Rotational Module LWE (RotMLWE)

VORTEX-256

A new lattice KEM built on Rotational Module Learning With Errors
_{Same footprint as Kyber-512 · Entirely different mathematics · Standalone library
A Bajpai Labs project · postquantumlabs.in/library/vortex-pqc}

                              ╭──────────────────────────────────────╮
                              │                                      │
         ρ  ──▶  a₀ ──σ──▶  a₁ ──σ──▶  a₂ ──σ──▶  …               │
                              │         Frobenius orbit              │
                              │         of a single ring element     │
                              ╰──────────────────────────────────────╯
                                           │
                              bᵢ = aᵢ · s + eᵢ     (K correlated instances)
                                           │
                              pk  ·  ct  ·  32-byte shared secret

✦ At a glance

The invention ML-KEM samples a full k×k matrix of random ring elements. VORTEX-256 samples one element a, then derives the public structure from its Frobenius orbit: σ : f(x) ↦ f(x³ mod x²⁵⁶+1) a₀ = a a₁ = σ(a₀) bᵢ = aᵢ · s + eᵢ One secret s. K rotations. A new hardness assumption — RotMLWE.

The footprint Identical wire sizes to Kyber-512 — drop-in at the byte level. Object Size Public key 800 B Private key 1 248 B Ciphertext 768 B Shared secret 32 B Kyber-512 VORTEX-256 XOF calls at keygen 4 1 Secret type vector scalar Assumption MLWE RotMLWE

✦ Install

pip install vortex-pqc

No runtime dependencies. Compiles an optional native extension when a C toolchain is present; otherwise falls back to a pure-Python reference.

✦ Thirty seconds to a shared secret

from vortex_pqc import generate_keypair, encapsulate, decapsulate

alice = generate_keypair()
bob   = encapsulate(alice.public_key)

# bob sends bob.data (768 B) to alice
alice_secret = decapsulate(bob.data, alice.private_key)

assert alice_secret == bob.shared_secret   # both parties agree

✦ How the exchange works

sequenceDiagram
    participant Alice
    participant Bob

    Note over Alice: generate_keypair()
    Alice->>Alice: pk (800 B) · sk (1248 B)

    Alice->>Bob: public key

    Note over Bob: encapsulate(pk)
    Bob->>Bob: ct (768 B) · ss (32 B)

    Bob->>Alice: ciphertext

    Note over Alice: decapsulate(ct, sk)
    Alice->>Alice: ss (32 B)

    Note over Alice,Bob: shared secrets match

✦ PEM keys

Standard Base64 PEM — compatible with everyday tooling.

from vortex_pqc import PEMKind, write_pem_file, read_pem_file

write_pem_file("key.pem", PEMKind.PRIVATE_KEY, alice.private_key)
sk = read_pem_file("key.pem", PEMKind.PRIVATE_KEY)

-----BEGIN VORTEX256 PRIVATE KEY-----
AQDQABAAABAAAA0AAAAAAPDP/gzQAhAAAAAAAA3QAA0AAPDPAQAAASAAAADQ/wwA
...
-----END VORTEX256 PRIVATE KEY-----

Private key files are written with mode 0600.

✦ C library

cd c && make lib && make test && make demo

#include "vortex_pqc.h"

uint8_t pk[VORTEX_PUBLIC_KEY_BYTES];
uint8_t sk[VORTEX_PRIVATE_KEY_BYTES];
uint8_t ct[VORTEX_CIPHERTEXT_BYTES];
uint8_t ss[VORTEX_SHARED_SECRET_BYTES];

vortex_keypair(pk, sk);
vortex_enc(pk, ct, ss);
vortex_dec(ct, sk, ss);

✦ Documentation

Library home → · Full documentation → · Published docs →

Enterprise: Bajpai Labs

Guide	For	You'll learn
Overview	Everyone	What VORTEX is, design goals, positioning
Quickstart	Users	Install, first exchange, PEM files
Integration guide	Developers	Client–server protocol, session keys
Core concepts	Learners	KEM, RotMLWE, Frobenius, FO transform
Security model	Security engineers	Threat model, guarantees, limitations
API reference	Integrators	Python and C API, byte layouts
Comparison	Evaluators	vs ML-KEM, NTRU, other PQC
FAQ	Everyone	Common questions answered

✦ For developers

git clone https://github.com/bajpai-labs/vortex-pqc.git
cd vortex-pqc
python3 -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"
make test

→ Full workflow in the Development Guide

✦ Security

Research prototype. VORTEX-256 introduces a novel hardness assumption that has not received the years of independent cryptanalysis behind NIST-standardised ML-KEM. Suitable for research, education, and prototyping. Not recommended for production without a formal security review.

✦ Related

This project is fully independent from Kyber-PQC (ML-KEM-512).

---

Institutional Backing & Maintenance

Post-Quantum Labs is an open-source research and development initiative of Bajpai Labs. All frameworks, kernel-level optimizations, and cryptographic implementations hosted here are engineered and maintained by our core systems architecture team.

Operational Hub	Technical Documentation

Enterprise Support & Custom Integrations: Need deterministic sub-microsecond performance, hardware-software co-design, or custom PQC migration frameworks? Contact our corporate consulting arm at Bajpai Labs.

---

Maintenance & Ownership

This library is part of the open-source ecosystem developed by Post-Quantum Labs, a wholly-owned division of Bajpai Labs.

• Primary Corporate Hub: https://bajpailabs.com
• Documentation & Benchmarks: https://postquantumlabs.com
• Inquiries: [e-mail] / [e-mail]

License

MIT License. See LICENSE for details.