quantusync/alaniz-cipherChiffrement à partir de Morphismes de Faisceaux Non Linéaires sur des Graphes
Chiffrement post-quantique basé sur les faisceaux via permutations vectorielles sur les corps finis
Une primitive cryptographique basée sur le problème d'inversion de morphisme de faisceau non linéaire (NL-SMIP) : un système polynomial avec des coefficients secrets couplés par la cohomologie des faisceaux sur des graphes.
Article (v3) : L. Alaniz Pintos, "The Alaniz Cipher v3: Sheaf-Based Post-Quantum Encryption via Vector-Valued Finite Field Permutations", 2026.
La version 2 a introduit σ_SPN pour contrer l'attaque par mise à l'échelle qui a cassé la v1. Cependant, la v2 est elle-même cassée par une attaque plus générale combinant l'interpolation polynomiale avec le calcul de bases de Gröbner : tout chiffrement déterministe de la forme c = As + Bσ(As) avec σ de degré polynomial borné admet une attaque CPA de récupération de clé. Voir la section 3 de l'article et experiments/02_cpa_attack_analysis.py.
La version 3 répond à ce problème au niveau structurel :
| Fonctionnalité | v2 | v3 |
|---|---|---|
| Chiffrement | Déterministe | Probabiliste (nonce + PRG) |
| σ | SPN par composante sur F_p | Vectoriel : π_e(x) = x^e dans F_{p^d} |
| Clé secondaire | Matrice B_v ∈ GL(d, F_p) | Scalaire β_v ∈ F_{p^d}^* |
| Déchiffrement | Force brute sur F_p^d | Factorisation univariée dans F_{p^d}[τ] |
| Uniformité différentielle de σ | δ ≥ 2p (~34 pour p=17) | δ ∈ {2, 4} (APN ou presque APN) |
| Cible IND-CCA | Non applicable | Atteinte via transformation FO |
14 configurations de semi-régularité testées, 14 correspondent exactement aux prédictions de Hilbert-Poincaré. Aucune vulnérabilité MinRank d'après le théorème 6.5 (argument du centralisateur). Aucune clé faible détectée dans 69 configurations.
Les messages sont encodés comme des sections globales d'un faisceau cellulaire sur un graphe de rang cyclique β_1 ≥ 1. Chiffrement par nœud :
r_v = PRG(nonce, v)
u_v = ι(A_v · s_v + r_v) ∈ F_{p^d}
w_v = β_v · u_v + (β_v − 1) · (L · u_v + 1)^e
c_v = ι^{-1}(w_v) − r_v
où A_v ∈ GL(d, F_p), β_v ∈ F_{p^d}^* et L ∈ F_{p^d}^* est public. Le déchiffrement se réduit à trouver les racines de γ·τ^e + α·τ − (c′ + α) = 0 dans F_{p^d}[τ] via Cantor-Zassenhaus, puis à filtrer par la cohérence cohomologique à tous les n − 1 sommets non racines.
| Ensemble | d | log₂ p | n | e | |sk| | |pk| | |c| | Sécurité | |---|---|---|---|---|---|---|---|---| | Démo | 2 | 4 | 4 | 17 | 30 B | 10 B | 16 B | non sécurisé | | Académique | 3 | 16 | 8 | 17 | 0.3 KB | 30 B | 96 B | ~80 bits classique | | PQ-128 | 6 | 61 | 32 | 17 | 16 KB | 64 B | 1.5 KB | ≥128 post-Grover | | PQ-256 | 8 | 127 | 64 | 17 | 170 KB | 128 B | 8 KB | ≥256 post-Grover |
git clone https://github.com/QuantuSync/alaniz-cipher.git
cd alaniz-cipher
pip install -e .[test]
# Run the v2 demo (historical)
python -m alaniz.demo.demo_basic
# Run all tests
pytest tests/ -v
# Run v3 verification experiments
python experiments/07_semi_regularity.py
python experiments/08_weak_keys.py
python experiments/09_nonce_robustness.py
python experiments/10_centralizer.py
python experiments/11_kem_verification.py
from alaniz.core.field import FiniteField
from alaniz.core.graph import Graph
from alaniz.core.sheaf import Sheaf
from alaniz.crypto.protocol import ProtocolV3, PublicParamsV3
from alaniz.crypto.kem import KEM
Fp = FiniteField(17)
graph = Graph.cycle(4)
sheaf = Sheaf.random_with_cohomology(graph, dv=2, Fp=Fp)
proto = ProtocolV3(PublicParamsV3.generate(sheaf))
kem = KEM(proto)
sk = kem.keygen()
K, ct = kem.encaps(sk) # sender: random message + shared key
K_recv = kem.decaps(sk, ct) # receiver: same K if valid
assert K == K_recv
alaniz-cipher/
├── alaniz/
│ ├── core/
│ │ ├── field.py # Arithmétique F_p (v2, toujours utilisée par v1/v2)
│ │ ├── field_ext.py # Arithmétique F_{p^d} via galois (v3)
│ │ ├── graph.py # Topologies de graphes (arbres, cycles, etc.)
│ │ └── sheaf.py # Faisceaux cellulaires + contraintes de cohomologie
│ ├── crypto/
│ │ ├── sigma.py # Applications σ : monomial_power (v3), id_spn (v2), cube/inverse (v1)
│ │ ├── protocol.py # Protocole (v2), ProtocolV3 (v3)
│ │ ├── prg.py # PRG SHAKE-256 pour dérivation de nonce (v3)
│ │ └── kem.py # Fujisaki-Okamoto → KEM IND-CCA (v3)
│ └── demo/
│ └── demo_basic.py # Démo v2 (historique)
├── experiments/
│ ├── 01-06_*.py # Analyses v1 (historique, annexe v2 de l'article)
│ ├── 14_v2_redteam.py # Red team v2 (historique)
│ ├── 07_semi_regularity.py # v3 : vérification Hilbert-Poincaré
│ ├── 08_weak_keys.py # v3 : balayage clé faible 69 configurations
│ ├── 09_nonce_robustness.py # v3 : Théorème 6.7
│ ├── 10_centralizer.py # v3 : Théorème 6.5
│ └── 11_kem_verification.py # v3 : tests empiriques KEM IND-CCA
├── tests/
│ ├── test_protocol.py # Tests v2 (conservés pour régression)
│ └── test_protocol_v3.py # Tests v3
├── pyproject.toml
└── README.md
v1 : Cassée par l'attaque par mise à l'échelle de Langa sur σ_cube(λy) = λ³ σ_cube(y) (Alaniz 2026, annexe A de l'article v3). Récupération en O(d) requêtes.
v2 : Cassée par l'attaque par interpolation polynomiale + Gröbner contre tout chiffrement déterministe c = As + Bσ(As) avec σ de degré borné. Pour d=2, p=17, récupération complète de clé en 20 requêtes CPA et ~5,7 s de calcul SymPy sur 10/10 instances aléatoires. Voir experiments/02_cpa_attack_analysis.py et la section 3 de l'article.
Les classes v1 et v2 restent accessibles dans ce dépôt pour reproductibilité historique. Pour toute nouvelle utilisation, utilisez ProtocolV3.
@misc{alaniz2026cipherv3,
author = {Alaniz Pintos, Lucas},
title = {The Alaniz Cipher v3: Sheaf-Based Post-Quantum Encryption
via Vector-Valued Finite Field Permutations},
year = {2026},
url = {https://github.com/QuantuSync/alaniz-cipher}
}
A. Rodríguez Langa (INECO) pour la cryptanalyse de la v1 qui a motivé le chemin de refonte menant à la v2 puis à la v3.
Lucas Alaniz Pintos Division des produits intelligents, INECO [email protected] ORCID: 0009-0008-5179-2534
MIT