# Spécification formelle du protocole Collatz‑trapdoor v2.1

## Introduction

Le présent document fixe une version formelle et exploitable d’un protocole hybride combinant une fonction de mélange fondée sur une dynamique de type Collatz perturbée et des primitives asymétriques standard (KEM et signature). La dynamique Collatz perturbée est cantonnée à un rôle de dérivation et de séparation de domaines, tandis que la confidentialité et l’authenticité reposent sur un KEM et une signature étudiés et auditables. La spécification s’écrit au niveau des algorithmes KeyGen, Encaps, Decaps, Sign, Verify, avec notations et paramètres explicités.

## Notations et conventions

### Objets mathématiques

\(\mathbb{N}=\{0,1,2,\dots\}\)

\(\mathbb{N}^+=\{1,2,3,\dots\}\)

\(\mathbb{I}=\{2n+1 \mid n\in\mathbb{N}\}\), ensemble des impairs positifs

\(v_2(x)\), valuation 2‑adique de \(x\in\mathbb{N}^+\), définie par
\[
v_2(x)=\max\{t\in\mathbb{N}\mid 2^t \text{ divise } x\}.
\]

### Chaînes de bits et fonctions cryptographiques

Les chaînes de bits sont notées en gras, par exemple \(\mathbf{x}\in\{0,1\}^\ell\).

\(\parallel\), concaténation de chaînes ou d’encodages canoniques.

\(\oplus\), XOR bit à bit sur des chaînes de même longueur.

\(\mathrm{Hash}(\cdot)\), fonction de hachage cryptographique, sortie de longueur \(h\) bits.

\(\mathrm{XOF}(\cdot)\), fonction d’extension (eXtendable Output Function) produisant un flux pseudo‑aléatoire de bits de longueur arbitraire.

\(\mathrm{KDF}(\cdot)\), fonction de dérivation de clé (Key Derivation Function).

\(\mathrm{AEAD.Enc}(K,\mathrm{nonce},M,\mathrm{ad})\rightarrow (C,\mathrm{tag})\), chiffrement authentifié.

\(\mathrm{AEAD.Dec}(K,\mathrm{nonce},C,\mathrm{ad},\mathrm{tag})\rightarrow M \text{ ou } \bot\), déchiffrement authentifié.

### Encodages canoniques

Tout entier \(x\in\mathbb{N}^+\) est encodé en big‑endian sur une longueur fixée \(\ell_S\) bits, notée \(\mathrm{EncInt}_{\ell_S}(x)\). Si \(\ell_S\) dépasse la taille minimale, l’encodage est paddé à gauche par des zéros.

Les entiers et chaînes utilisés en entrée des fonctions \(\mathrm{Hash}\), \(\mathrm{XOF}\), \(\mathrm{KDF}\) sont encodés sans ambiguïté via des préfixes de longueur (par exemple \(\mathrm{len}(\cdot)\parallel \cdot\)), ou via un format TLV convenu.

## Paramètres

Les paramètres sont publics et fixés lors du déploiement.

### Paramètres CollatzMix

\(\ell_S\) : taille en bits de \(S\) (exemple 2048 ou 4096)

\(b\) : taille en bits du seed d’erreur \(E\) (exemple 128 ou 256)

\(k_{\mathrm{mix}}\) : profondeur d’itération de mélange (exemple 512 ou 1024)

\(h\) : taille de sortie de \(\mathrm{Hash}\) en bits (exemple 256)

\(\ell_\rho,\ell_\sigma\) : tailles des seeds dérivés pour le KEM et la signature (dépendent des primitives choisies)

### Paramètres KEM et signature

Le protocole est agnostique au choix exact, à condition que les primitives retenues satisfassent les notions de sécurité attendues et disposent d’API stables :

KEM :
- \(\mathrm{KEM.KeyGen}(\mathbf{seed})\rightarrow(\mathrm{pk}_{\mathrm{kem}},\mathrm{sk}_{\mathrm{kem}})\)
- \(\mathrm{KEM.Encaps}(\mathrm{pk}_{\mathrm{kem}})\rightarrow(\mathrm{ct}_{\mathrm{kem}},\mathbf{ss})\)
- \(\mathrm{KEM.Decaps}(\mathrm{sk}_{\mathrm{kem}},\mathrm{ct}_{\mathrm{kem}})\rightarrow \mathbf{ss}\text{ ou }\bot\)

Signature :
- \(\mathrm{SIG.KeyGen}(\mathbf{seed})\rightarrow(\mathrm{pk}_{\mathrm{sig}},\mathrm{sk}_{\mathrm{sig}})\)
- \(\mathrm{SIG.Sign}(\mathrm{sk}_{\mathrm{sig}},m)\rightarrow \sigma\)
- \(\mathrm{SIG.Verify}(\mathrm{pk}_{\mathrm{sig}},m,\sigma)\rightarrow \{\mathrm{true},\mathrm{false}\}\)

Si les implémentations disponibles n’exposent pas de KeyGen « seedé », la correction consiste à instancier un DRBG déterministe \(\mathrm{DRBG}\) initialisé par \(\mathbf{seed}\) et à fournir son flux en remplacement de l’aléa interne de KeyGen.

### Profils indicatifs

Profil standard :
- \(\ell_S=2048\)
- \(b=128\)
- \(k_{\mathrm{mix}}=512\)

Profil haute sécurité :
- \(\ell_S=4096\)
- \(b=256\)
- \(k_{\mathrm{mix}}=1024\)

Le dimensionnement final doit rester cohérent avec la sécurité du KEM et de la signature réellement utilisés ; CollatzMix n’augmente pas le niveau de sécurité au‑delà de ces primitives.

## Définition de l’opérateur de Collatz perturbé

Soit \(n\in\mathbb{I}\). On pose \(v=v_2(3n+1)\) et \(e\in\{0,1\}\).

Numérateur perturbé :
\[
N^\*(n,e)=3n+1+2^{v_2(3n+1)}\cdot e.
\]

Exposant de normalisation (définition non ambiguë) :
\[
a^\*(n,e)=v_2\!\bigl(N^\*(n,e)\bigr).
\]

Opérateur perturbé :
\[
U^\*(n,e)=\frac{N^\*(n,e)}{2^{a^\*(n,e)}}.
\]

Propriété :
\[
U^\*(n,e)\in\mathbb{I}.
\]

Trajectoire perturbée sur \(k_{\mathrm{mix}}\) pas, pour un vecteur \(\vec e\in\{0,1\}^{k_{\mathrm{mix}}}\) :
\[
U^{\*(k_{\mathrm{mix}})}(S,\vec e)=U^\*(\cdots U^\*(U^\*(S,e_0),e_1)\cdots,e_{k_{\mathrm{mix}}-1}).
\]

## Expansion du bruit binaire

Le protocole n’expose pas \(\vec e\) et n’utilise pas une “taille de bruit” distincte de \(k_{\mathrm{mix}}\). Le seul paramètre de bruit est un seed \(E\) de taille \(b\) bits.

Définition :
\[
\vec e = \mathrm{XOF}(E\parallel \mathrm{dst}\parallel \mathrm{EncInt}(k_{\mathrm{mix}}))[0..k_{\mathrm{mix}}-1],
\]
où \(\mathrm{dst}\) est une étiquette de séparation de domaine, et \([0..k_{\mathrm{mix}}-1]\) signifie “prendre les \(k_{\mathrm{mix}}\) premiers bits”.

## Fonction de mélange CollatzMix

### Spécification

Entrées :
- secret maître \(S\in\mathbb{I}\), encodé sur \(\ell_S\) bits
- seed d’erreur \(\mathbf{E}\in\{0,1\}^b\)
- étiquette de domaine \(\mathrm{dst}\) (chaîne courte)
- longueur désirée \(\ell\) bits

Sortie :
- \(\mathbf{out}\in\{0,1\}^\ell\)

### Algorithme CollatzMix

1. \(\vec e \leftarrow \mathrm{ExpandBits}(\mathbf{E},\mathrm{dst},k_{\mathrm{mix}})\)
2. \(X_0 \leftarrow S\)
3. Pour \(i\) de \(0\) à \(k_{\mathrm{mix}}-1\) :
   - \(X_{i+1} \leftarrow U^\*(X_i,e_i)\)
4. Pour \(i\) de \(0\) à \(k_{\mathrm{mix}}\) :
   - \(\mathbf{B}_i \leftarrow \mathrm{Hash}(\mathrm{dst}\parallel \mathrm{EncInt}(i)\parallel \mathrm{EncInt}_{\ell_S}(X_i))\)
5. \(\mathbf{out} \leftarrow (\mathbf{B}_0\parallel \mathbf{B}_1\parallel \cdots)[0..\ell-1]\)

Notes d’implémentation :
- \(\mathrm{dst}\) doit être constant et distinct pour chaque usage (KEM seed, KEM noise, signature seed, signature noise, etc.).
- L’encodage \(\mathrm{EncInt}_{\ell_S}(X_i)\) est nécessaire pour éviter des collisions d’encodage.
- Les itérations doivent être exécutées en temps aussi régulier que possible ; la valuation \(v_2(\cdot)\) induit des branches qui peuvent révéler de l’information via des canaux auxiliaires si l’implémentation est naïve.

## Génération de la clé maîtresse

### Algorithme MasterKeyGen

Entrées :
- paramètres \((\ell_S,b,k_{\mathrm{mix}})\)

Sorties :
- \(\mathrm{msk}=(S,\mathbf{E})\)

Procédure :
1. Échantillonner uniformément un entier impair \(S\) de taille \(\ell_S\) bits.
2. Échantillonner uniformément \(\mathbf{E}\in\{0,1\}^b\).
3. Rejeter et ré‑échantillonner \(S\) si \(3S+1\) est une puissance de \(2\), c’est‑à‑dire s’il existe \(x\in\mathbb{N}\) tel que \(3S+1=2^x\).
4. Retourner \(\mathrm{msk}=(S,\mathbf{E})\).

Ce filtrage évite des cas pathologiques évidents ; il n’est pas présenté comme preuve de sécurité.

## Dérivation des seeds et structure des clés

### Seeds dérivés

Les seeds sont dérivés par séparation de domaine, avec longueurs propres à chaque primitive.

\[
\mathbf{\rho_{kem}}=\mathrm{CollatzMix}(S,\mathbf{E},\text{"kem-seed"},\ell_\rho)
\]
\[
\mathbf{\sigma_{kem}}=\mathrm{CollatzMix}(S,\mathbf{E},\text{"kem-noise"},\ell_\sigma)
\]
\[
\mathbf{\rho_{sig}}=\mathrm{CollatzMix}(S,\mathbf{E},\text{"sig-seed"},\ell_\rho)
\]
\[
\mathbf{\sigma_{sig}}=\mathrm{CollatzMix}(S,\mathbf{E},\text{"sig-noise"},\ell_\sigma)
\]

Le schéma retenu fixe l’usage précis de \(\ell_\rho\) et \(\ell_\sigma\).

### Clé publique et clé privée

Clé publique :
\[
\mathrm{pk}=(\mathrm{pk}_{\mathrm{kem}},\mathrm{pk}_{\mathrm{sig}},\mathrm{param})
\]
où \(\mathrm{param}\) est l’identifiant de profil et les paramètres publics (y compris \(k_{\mathrm{mix}},\ell_S,b,h\) et le choix des primitives).

Clé privée opérationnelle :
\[
\mathrm{sk}=(\mathrm{sk}_{\mathrm{kem}},\mathrm{sk}_{\mathrm{sig}})
\]

Clé privée reconstructible (optionnelle, pour dérivation déterministe) :
\[
\mathrm{msk}=(S,\mathbf{E})
\]
permet de reconstruire \((\mathrm{sk}_{\mathrm{kem}},\mathrm{sk}_{\mathrm{sig}})\) par recalcul.

Une implémentation peut conserver \(\mathrm{sk}\) seul, ou \(\mathrm{msk}\) seul, ou les deux, selon le modèle de menace et les contraintes d’ergonomie.

## Algorithmes formels

### KeyGen

Entrées :
- paramètres publics \(\mathrm{param}\)

Sorties :
- \((\mathrm{pk},\mathrm{sk})\) et éventuellement \(\mathrm{msk}\)

Procédure :
1. \(\mathrm{msk}=(S,\mathbf{E})\leftarrow \mathrm{MasterKeyGen}(\ell_S,b,k_{\mathrm{mix}})\)
2. Dériver \(\mathbf{\rho_{kem}},\mathbf{\sigma_{kem}},\mathbf{\rho_{sig}},\mathbf{\sigma_{sig}}\) comme défini plus haut.
3. \((\mathrm{pk}_{\mathrm{kem}},\mathrm{sk}_{\mathrm{kem}})\leftarrow \mathrm{KEM.KeyGen}(\mathbf{\rho_{kem}}\parallel \mathbf{\sigma_{kem}})\)
4. \((\mathrm{pk}_{\mathrm{sig}},\mathrm{sk}_{\mathrm{sig}})\leftarrow \mathrm{SIG.KeyGen}(\mathbf{\rho_{sig}}\parallel \mathbf{\sigma_{sig}})\)
5. \(\mathrm{pk}\leftarrow (\mathrm{pk}_{\mathrm{kem}},\mathrm{pk}_{\mathrm{sig}},\mathrm{param})\)
6. \(\mathrm{sk}\leftarrow (\mathrm{sk}_{\mathrm{kem}},\mathrm{sk}_{\mathrm{sig}})\)
7. Retourner \((\mathrm{pk},\mathrm{sk})\) et, selon politique, \(\mathrm{msk}\).

Commentaires de correction :
- la concaténation \(\mathbf{\rho}\parallel \mathbf{\sigma}\) fournit une entropie et une séparation suffisantes pour alimenter un DRBG interne si nécessaire.
- si le KEM ou la signature exigent plusieurs sources de seeds, le mapping exact doit être documenté par la primitive choisie.

### Encaps

Encapsulation d’un secret partagé, puis chiffrement hybride optionnel d’un message via AEAD.

Entrées :
- clé publique \(\mathrm{pk}\)
- message optionnel \(M\) (octets)
- données associées \(\mathrm{ad}\) (octets, optionnel)

Sorties :
- encapsulat \(\mathrm{ct}\)
- secret partagé \(\mathbf{K}\) (pour usage externe) ou clé AEAD interne
- si \(M\) est présent, un ciphertext AEAD

Procédure :
1. Extraire \(\mathrm{pk}_{\mathrm{kem}}\) de \(\mathrm{pk}\).
2. \((\mathrm{ct}_{\mathrm{kem}},\mathbf{ss})\leftarrow \mathrm{KEM.Encaps}(\mathrm{pk}_{\mathrm{kem}})\)
3. \(\mathbf{K}\leftarrow \mathrm{KDF}(\text{"kem"}\parallel \mathbf{ss}\parallel \mathrm{ct}_{\mathrm{kem}})\)
4. Si \(M\) est absent :
   - \(\mathrm{ct}\leftarrow \mathrm{ct}_{\mathrm{kem}}\)
   - retourner \((\mathrm{ct},\mathbf{K})\)
5. Si \(M\) est présent :
   - \(\mathbf{K}_{\mathrm{aead}}\leftarrow \mathrm{KDF}(\text{"aead"}\parallel \mathbf{K})\)
   - choisir un \(\mathrm{nonce}\) conforme à l’AEAD (unique par clé)
   - \((C,\mathrm{tag})\leftarrow \mathrm{AEAD.Enc}(\mathbf{K}_{\mathrm{aead}},\mathrm{nonce},M,\mathrm{ad})\)
   - \(\mathrm{ct}\leftarrow (\mathrm{ct}_{\mathrm{kem}},\mathrm{nonce},\mathrm{ad},C,\mathrm{tag})\)
   - retourner \((\mathrm{ct},\mathbf{K})\)

### Decaps

Décapsulation du secret partagé et déchiffrement hybride optionnel.

Entrées :
- clé privée \(\mathrm{sk}\)
- encapsulat \(\mathrm{ct}\)

Sorties :
- \(\mathbf{K}\) ou \(\bot\)
- si le mode hybride est utilisé, \(M\) ou \(\bot\)

Procédure :
1. Extraire \(\mathrm{sk}_{\mathrm{kem}}\) de \(\mathrm{sk}\).
2. Si \(\mathrm{ct}\) est du type simple :
   - \(\mathrm{ct}_{\mathrm{kem}}\leftarrow \mathrm{ct}\)
3. Si \(\mathrm{ct}\) est du type hybride :
   - \((\mathrm{ct}_{\mathrm{kem}},\mathrm{nonce},\mathrm{ad},C,\mathrm{tag})\leftarrow \mathrm{ct}\)
4. \(\mathbf{ss}\leftarrow \mathrm{KEM.Decaps}(\mathrm{sk}_{\mathrm{kem}},\mathrm{ct}_{\mathrm{kem}})\)
5. Si \(\mathbf{ss}=\bot\), retourner \(\bot\).
6. \(\mathbf{K}\leftarrow \mathrm{KDF}(\text{"kem"}\parallel \mathbf{ss}\parallel \mathrm{ct}_{\mathrm{kem}})\)
7. Si \(\mathrm{ct}\) est du type simple, retourner \(\mathbf{K}\).
8. \(\mathbf{K}_{\mathrm{aead}}\leftarrow \mathrm{KDF}(\text{"aead"}\parallel \mathbf{K})\)
9. \(M\leftarrow \mathrm{AEAD.Dec}(\mathbf{K}_{\mathrm{aead}},\mathrm{nonce},C,\mathrm{ad},\mathrm{tag})\)
10. Retourner \(M\) si succès, sinon \(\bot\).

### Sign

Entrées :
- clé privée \(\mathrm{sk}\)
- message \(m\) (octets)

Sortie :
- signature \(\sigma\)

Procédure :
1. Extraire \(\mathrm{sk}_{\mathrm{sig}}\) de \(\mathrm{sk}\).
2. \(\sigma \leftarrow \mathrm{SIG.Sign}(\mathrm{sk}_{\mathrm{sig}},m)\)
3. Retourner \(\sigma\).

### Verify

Entrées :
- clé publique \(\mathrm{pk}\)
- message \(m\)
- signature \(\sigma\)

Sortie :
- \(\mathrm{true}\) ou \(\mathrm{false}\)

Procédure :
1. Extraire \(\mathrm{pk}_{\mathrm{sig}}\) de \(\mathrm{pk}\).
2. Retourner \(\mathrm{SIG.Verify}(\mathrm{pk}_{\mathrm{sig}},m,\sigma)\).

## Propriétés attendues

### Correction

Correction KEM :
\[
\Pr\bigl[\mathbf{ss}=\mathbf{ss}' \mid (\mathrm{pk}_{\mathrm{kem}},\mathrm{sk}_{\mathrm{kem}})\leftarrow \mathrm{KEM.KeyGen},\ (\mathrm{ct}_{\mathrm{kem}},\mathbf{ss})\leftarrow \mathrm{KEM.Encaps}(\mathrm{pk}_{\mathrm{kem}}),\ \mathbf{ss}'\leftarrow \mathrm{KEM.Decaps}(\mathrm{sk}_{\mathrm{kem}},\mathrm{ct}_{\mathrm{kem}})\bigr]=1.
\]

Correction signature :
\[
\mathrm{SIG.Verify}(\mathrm{pk}_{\mathrm{sig}},m,\mathrm{SIG.Sign}(\mathrm{sk}_{\mathrm{sig}},m))=\mathrm{true}.
\]

### Objectifs de sécurité

Confidentialité :
- objectif typique IND‑CCA2 pour l’encapsulation et le chiffrement hybride, hérité du KEM et de l’AEAD.

Authenticité :
- objectif typique EUF‑CMA pour la signature, hérité du schéma de signature.

Le rôle de CollatzMix est celui d’un dérivateur de seeds et d’un mécanisme de séparation de domaines ; aucune affirmation de réduction vers SVP ou LWE n’est portée par la partie Collatz elle‑même dans cette version.

## Recommandations d’implémentation

Gestion des canaux auxiliaires :
- éviter des branches manifestement dépendantes de \(v_2(\cdot)\) sans compensation ; l’opérateur CollatzMix doit être traité comme une fonction sensible si \(\mathrm{msk}\) est présent en mémoire.
- effacer en mémoire les valeurs intermédiaires \(X_i\) si l’environnement le permet.

Séparation des domaines :
- les chaînes \("kem-seed"\), \("kem-noise"\), \("sig-seed"\), \("sig-noise"\) doivent être considérées comme constantes de protocole, non modifiables par un attaquant.

Nonces AEAD :
- un nonce ne doit jamais être réutilisé avec la même clé \(\mathbf{K}_{\mathrm{aead}}\).
- si la politique l’autorise, un nonce aléatoire est acceptable, sinon un compteur persistant est requis.

Encodages :
- tous les encodages d’entiers doivent être fixés une fois pour toutes ; une ambiguïté d’encodage détruit la séparation de domaines et peut créer des collisions.

## Conclusion

La spécification v2.1 formalise un protocole hybride où la dynamique Collatz perturbée et son bruit binaire ne prétendent plus porter, seules, la sécurité asymétrique. La correction est obtenue en confiant l’encapsulation et la signature à des primitives asymétriques explicitement décrites par des algorithmes KeyGen, Encaps, Decaps, Sign, Verify, et en utilisant CollatzMix comme mécanisme de dérivation déterministe et de séparation de domaines. Cette architecture rend la correction vérifiable et ouvre la voie à une évaluation cryptanalytique réaliste, centrée sur les primitives KEM et signature choisies et sur l’implémentation de la dérivation CollatzMix en présence de canaux auxiliaires.