quant-bvz-secure 0.1.0__tar.gz

quant_bvz_secure-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,106 @@
+# 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/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quant-bvz-secure"
+version = "0.1.0"
+description = "Biblioteka kryptograficzna: post-kwantowa wymiana kluczy (Kyber/Dilithium) + symulacja QKD (BB84) + AEAD"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+keywords = ["post-quantum", "pqc", "kyber", "dilithium", "qkd", "bb84", "cryptography"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Security :: Cryptography",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "cryptography>=42.0",
+]
+
+[project.optional-dependencies]
+pqc = ["liboqs-python>=0.10.0"]
+qkd-hw = ["qiskit>=1.0", "qiskit-aer>=0.14"]
+all = ["liboqs-python>=0.10.0", "qiskit>=1.0", "qiskit-aer>=0.14"]
+
+[project.urls]
+Repository = "https://github.com/Jokovexor/quant-bvz-secure"
+
+[tool.setuptools.packages.find]
+include = ["qcrypt*"]

quant_bvz_secure-0.1.0/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",
+]

quant_bvz_secure-0.1.0/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())

quant_bvz_secure-0.1.0/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)."""

quant_bvz_secure-0.1.0/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)

quant_bvz_secure-0.1.0/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"]