quant-bvz-secure 0.1.0__py3-none-any.whl

qcrypt/__init__.py

@@ -0,0 +1,27 @@
+"""
+qcrypt — biblioteka kryptograficzna łącząca:
+  1) Post-Quantum Cryptography (PQC) — realne algorytmy odporne na komputery
+     kwantowe (Kyber/ML-KEM, Dilithium/ML-DSA przez liboqs, jeśli dostępne).
+  2) Symulator QKD (BB84) — edukacyjna symulacja kwantowej dystrybucji klucza.
+  3) Warstwę symetryczną AEAD (AES-256-GCM) do faktycznego szyfrowania danych.
+
+WAŻNE: moduł qkd to symulacja matematyczna protokołu BB84 na klasycznym
+komputerze — nie wykonuje żadnych operacji na prawdziwym sprzęcie kwantowym,
+chyba że podłączysz backend Qiskit (patrz qcrypt.qkd.backend).
+"""
+
+__version__ = "0.1.0"
+
+from qcrypt.symmetric.aead import AEAD
+from qcrypt.pqc.hybrid import HybridKEM
+from qcrypt.qkd.bb84 import BB84Protocol
+from qcrypt.exceptions import QCryptError, PQCUnavailableError, EavesdropDetected
+
+__all__ = [
+    "AEAD",
+    "HybridKEM",
+    "BB84Protocol",
+    "QCryptError",
+    "PQCUnavailableError",
+    "EavesdropDetected",
+]

qcrypt/cli.py

@@ -0,0 +1,118 @@
+"""
+Prosty interfejs wiersza poleceń do demonstracji biblioteki qcrypt.
+
+Użycie:
+    python -m qcrypt.cli bb84-demo [--qubits N] [--eve] [--noise 0.02]
+    python -m qcrypt.cli hybrid-demo
+    python -m qcrypt.cli encrypt --key-hex <hex> --in plik.txt --out plik.enc
+    python -m qcrypt.cli decrypt --key-hex <hex> --in plik.enc --out plik.txt
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from qcrypt.qkd.bb84 import BB84Protocol
+from qcrypt.qkd.channel import QuantumChannel
+from qcrypt.pqc.hybrid import HybridKEM
+from qcrypt.symmetric.aead import AEAD
+
+
+def cmd_bb84_demo(args: argparse.Namespace) -> None:
+    channel = QuantumChannel(eavesdropper=args.eve, noise_level=args.noise)
+    protocol = BB84Protocol(channel=channel, n_qubits=args.qubits)
+    result = protocol.run()
+
+    print(f"Wysłane kubity:        {result.raw_key_length}")
+    print(f"Po sifting:            {result.sifted_key_length}")
+    print(f"Estymowany QBER:       {result.qber:.2%}")
+    print(f"Eve przechwytywała:    {'TAK' if args.eve else 'NIE'}")
+    print(f"Wykryto podsłuch:      {'TAK' if result.eavesdropper_detected else 'NIE'}")
+    if not result.eavesdropper_detected:
+        print(f"Finalny klucz (hex):   {result.shared_key.hex()}")
+    else:
+        print("Klucz ODRZUCONY — kanał uznany za skompromitowany.")
+
+
+def cmd_hybrid_demo(args: argparse.Namespace) -> None:
+    bob = HybridKEM(classical_only=args.classical_only)
+    bundle = bob.generate_keypair()
+
+    ciphertext, alice_secret = HybridKEM.encapsulate(bundle)
+    bob_secret = bob.decapsulate(ciphertext)
+
+    print(f"Tryb:                  {'tylko klasyczny (X25519)' if bob.classical_only else 'hybrydowy (X25519 + Kyber)'}")
+    print(f"Sekret Alice (hex):    {alice_secret.hex()}")
+    print(f"Sekret Boba (hex):     {bob_secret.hex()}")
+    print(f"Sekrety zgodne:        {'TAK' if alice_secret == bob_secret else 'NIE'}")
+
+    cipher = AEAD(key=alice_secret)
+    blob = cipher.encrypt(b"Wiadomosc zaszyfrowana wspolnym sekretem")
+    decrypted = AEAD(key=bob_secret).decrypt(blob)
+    print(f"Test AEAD:             {decrypted.decode('utf-8')}")
+
+
+def cmd_encrypt(args: argparse.Namespace) -> None:
+    key = bytes.fromhex(args.key_hex)
+    with open(args.infile, "rb") as f:
+        data = f.read()
+    blob = AEAD(key=key).encrypt(data)
+    with open(args.outfile, "wb") as f:
+        f.write(blob)
+    print(f"Zaszyfrowano -> {args.outfile}")
+
+
+def cmd_decrypt(args: argparse.Namespace) -> None:
+    key = bytes.fromhex(args.key_hex)
+    with open(args.infile, "rb") as f:
+        blob = f.read()
+    data = AEAD(key=key).decrypt(blob)
+    with open(args.outfile, "wb") as f:
+        f.write(data)
+    print(f"Odszyfrowano -> {args.outfile}")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="qcrypt", description="Demo biblioteki qcrypt")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_bb84 = sub.add_parser("bb84-demo", help="Symulacja protokołu BB84")
+    p_bb84.add_argument("--qubits", type=int, default=1024)
+    p_bb84.add_argument("--eve", action="store_true", help="Włącz symulowanego podsłuchującego")
+    p_bb84.add_argument("--noise", type=float, default=0.0, help="Poziom szumu kanału 0.0-1.0")
+    p_bb84.set_defaults(func=cmd_bb84_demo)
+
+    p_hybrid = sub.add_parser("hybrid-demo", help="Hybrydowa wymiana kluczy X25519+Kyber")
+    p_hybrid.add_argument("--classical-only", action="store_true",
+                           help="Wymuś tryb bez PQC (gdy liboqs niedostępne)")
+    p_hybrid.set_defaults(func=cmd_hybrid_demo)
+
+    p_enc = sub.add_parser("encrypt", help="Zaszyfruj plik AES-256-GCM")
+    p_enc.add_argument("--key-hex", required=True)
+    p_enc.add_argument("--in", dest="infile", required=True)
+    p_enc.add_argument("--out", dest="outfile", required=True)
+    p_enc.set_defaults(func=cmd_encrypt)
+
+    p_dec = sub.add_parser("decrypt", help="Odszyfruj plik")
+    p_dec.add_argument("--key-hex", required=True)
+    p_dec.add_argument("--in", dest="infile", required=True)
+    p_dec.add_argument("--out", dest="outfile", required=True)
+    p_dec.set_defaults(func=cmd_decrypt)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        args.func(args)
+    except Exception as exc:
+        print(f"Blad: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

qcrypt/exceptions.py

@@ -0,0 +1,22 @@
+"""Wyjątki używane w całej bibliotece qcrypt."""
+
+
+class QCryptError(Exception):
+    """Bazowy wyjątek biblioteki."""
+
+
+class PQCUnavailableError(QCryptError):
+    """Podnoszony, gdy biblioteka liboqs-python (moduł `oqs`) nie jest
+    zainstalowana, a wywołany kod wymaga prawdziwego algorytmu PQC
+    (Kyber/ML-KEM, Dilithium/ML-DSA)."""
+
+
+class EavesdropDetected(QCryptError):
+    """Podnoszony przez symulator BB84, gdy poziom błędów (QBER) w próbce
+    kontrolnej przekracza bezpieczny próg, co sugeruje podsłuch kanału
+    kwantowego."""
+
+
+class DecryptionError(QCryptError):
+    """Podnoszony, gdy odszyfrowanie/uwierzytelnienie AEAD się nie powiedzie
+    (zły klucz, uszkodzone dane lub próba manipulacji)."""

qcrypt/keystore.py

@@ -0,0 +1,123 @@
+"""
+Magazyn kluczy — serializacja kluczy publicznych/sekretów do plików JSON
+(dane binarne kodowane base64). Nie przechowuje kluczy prywatnych obiektów
+oqs/cryptography bezpośrednio (te żyją tylko w pamięci procesu) — przechowuje
+surowe bajty.
+
+Domyślnie (bez podania hasła) plik jest plaintext-base64 — wygodne do
+szybkich testów/demo, ale NIE do produkcji. Podając `password`, cały
+zawartość magazynu jest szyfrowana AES-256-GCM kluczem wyprowadzonym z hasła
+przez Scrypt (odpornym na ataki brute-force na GPU/ASIC), przy użyciu
+istniejącej klasy `AEAD`. Plik na dysku jest wtedy dodatkowo chroniony
+uprawnieniami 0600 (tylko właściciel może czytać/pisać).
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+from pathlib import Path
+
+from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
+
+from qcrypt.symmetric.aead import AEAD
+from qcrypt.exceptions import DecryptionError
+
+SALT_SIZE = 16
+SCRYPT_N = 2**16   # koszt CPU/pamięci — bezpieczny domyślny poziom (2026)
+SCRYPT_R = 8
+SCRYPT_P = 1
+SCRYPT_KEY_LEN = 32
+
+
+class KeyStore:
+    """
+    Przykład bez hasła (plaintext — tylko do testów/demo):
+        store = KeyStore("keys.json")
+        store.save("bob_public", public_key_bytes)
+        pub = store.load("bob_public")
+
+    Przykład z hasłem (zaszyfrowany magazyn — zalecane produkcyjnie):
+        store = KeyStore("keys.json", password="korzen-slonecznik-42")
+        store.save("bob_secret", secret_key_bytes)
+        secret = store.load("bob_secret")
+    """
+
+    def __init__(self, path: str | Path, *, password: str | None = None):
+        self.path = Path(path)
+        self._password = password
+        self._salt: bytes | None = None
+        self._data: dict[str, str] = {}
+
+        if self.path.exists():
+            self._load_from_disk()
+        elif password is not None:
+            self._salt = os.urandom(SALT_SIZE)
+
+    @property
+    def is_encrypted(self) -> bool:
+        return self._password is not None
+
+    def save(self, name: str, key_bytes: bytes) -> None:
+        self._data[name] = base64.b64encode(key_bytes).decode("ascii")
+        self._flush()
+
+    def load(self, name: str) -> bytes:
+        if name not in self._data:
+            raise KeyError(f"Brak klucza o nazwie '{name}' w {self.path}")
+        return base64.b64decode(self._data[name])
+
+    def delete(self, name: str) -> None:
+        self._data.pop(name, None)
+        self._flush()
+
+    def list_keys(self) -> list[str]:
+        return list(self._data.keys())
+
+    # -- szyfrowanie magazynu na dysku -------------------------------------
+
+    def _derive_master_key(self, salt: bytes) -> bytes:
+        assert self._password is not None
+        kdf = Scrypt(salt=salt, length=SCRYPT_KEY_LEN, n=SCRYPT_N, r=SCRYPT_R, p=SCRYPT_P)
+        return kdf.derive(self._password.encode("utf-8"))
+
+    def _load_from_disk(self) -> None:
+        raw = self.path.read_bytes()
+
+        if self._password is None:
+            # tryb plaintext (kompatybilność wsteczna / demo)
+            self._data = json.loads(raw.decode("utf-8"))
+            return
+
+        if len(raw) < SALT_SIZE:
+            raise DecryptionError(f"Plik {self.path} jest za krótki, brak salt.")
+        salt, blob = raw[:SALT_SIZE], raw[SALT_SIZE:]
+        self._salt = salt
+        master_key = self._derive_master_key(salt)
+        try:
+            plaintext = AEAD(key=master_key).decrypt(blob)
+        except DecryptionError as exc:
+            raise DecryptionError(
+                f"Nie udało się odszyfrować magazynu {self.path} — błędne hasło "
+                "lub plik został uszkodzony/zmanipulowany."
+            ) from exc
+        self._data = json.loads(plaintext.decode("utf-8"))
+
+    def _flush(self) -> None:
+        tmp_path = self.path.with_suffix(".tmp")
+        payload = json.dumps(self._data, indent=2).encode("utf-8")
+
+        if self._password is not None:
+            if self._salt is None:
+                self._salt = os.urandom(SALT_SIZE)
+            master_key = self._derive_master_key(self._salt)
+            payload = self._salt + AEAD(key=master_key).encrypt(payload)
+
+        # Uprawnienia 0600 od razu przy tworzeniu pliku (nie po fakcie —
+        # unikamy okna czasowego, w którym plik byłby czytelny dla innych).
+        fd = os.open(tmp_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "wb") as f:
+            f.write(payload)
+        os.replace(tmp_path, self.path)
+        os.chmod(self.path, 0o600)

qcrypt/pqc/__init__.py

@@ -0,0 +1,5 @@
+from qcrypt.pqc.hybrid import HybridKEM
+from qcrypt.pqc.kem import KyberKEM, PQC_AVAILABLE
+from qcrypt.pqc.signatures import DilithiumSigner
+
+__all__ = ["HybridKEM", "KyberKEM", "DilithiumSigner", "PQC_AVAILABLE"]

qcrypt/pqc/hybrid.py

@@ -0,0 +1,155 @@
+"""
+Hybrydowa wymiana klucza: X25519 (klasyczny, eliptyczny) + Kyber/ML-KEM
+(post-kwantowy), połączone przez HKDF w jeden wspólny sekret.
+
+To zalecany przez NIST tryb na okres przejściowy: jeśli Kyber okaże się mieć
+niewykrytą słabość, bezpieczeństwo nadal opiera się na X25519; jeśli komputery
+kwantowe złamią X25519, bezpieczeństwo nadal opiera się na Kyber. Atakujący
+musi złamać OBA, żeby odzyskać sekret.
+
+Jeśli liboqs-python nie jest zainstalowane, klasa może działać w trybie
+`classical_only=True` — tylko X25519, bez odporności kwantowej (jawnie
+oznaczone ostrzeżeniem).
+"""
+
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass
+
+from cryptography.hazmat.primitives.asymmetric.x25519 import (
+    X25519PrivateKey,
+    X25519PublicKey,
+)
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+from cryptography.hazmat.primitives import serialization
+
+from qcrypt.pqc.kem import KyberKEM, PQC_AVAILABLE, DEFAULT_ALGORITHM as KYBER_ALG
+
+
+@dataclass
+class HybridPublicBundle:
+    """To, co strona odpowiadająca wysyła do strony inicjującej połączenie."""
+
+    x25519_public: bytes
+    kyber_public: bytes | None  # None w trybie classical_only
+
+    def to_bytes(self) -> bytes:
+        kp = self.kyber_public or b""
+        return len(self.x25519_public).to_bytes(2, "big") + self.x25519_public + kp
+
+    @classmethod
+    def from_bytes(cls, blob: bytes) -> "HybridPublicBundle":
+        x_len = int.from_bytes(blob[:2], "big")
+        x25519_public = blob[2:2 + x_len]
+        kyber_public = blob[2 + x_len:] or None
+        return cls(x25519_public=x25519_public, kyber_public=kyber_public)
+
+
+@dataclass
+class HybridCiphertext:
+    """To, co strona inicjująca wysyła z powrotem po encapsulate()."""
+
+    x25519_ephemeral_public: bytes
+    kyber_ciphertext: bytes | None
+
+    def to_bytes(self) -> bytes:
+        kc = self.kyber_ciphertext or b""
+        return len(self.x25519_ephemeral_public).to_bytes(2, "big") + self.x25519_ephemeral_public + kc
+
+    @classmethod
+    def from_bytes(cls, blob: bytes) -> "HybridCiphertext":
+        x_len = int.from_bytes(blob[:2], "big")
+        x25519_ephemeral_public = blob[2:2 + x_len]
+        kyber_ciphertext = blob[2 + x_len:] or None
+        return cls(x25519_ephemeral_public=x25519_ephemeral_public, kyber_ciphertext=kyber_ciphertext)
+
+
+class HybridKEM:
+    """
+    Hybrydowa wymiana klucza X25519 + Kyber.
+
+    Strona odpowiadająca (Bob):
+        bob = HybridKEM()
+        bundle = bob.generate_keypair()          # -> wysyłamy do Alice
+
+    Strona inicjująca (Alice):
+        ciphertext, shared_secret = HybridKEM.encapsulate(bundle)  # -> ciphertext do Boba
+
+    Strona odpowiadająca:
+        shared_secret = bob.decapsulate(ciphertext)   # ten sam sekret co u Alice
+    """
+
+    def __init__(self, *, classical_only: bool = False):
+        self.classical_only = classical_only or not PQC_AVAILABLE
+        if self.classical_only and PQC_AVAILABLE is False and not classical_only:
+            warnings.warn(
+                "liboqs-python niedostępne — HybridKEM działa w trybie WYŁĄCZNIE "
+                "KLASYCZNYM (X25519), bez odporności na komputery kwantowe. "
+                "Zainstaluj 'liboqs-python', aby włączyć warstwę PQC.",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+        self._x25519_private = X25519PrivateKey.generate()
+        self._kyber = None if self.classical_only else KyberKEM()
+
+    def generate_keypair(self) -> HybridPublicBundle:
+        x_pub = self._x25519_private.public_key().public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw,
+        )
+        k_pub = None if self.classical_only else self._kyber.generate_keypair()
+        return HybridPublicBundle(x25519_public=x_pub, kyber_public=k_pub)
+
+    @staticmethod
+    def encapsulate(bundle: HybridPublicBundle) -> tuple[HybridCiphertext, bytes]:
+        """Strona inicjująca: zwraca (ciphertext_do_wyslania, wspolny_sekret)."""
+        # --- warstwa klasyczna: efemeryczny X25519 ---
+        ephemeral_private = X25519PrivateKey.generate()
+        ephemeral_public_bytes = ephemeral_private.public_key().public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw,
+        )
+        peer_public = X25519PublicKey.from_public_bytes(bundle.x25519_public)
+        x25519_secret = ephemeral_private.exchange(peer_public)
+
+        # --- warstwa post-kwantowa: Kyber (jeśli dostępna) ---
+        kyber_ciphertext = None
+        kyber_secret = b""
+        if bundle.kyber_public is not None:
+            kyber_ciphertext, kyber_secret = KyberKEM.encapsulate(
+                bundle.kyber_public, algorithm=KYBER_ALG
+            )
+
+        combined_secret = HybridKEM._combine(x25519_secret, kyber_secret)
+        ciphertext = HybridCiphertext(
+            x25519_ephemeral_public=ephemeral_public_bytes,
+            kyber_ciphertext=kyber_ciphertext,
+        )
+        return ciphertext, combined_secret
+
+    def decapsulate(self, ciphertext: HybridCiphertext) -> bytes:
+        """Strona odpowiadająca: odzyskuje ten sam wspólny sekret."""
+        peer_ephemeral = X25519PublicKey.from_public_bytes(ciphertext.x25519_ephemeral_public)
+        x25519_secret = self._x25519_private.exchange(peer_ephemeral)
+
+        kyber_secret = b""
+        if ciphertext.kyber_ciphertext is not None:
+            if self._kyber is None:
+                raise ValueError("Otrzymano ciphertext Kyber, ale ten KEM działa w trybie classical_only.")
+            kyber_secret = self._kyber.decapsulate(ciphertext.kyber_ciphertext)
+
+        return self._combine(x25519_secret, kyber_secret)
+
+    @staticmethod
+    def _combine(x25519_secret: bytes, kyber_secret: bytes) -> bytes:
+        """Łączy oba sekrety przez HKDF — standardowa konstrukcja hybrydowa
+        (zgodna z duchem zaleceń NIST/IETF dot. hybrydowego KEM)."""
+        hkdf = HKDF(
+            algorithm=hashes.SHA256(),
+            length=32,
+            salt=None,
+            info=b"qcrypt-hybrid-kem-v1",
+        )
+        return hkdf.derive(x25519_secret + kyber_secret)

qcrypt/pqc/kem.py

@@ -0,0 +1,96 @@
+"""
+Mechanizm uzgadniania klucza (KEM) odporny na komputery kwantowe.
+
+Owija bibliotekę `liboqs-python` (pakiet `oqs`), która dostarcza zaudytowane
+implementacje algorytmów kratowych, w tym Kyber / ML-KEM (standard NIST
+FIPS 203). Nie implementujemy tu własnej kryptografii kratowej — to zadanie
+zostawiamy zweryfikowanej bibliotece.
+
+Instalacja:
+    pip install liboqs-python
+(wymaga skompilowania biblioteki C `liboqs` — patrz README).
+
+Jeśli `oqs` nie jest zainstalowane, klasa `KyberKEM` jest zdefiniowana, ale
+każda próba jej użycia rzuca PQCUnavailableError z instrukcją instalacji.
+Dzięki temu reszta biblioteki (np. HybridKEM) może działać w trybie
+"tylko klasyczny" bez twardej zależności.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from qcrypt.exceptions import PQCUnavailableError
+
+try:
+    import oqs  # type: ignore
+
+    PQC_AVAILABLE = True
+except ImportError:
+    oqs = None  # type: ignore
+    PQC_AVAILABLE = False
+
+DEFAULT_ALGORITHM = "Kyber768"  # odpowiednik ML-KEM-768 (NIST poziom 3)
+
+
+@dataclass
+class KEMKeypair:
+    algorithm: str
+    public_key: bytes
+    # sekretny stan trzymany po stronie serwera oqs.KeyEncapsulation,
+    # niedostępny bezpośrednio — patrz KyberKEM._client
+
+
+class KyberKEM:
+    """
+    Wymiana klucza metodą Kyber/ML-KEM.
+
+    Przykład:
+        bob = KyberKEM()
+        public_key = bob.generate_keypair()
+
+        # Alice:
+        ciphertext, alice_secret = KyberKEM.encapsulate(public_key)
+
+        # Bob:
+        bob_secret = bob.decapsulate(ciphertext)
+        assert alice_secret == bob_secret
+    """
+
+    def __init__(self, algorithm: str = DEFAULT_ALGORITHM):
+        self._require_pqc()
+        self.algorithm = algorithm
+        self._kem = oqs.KeyEncapsulation(algorithm)
+        self._public_key: bytes | None = None
+
+    @staticmethod
+    def _require_pqc() -> None:
+        if not PQC_AVAILABLE:
+            raise PQCUnavailableError(
+                "Pakiet 'oqs' (liboqs-python) nie jest zainstalowany. "
+                "Zainstaluj: pip install liboqs-python "
+                "(wymaga skompilowanej biblioteki C liboqs). "
+                "Alternatywnie użyj HybridKEM w trybie 'classical_only=True', "
+                "który działa bez PQC (tylko X25519, bez odporności kwantowej)."
+            )
+
+    def generate_keypair(self) -> bytes:
+        """Generuje parę kluczy, zwraca klucz publiczny do przesłania drugiej stronie."""
+        self._public_key = self._kem.generate_keypair()
+        return self._public_key
+
+    @staticmethod
+    def encapsulate(public_key: bytes, algorithm: str = DEFAULT_ALGORITHM) -> tuple[bytes, bytes]:
+        """Strona inicjująca: na podstawie klucza publicznego drugiej strony
+        generuje (ciphertext, shared_secret). ciphertext wysyłamy do właściciela
+        klucza publicznego, shared_secret zostaje lokalnie."""
+        KyberKEM._require_pqc()
+        with oqs.KeyEncapsulation(algorithm) as kem:
+            ciphertext, shared_secret = kem.encap_secret(public_key)
+        return ciphertext, shared_secret
+
+    def decapsulate(self, ciphertext: bytes) -> bytes:
+        """Strona posiadająca klucz prywatny: odzyskuje ten sam shared_secret."""
+        if self._public_key is None:
+            raise RuntimeError("Najpierw wywołaj generate_keypair().")
+        return self._kem.decap_secret(ciphertext)

qcrypt/pqc/signatures.py

@@ -0,0 +1,58 @@
+"""
+Podpisy cyfrowe odporne na komputery kwantowe — Dilithium / ML-DSA
+(standard NIST FIPS 204), przez liboqs-python.
+"""
+
+from __future__ import annotations
+
+from qcrypt.exceptions import PQCUnavailableError
+from qcrypt.pqc.kem import PQC_AVAILABLE
+
+try:
+    import oqs  # type: ignore
+except ImportError:
+    oqs = None  # type: ignore
+
+DEFAULT_ALGORITHM = "Dilithium3"  # odpowiednik ML-DSA-65 (NIST poziom 3)
+
+
+class DilithiumSigner:
+    """
+    Podpisywanie i weryfikacja odporne na kwantowe.
+
+    Przykład:
+        signer = DilithiumSigner()
+        public_key = signer.generate_keypair()
+        signature = signer.sign(b"wiadomość")
+
+        assert DilithiumSigner.verify(public_key, b"wiadomość", signature)
+    """
+
+    def __init__(self, algorithm: str = DEFAULT_ALGORITHM):
+        if not PQC_AVAILABLE:
+            raise PQCUnavailableError(
+                "Pakiet 'oqs' (liboqs-python) nie jest zainstalowany. "
+                "Zainstaluj: pip install liboqs-python"
+            )
+        self.algorithm = algorithm
+        self._signer = oqs.Signature(algorithm)
+        self._public_key: bytes | None = None
+
+    def generate_keypair(self) -> bytes:
+        self._public_key = self._signer.generate_keypair()
+        return self._public_key
+
+    def sign(self, message: bytes) -> bytes:
+        if self._public_key is None:
+            raise RuntimeError("Najpierw wywołaj generate_keypair().")
+        return self._signer.sign(message)
+
+    @staticmethod
+    def verify(public_key: bytes, message: bytes, signature: bytes,
+               algorithm: str = DEFAULT_ALGORITHM) -> bool:
+        if not PQC_AVAILABLE:
+            raise PQCUnavailableError(
+                "Pakiet 'oqs' (liboqs-python) nie jest zainstalowany."
+            )
+        with oqs.Signature(algorithm) as verifier:
+            return verifier.verify(message, signature, public_key)

qcrypt/qkd/__init__.py

@@ -0,0 +1,4 @@
+from qcrypt.qkd.bb84 import BB84Protocol, BB84Result
+from qcrypt.qkd.channel import QuantumChannel
+
+__all__ = ["BB84Protocol", "BB84Result", "QuantumChannel"]

qcrypt/qkd/backend.py

@@ -0,0 +1,88 @@
+"""
+Abstrakcja "backendu kubitowego" dla protokołu BB84.
+
+Domyślny `SimulatedBackend` to czysta matematyka (żadnych obwodów kwantowych) —
+bit + baza kodowania są reprezentowane jako para liczb, a pomiar w złej bazie
+daje losowy wynik zgodnie z regułami mechaniki kwantowej dla stanów BB84
+(co matematycznie odtwarza zachowanie prawdziwych qubitów dla tego protokołu).
+
+`QiskitBackend` (opcjonalny) faktycznie buduje obwód kwantowy dla każdego
+kubitu i wykonuje go na symulatorze Qiskit Aer (lub, po zmianie `service`,
+na prawdziwym komputerze kwantowym IBM). Wymaga `pip install qiskit qiskit-aer`.
+
+Bazy: 0 = baza obliczeniowa (Z, "+"), 1 = baza diagonalna (X, "x")
+Bity: 0 lub 1
+"""
+
+from __future__ import annotations
+
+import random
+from abc import ABC, abstractmethod
+
+
+class QubitBackend(ABC):
+    """Interfejs backendu: przygotuj kubit w danym bicie/bazie, zmierz w danej bazie."""
+
+    @abstractmethod
+    def measure(self, sent_bit: int, sent_basis: int, measure_basis: int) -> int:
+        """Zwraca wynik pomiaru kubitu wysłanego jako (sent_bit, sent_basis),
+        zmierzonego w bazie measure_basis. Jeśli bazy się zgadzają, wynik = sent_bit
+        (w idealnym kanale). Jeśli się nie zgadzają, wynik jest losowy (50/50)."""
+        raise NotImplementedError
+
+
+class SimulatedBackend(QubitBackend):
+    """Domyślny backend: symulacja matematyczna bez faktycznych obwodów
+    kwantowych. Szybki, deterministyczny (poza losowością pomiaru w złej
+    bazie), używa `random.SystemRandom` jako źródła entropii."""
+
+    def __init__(self, seed: int | None = None):
+        self._rng = random.SystemRandom() if seed is None else random.Random(seed)
+
+    def measure(self, sent_bit: int, sent_basis: int, measure_basis: int) -> int:
+        if sent_basis == measure_basis:
+            return sent_bit
+        return self._rng.randint(0, 1)
+
+
+class QiskitBackend(QubitBackend):
+    """
+    Opcjonalny backend wykonujący faktyczny obwód kwantowy dla każdego
+    kubitu na symulatorze Qiskit Aer.
+
+    Wymaga: pip install qiskit qiskit-aer
+
+    Kodowanie:
+        bit=0, basis=0 (Z) -> |0>
+        bit=1, basis=0 (Z) -> |1>
+        bit=0, basis=1 (X) -> |+>  (H|0>)
+        bit=1, basis=1 (X) -> |->  (H|1>)
+    Pomiar w bazie X realizowany jako H przed pomiarem w bazie obliczeniowej.
+    """
+
+    def __init__(self):
+        try:
+            from qiskit import QuantumCircuit
+            from qiskit_aer import AerSimulator
+        except ImportError as exc:
+            raise ImportError(
+                "QiskitBackend wymaga pakietów 'qiskit' i 'qiskit-aer'. "
+                "Zainstaluj: pip install qiskit qiskit-aer"
+            ) from exc
+        self._QuantumCircuit = QuantumCircuit
+        self._simulator = AerSimulator()
+
+    def measure(self, sent_bit: int, sent_basis: int, measure_basis: int) -> int:
+        qc = self._QuantumCircuit(1, 1)
+        if sent_bit == 1:
+            qc.x(0)
+        if sent_basis == 1:
+            qc.h(0)
+        if measure_basis == 1:
+            qc.h(0)
+        qc.measure(0, 0)
+
+        job = self._simulator.run(qc, shots=1, memory=True)
+        result = job.result()
+        (outcome,) = result.get_memory(qc)
+        return int(outcome)

qcrypt/qkd/bb84.py

@@ -0,0 +1,160 @@
+"""
+Protokół BB84 (Bennett–Brassard 1984) — symulacja kwantowej dystrybucji klucza.
+
+Etapy:
+  1. Alice generuje losowe bity i losowe bazy, "wysyła" kubity.
+  2. Bob mierzy każdy kubit w losowo wybranej bazie.
+  3. Sifting: Alice i Bob porównują (jawnie, klasycznym kanałem) użyte bazy —
+     zachowują tylko bity, gdzie bazy się zgodziły.
+  4. Estymacja QBER: poświęcają losową próbkę przesianych bitów, porównują
+     jawnie — jeśli błędów jest za dużo, ktoś podsłuchiwał -> przerywają.
+  5. Privacy amplification: pozostały klucz jest haszowany (SHA-256), żeby
+     usunąć ewentualną szczątkową wiedzę podsłuchującego o kluczu.
+
+UWAGA: to symulacja matematyczna na klasycznym komputerze. Domyślny
+`SimulatedBackend` nie wykonuje żadnych operacji na prawdziwym sprzęcie
+kwantowym — służy do nauki protokołu i integracji z resztą biblioteki.
+Do faktycznych obwodów kwantowych podłącz `qcrypt.qkd.backend.QiskitBackend`.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import random
+from dataclasses import dataclass, field
+
+from qcrypt.exceptions import EavesdropDetected
+from qcrypt.qkd.channel import QuantumChannel
+
+DEFAULT_QBER_THRESHOLD = 0.11  # ~11%, próg klasycznie przyjmowany dla BB84
+DEFAULT_SAMPLE_FRACTION = 0.25  # jaka część przesianych bitów idzie na test QBER
+
+
+@dataclass
+class BB84Result:
+    """Wynik przebiegu protokołu."""
+
+    raw_key_length: int          # liczba wysłanych kubitów
+    sifted_key_length: int        # po odrzuceniu niezgodnych baz
+    final_key_length: int         # po odjęciu próbki testowej
+    qber: float                    # estymowany współczynnik błędów
+    eavesdropper_detected: bool
+    shared_key: bytes              # finalny klucz (po privacy amplification), pusty jeśli przerwano
+
+
+class BB84Protocol:
+    """
+    Orkiestracja pełnego przebiegu BB84 między Alice a Bobem.
+
+    Przykład:
+        channel = QuantumChannel(eavesdropper=False, noise_level=0.02)
+        protocol = BB84Protocol(channel=channel, n_qubits=2048)
+        result = protocol.run()
+
+        if result.eavesdropper_detected:
+            print("Kanał skompromitowany — klucz odrzucony.")
+        else:
+            secret_key_bytes = result.shared_key   # gotowe do użycia w AEAD
+    """
+
+    def __init__(
+        self,
+        channel: QuantumChannel | None = None,
+        *,
+        n_qubits: int = 1024,
+        qber_threshold: float = DEFAULT_QBER_THRESHOLD,
+        sample_fraction: float = DEFAULT_SAMPLE_FRACTION,
+        seed: int | None = None,
+    ):
+        self.channel = channel or QuantumChannel(seed=seed)
+        self.n_qubits = n_qubits
+        self.qber_threshold = qber_threshold
+        self.sample_fraction = sample_fraction
+        self._rng = random.SystemRandom() if seed is None else random.Random(seed)
+
+    def run(self) -> BB84Result:
+        # --- 1. Alice generuje losowe bity i bazy ---
+        alice_bits = [self._rng.randint(0, 1) for _ in range(self.n_qubits)]
+        alice_bases = [self._rng.randint(0, 1) for _ in range(self.n_qubits)]
+
+        # --- 2. Transmisja + pomiar Boba ---
+        bob_bases = [self._rng.randint(0, 1) for _ in range(self.n_qubits)]
+        bob_bits: list[int] = []
+        for bit, basis, bob_basis in zip(alice_bits, alice_bases, bob_bases):
+            tx = self.channel.transmit(bit, basis)
+            bob_bits.append(self.channel.measure(tx, bob_basis))
+
+        # --- 3. Sifting: zostają tylko pozycje ze zgodną bazą ---
+        sifted_alice, sifted_bob = [], []
+        for a_bit, a_basis, b_basis, b_bit in zip(alice_bits, alice_bases, bob_bases, bob_bits):
+            if a_basis == b_basis:
+                sifted_alice.append(a_bit)
+                sifted_bob.append(b_bit)
+
+        sifted_len = len(sifted_alice)
+        if sifted_len == 0:
+            return BB84Result(
+                raw_key_length=self.n_qubits,
+                sifted_key_length=0,
+                final_key_length=0,
+                qber=1.0,
+                eavesdropper_detected=True,
+                shared_key=b"",
+            )
+
+        # --- 4. Estymacja QBER na losowej próbce ---
+        sample_size = max(1, int(sifted_len * self.sample_fraction))
+        sample_indices = set(self._rng.sample(range(sifted_len), sample_size))
+
+        mismatches = sum(
+            1 for i in sample_indices if sifted_alice[i] != sifted_bob[i]
+        )
+        qber = mismatches / sample_size
+
+        eavesdropper_detected = qber > self.qber_threshold
+
+        # --- 5. Usunięcie próbki testowej z klucza (ujawniona jawnie) ---
+        remaining_alice = [
+            b for i, b in enumerate(sifted_alice) if i not in sample_indices
+        ]
+
+        if eavesdropper_detected:
+            return BB84Result(
+                raw_key_length=self.n_qubits,
+                sifted_key_length=sifted_len,
+                final_key_length=0,
+                qber=qber,
+                eavesdropper_detected=True,
+                shared_key=b"",
+            )
+
+        # --- 6. Privacy amplification: hash klucza do finalnego sekretu ---
+        final_key = self._privacy_amplify(remaining_alice)
+
+        return BB84Result(
+            raw_key_length=self.n_qubits,
+            sifted_key_length=sifted_len,
+            final_key_length=len(remaining_alice),
+            qber=qber,
+            eavesdropper_detected=False,
+            shared_key=final_key,
+        )
+
+    def run_or_raise(self) -> bytes:
+        """Wygodny wariant: zwraca klucz albo rzuca EavesdropDetected."""
+        result = self.run()
+        if result.eavesdropper_detected:
+            raise EavesdropDetected(
+                f"Wykryto podsłuch kanału kwantowego: QBER={result.qber:.2%} "
+                f"przekracza próg {self.qber_threshold:.2%}. Klucz odrzucony."
+            )
+        return result.shared_key
+
+    @staticmethod
+    def _privacy_amplify(bits: list[int]) -> bytes:
+        """Redukuje przesiany klucz do finalnego sekretu poprzez hashowanie —
+        usuwa szczątkową informację, jaką mógłby zdobyć podsłuchujący,
+        nawet jeśli QBER był poniżej progu wykrywalności."""
+        bit_string = "".join(str(b) for b in bits)
+        packed = int(bit_string, 2).to_bytes((len(bit_string) + 7) // 8, "big") if bit_string else b""
+        return hashlib.sha256(packed).digest()

qcrypt/qkd/channel.py

@@ -0,0 +1,80 @@
+"""
+Model kanału kwantowego łączącego Alice i Boba w symulacji BB84.
+
+Obsługuje dwa źródła błędów, które w realnym QKD są nie do odróżnienia
+(i właśnie dlatego wysoki QBER traktuje się jako "być może podsłuch"):
+  - `noise_level`: naturalny szum/straty w kanale (imperfekcje sprzętu),
+  - `eavesdropper`: symulacja ataku "przechwyć i wyślij ponownie" (intercept-resend).
+"""
+
+from __future__ import annotations
+
+import random
+from dataclasses import dataclass, field
+
+from qcrypt.qkd.backend import QubitBackend, SimulatedBackend
+
+
+@dataclass
+class TransmittedQubit:
+    """Stan pojedynczego kubitu w locie: to, co faktycznie wysyła Alice
+    (po ewentualnej ingerencji Eve)."""
+
+    original_bit: int
+    original_basis: int
+    sent_bit: int      # może się różnić od original_bit, jeśli Eve zmierzyła w złej bazie
+    sent_basis: int     # bazuje na tym, co Eve retransmituje (=original_basis jeśli brak Eve)
+    intercepted: bool
+
+
+class QuantumChannel:
+    """
+    Symulowany kanał kwantowy między Alice a Bobem.
+
+    Args:
+        backend: implementacja pomiaru kubitów (domyślnie SimulatedBackend).
+        noise_level: prawdopodobieństwo losowego przekłamania bitu w kanale (0.0–1.0).
+        eavesdropper: jeśli True, Eve przechwytuje każdy kubit metodą
+            intercept-resend (mierzy w losowej bazie, wysyła dalej to, co zmierzyła).
+        seed: ziarno RNG dla powtarzalności testów.
+    """
+
+    def __init__(
+        self,
+        backend: QubitBackend | None = None,
+        *,
+        noise_level: float = 0.0,
+        eavesdropper: bool = False,
+        seed: int | None = None,
+    ):
+        self.backend = backend or SimulatedBackend(seed=seed)
+        self.noise_level = noise_level
+        self.eavesdropper = eavesdropper
+        self._rng = random.SystemRandom() if seed is None else random.Random(seed)
+
+    def transmit(self, bit: int, basis: int) -> TransmittedQubit:
+        """Wysyła jeden kubit (bit zakodowany w danej bazie) od Alice do Boba,
+        symulując ewentualny podsłuch Eve i szum kanału."""
+        sent_bit, sent_basis, intercepted = bit, basis, False
+
+        if self.eavesdropper:
+            eve_basis = self._rng.randint(0, 1)
+            eve_measured = self.backend.measure(bit, basis, eve_basis)
+            # Eve retransmituje kubit zakodowany zgodnie z tym, co zmierzyła —
+            # to właśnie wprowadza wykrywalne błędy, gdy jej baza się nie zgadza z Alice.
+            sent_bit, sent_basis, intercepted = eve_measured, eve_basis, True
+
+        if self._rng.random() < self.noise_level:
+            sent_bit ^= 1  # losowe przekłamanie bitu przez szum kanału
+
+        return TransmittedQubit(
+            original_bit=bit,
+            original_basis=basis,
+            sent_bit=sent_bit,
+            sent_basis=sent_basis,
+            intercepted=intercepted,
+        )
+
+    def measure(self, tx: TransmittedQubit, measure_basis: int) -> int:
+        """Bob mierzy otrzymany kubit w wybranej przez siebie bazie."""
+        return self.backend.measure(tx.sent_bit, tx.sent_basis, measure_basis)

qcrypt/symmetric/__init__.py

@@ -0,0 +1,3 @@
+from qcrypt.symmetric.aead import AEAD
+
+__all__ = ["AEAD"]

qcrypt/symmetric/aead.py

@@ -0,0 +1,90 @@
+"""
+Warstwa symetryczna AEAD (Authenticated Encryption with Associated Data).
+
+Klucz otrzymany z wymiany kluczy (PQC KEM) lub z symulacji BB84 ma zwykle
+nieregularną długość / jest surowym sekretem — tutaj przepuszczamy go przez
+HKDF, aby uzyskać właściwy 256-bitowy klucz AES, a następnie szyfrujemy dane
+w trybie AES-256-GCM (poufność + integralność w jednym).
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+from cryptography.hazmat.primitives import hashes
+
+from qcrypt.exceptions import DecryptionError
+
+NONCE_SIZE = 12  # 96 bitów — zalecane dla GCM
+KEY_SIZE = 32     # 256 bitów
+
+
+@dataclass
+class EncryptedMessage:
+    """Kontener na wynik szyfrowania: nonce + szyfrogram (z tagiem GCM)."""
+
+    nonce: bytes
+    ciphertext: bytes
+
+    def to_bytes(self) -> bytes:
+        """Serializuje do jednego blobu: [nonce (12B)][ciphertext+tag]."""
+        return self.nonce + self.ciphertext
+
+    @classmethod
+    def from_bytes(cls, blob: bytes) -> "EncryptedMessage":
+        if len(blob) < NONCE_SIZE:
+            raise DecryptionError("Blob zbyt krótki, brak pełnego nonce.")
+        return cls(nonce=blob[:NONCE_SIZE], ciphertext=blob[NONCE_SIZE:])
+
+
+class AEAD:
+    """
+    Szyfrowanie symetryczne AES-256-GCM zasilane sekretem z warstwy
+    kwantowo-odpornej (PQC KEM) lub kwantowej dystrybucji klucza (BB84).
+
+    Przykład:
+        cipher = AEAD(key=shared_secret)
+        blob = cipher.encrypt(b"tajna wiadomość")
+        plaintext = cipher.decrypt(blob)
+    """
+
+    def __init__(self, key: bytes, *, info: bytes = b"qcrypt-aead-v1"):
+        """
+        Args:
+            key: surowy sekret (dowolna długość >= 16 bajtów), np. z KEM lub BB84.
+            info: kontekst domenowy dla HKDF (izoluje różne zastosowania klucza).
+        """
+        if len(key) < 16:
+            raise ValueError("Klucz wejściowy musi mieć co najmniej 16 bajtów entropii.")
+        self._key = self._derive_key(key, info)
+        self._aesgcm = AESGCM(self._key)
+
+    @staticmethod
+    def _derive_key(raw_secret: bytes, info: bytes) -> bytes:
+        hkdf = HKDF(
+            algorithm=hashes.SHA256(),
+            length=KEY_SIZE,
+            salt=None,
+            info=info,
+        )
+        return hkdf.derive(raw_secret)
+
+    def encrypt(self, plaintext: bytes, *, associated_data: bytes | None = None) -> bytes:
+        """Szyfruje plaintext, zwraca gotowy blob (nonce + ciphertext+tag)."""
+        nonce = os.urandom(NONCE_SIZE)
+        ciphertext = self._aesgcm.encrypt(nonce, plaintext, associated_data)
+        return EncryptedMessage(nonce=nonce, ciphertext=ciphertext).to_bytes()
+
+    def decrypt(self, blob: bytes, *, associated_data: bytes | None = None) -> bytes:
+        """Odszyfrowuje blob utworzony przez encrypt(). Rzuca DecryptionError
+        przy nieprawidłowym kluczu, uszkodzonych danych lub manipulacji."""
+        msg = EncryptedMessage.from_bytes(blob)
+        try:
+            return self._aesgcm.decrypt(msg.nonce, msg.ciphertext, associated_data)
+        except Exception as exc:  # cryptography rzuca InvalidTag
+            raise DecryptionError(
+                "Nie udało się odszyfrować — zły klucz, uszkodzone dane lub próba manipulacji."
+            ) from exc

quant_bvz_secure-0.1.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: quant-bvz-secure
+Version: 0.1.0
+Summary: Biblioteka kryptograficzna: post-kwantowa wymiana kluczy (Kyber/Dilithium) + symulacja QKD (BB84) + AEAD
+License: MIT
+Project-URL: Repository, https://github.com/Jokovexor/quant-bvz-secure
+Keywords: post-quantum,pqc,kyber,dilithium,qkd,bb84,cryptography
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security :: Cryptography
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=42.0
+Provides-Extra: pqc
+Requires-Dist: liboqs-python>=0.10.0; extra == "pqc"
+Provides-Extra: qkd-hw
+Requires-Dist: qiskit>=1.0; extra == "qkd-hw"
+Requires-Dist: qiskit-aer>=0.14; extra == "qkd-hw"
+Provides-Extra: all
+Requires-Dist: liboqs-python>=0.10.0; extra == "all"
+Requires-Dist: qiskit>=1.0; extra == "all"
+Requires-Dist: qiskit-aer>=0.14; extra == "all"
+Dynamic: license-file
+
+# qcrypt
+
+Biblioteka kryptograficzna łącząca **kryptografię post-kwantową (PQC)**
+z **symulacją kwantowej dystrybucji klucza (QKD / BB84)**.
+
+## Ważne zastrzeżenie
+
+Czysty Python nie ma dostępu do sprzętu kwantowego. Ta biblioteka dzieli się
+na dwie realistyczne części:
+
+- **`qcrypt.pqc`** — prawdziwe, produkcyjne algorytmy odporne na ataki
+  komputerów kwantowych (Kyber/ML-KEM, Dilithium/ML-DSA), działające na
+  zwykłym procesorze *już dziś*. To jest realne zastosowanie.
+- **`qcrypt.qkd`** — **symulacja matematyczna** protokołu BB84 do celów
+  edukacyjnych. Domyślnie nie wykonuje żadnych operacji na prawdziwych
+  kubitach. Można podłączyć `QiskitBackend`, żeby faktycznie budować i
+  wykonywać obwody kwantowe na symulatorze Qiskit Aer (lub realnym QPU IBM).
+
+## Instalacja
+
+```bash
+pip install -e .                    # rdzeń (AEAD, symulacja BB84, X25519)
+pip install -e .[pqc]               # + Kyber/Dilithium (liboqs-python)
+pip install -e .[qkd-hw]            # + prawdziwe obwody kwantowe (Qiskit)
+pip install -e .[all]               # wszystko
+```
+
+`liboqs-python` wymaga skompilowania biblioteki C `liboqs` — zobacz
+https://github.com/open-quantum-safe/liboqs-python
+
+## Szybki start
+
+### 1. Hybrydowa wymiana klucza (produkcyjna)
+
+```python
+from qcrypt import HybridKEM, AEAD
+
+bob = HybridKEM()
+bundle = bob.generate_keypair()          # Bob -> wysyła do Alice
+
+ciphertext, alice_secret = HybridKEM.encapsulate(bundle)   # Alice
+bob_secret = bob.decapsulate(ciphertext)                    # Bob
+
+assert alice_secret == bob_secret
+
+cipher = AEAD(key=alice_secret)
+blob = cipher.encrypt(b"tajna wiadomosc")
+plaintext = AEAD(key=bob_secret).decrypt(blob)
+```
+
+### 2. Symulacja BB84 (edukacyjna)
+
+```python
+from qcrypt.qkd.bb84 import BB84Protocol
+from qcrypt.qkd.channel import QuantumChannel
+
+# Kanał bez podsłuchu
+channel = QuantumChannel(noise_level=0.02)
+result = BB84Protocol(channel=channel, n_qubits=2048).run()
+print(result.qber, result.eavesdropper_detected)
+
+# Kanał z podsłuchem — QBER wzrośnie i zostanie wykryty
+channel_eve = QuantumChannel(eavesdropper=True)
+result_eve = BB84Protocol(channel=channel_eve, n_qubits=2048).run()
+assert result_eve.eavesdropper_detected
+```
+
+### 3. CLI
+
+```bash
+python -m qcrypt.cli bb84-demo --qubits 4096
+python -m qcrypt.cli bb84-demo --qubits 4096 --eve      # symulacja podsłuchu
+python -m qcrypt.cli hybrid-demo --classical-only         # bez liboqs
+python -m qcrypt.cli encrypt --key-hex <64 hex znaki> --in plik.txt --out plik.enc
+python -m qcrypt.cli decrypt --key-hex <64 hex znaki> --in plik.enc --out plik.txt
+```
+
+## Struktura
+
+```
+qcrypt/
+├── pqc/
+│   ├── kem.py          # Kyber/ML-KEM przez liboqs-python
+│   ├── signatures.py    # Dilithium/ML-DSA przez liboqs-python
+│   └── hybrid.py         # X25519 + Kyber połączone przez HKDF
+├── qkd/
+│   ├── bb84.py           # orkiestracja protokołu, sifting, QBER, privacy amplification
+│   ├── channel.py        # model kanału + symulowany podsłuchujący (Eve)
+│   └── backend.py        # SimulatedBackend (domyślny) / QiskitBackend (opcjonalny)
+├── symmetric/
+│   └── aead.py            # AES-256-GCM + HKDF do wyprowadzania klucza
+├── keystore.py             # zapis/odczyt kluczy do JSON (base64)
+├── exceptions.py
+└── cli.py
+```
+
+## Bezpieczeństwo
+
+- Implementacje PQC pochodzą z zaudytowanej biblioteki `liboqs` — nie
+  implementujemy własnej kryptografii kratowej.
+- `HybridKEM` łączy X25519 z Kyber: złamanie musi dotyczyć **obu**
+  algorytmów jednocześnie, zgodnie z zaleceniami NIST na okres przejściowy.
+- Moduł `qkd` jest **edukacyjny**. Nie używaj go jako jedynej warstwy
+  bezpieczeństwa w systemie produkcyjnym bez realnego sprzętu kwantowego i
+  zaufanego kanału uwierzytelniania klasycznego (BB84 wymaga uwierzytelnionego
+  kanału klasycznego do sifting, inaczej podatny na man-in-the-middle).

quant_bvz_secure-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+qcrypt/__init__.py,sha256=trAcbXIhmfRa124wwQaChqKVU5IICpAQU-FZRe3sbC8,962
+qcrypt/cli.py,sha256=bVCuX5F4dMPfOqTUjGVphwlM6JM0NYDgPVpZibZe38E,4497
+qcrypt/exceptions.py,sha256=cJunqBIomK84dZgw5dXBizifG-CRx-Aufb2QMuEIWHE,733
+qcrypt/keystore.py,sha256=KBO0geIkIE1bmBPE7wLRzXY3bRXGEqd6cHjIOliCT7c,4521
+qcrypt/pqc/__init__.py,sha256=bpBxk7zeBuPan6uu7YcupMIXWo9XQSNYcPrCdFEDiYA,214
+qcrypt/pqc/hybrid.py,sha256=yrIcWvHkAt0X_150L3yWERaY-CRgSQ1r0vYbAcQ4sbo,6254
+qcrypt/pqc/kem.py,sha256=i8OXpOSBNihVtaziXsHIzTXqLuUobaoF8NN_p-E0tfQ,3384
+qcrypt/pqc/signatures.py,sha256=rpqhX2TeGYb8sYpd6FuiHGxGJGmKN62GrQGqXXXj6YE,1882
+qcrypt/qkd/__init__.py,sha256=HidmyhUE5uMWLf3UYQtifbe3Ipfv-Ov27XbnBuiyFkY,159
+qcrypt/qkd/backend.py,sha256=Jsxto3cGZ94hTAY_omkAwfunSE06Fg2hOzW05ckseQs,3226
+qcrypt/qkd/bb84.py,sha256=3nDMOuwwz9tiQH0ZhB5hvQEEsHnzakANBBr3zrfskCA,6353
+qcrypt/qkd/channel.py,sha256=DX9cd7o26m80v1aFm2y0-jFlBvDLL4t-zMVVCUtznBo,3119
+qcrypt/symmetric/__init__.py,sha256=SSFlkrD8IsOqFq1YsIDBOqvAnsCEElN13pKVvLd17To,59
+qcrypt/symmetric/aead.py,sha256=bJshMRsjkdX3Ef8u5Jwf1x9ej02pf-dqvaghChdll1k,3388
+quant_bvz_secure-0.1.0.dist-info/licenses/LICENSE,sha256=YDTqs06lZtO7a0hSms2_Iy4ZC94pvwpOmBlY5AInOes,1073
+quant_bvz_secure-0.1.0.dist-info/METADATA,sha256=ewT-x8eF7GUp-sizhCCWrGpR7SkjGihmlzRZZMbXsoQ,5202
+quant_bvz_secure-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+quant_bvz_secure-0.1.0.dist-info/top_level.txt,sha256=wnyBACCQ9zO8m1BZEqJhxa0DNPKlCejkYApFsQ5RtTw,7
+quant_bvz_secure-0.1.0.dist-info/RECORD,,

quant_bvz_secure-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

quant_bvz_secure-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bartosz Radomski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

quant_bvz_secure-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+qcrypt