Metadata-Version: 2.4
Name: quant-bvz-secure
Version: 0.1.1
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).
