# Spécification du protocole `rdv-vote/1`, révision 3

*Version du 22 octobre 2026 (document d'architecture v39). Extrait de la partie 7 du document « Architecture cryptographique » de l'auteur (Eric Prosé), sans la section « Écarts connus avec le démonstrateur » ni la section sur le dimensionnement de la plateforme. Les renvois à d'autres parties du document (parties 1 à 6, 8 et 9) ne sont pas publiés. **Révision 3** : la signature en aveugle du droit de vote suit le RFC 9474 (variante RSABSSA-SHA384-PSS-Deterministic, module de 3072 bits), avec le choix de la variante argumenté en 7.7 ; la section 7.9 bis décrit le vote indivisible d'une session à plusieurs tableaux ; le modèle de menaces et ses limites sont en 7.18 ; journal des révisions en 7.19. Prototype : non audité. Droits : © 2026 Eric Prosé ; la lecture, la copie et l'écriture d'une implémentation conforme sont autorisées ; licence du document à confirmer.*

## Spécification

### 7.1 Statut et vocabulaire

Cette partie est **normative** : elle décrit le protocole assez précisément pour que d'autres équipes écrivent, sans lire le code du démonstrateur, un programme compatible : le programme des tutelles (partie 8), un second vérificateur public, une application de vote. Version du protocole : `rdv-vote/1`, **révision 2** (octobre 2026, première relecture externe : voir 7.19). Aucun scrutin réel n'a eu lieu : la révision 2 remplace la révision 1 sans période de compatibilité.

Les mots **DOIT**, **NE DOIT PAS**, **DEVRAIT** ont leur sens habituel des normes techniques. Le code PHP du démonstrateur est l'**implémentation de référence provisoire** : tant que cette spécification et ce code se contredisent, l'un des deux a un défaut, à corriger et à consigner (section 7.15). Les vecteurs de test de la section 7.14 tranchent.

Notations. `G` est le point de base du groupe. `ℓ` est l'ordre du groupe. Pour un scalaire `x`, `x·P` désigne la multiplication d'un point par un scalaire. `‖` désigne la concaténation d'octets. `X` (majuscule) est la clé publique de la clé secrète `x`.

### 7.2 Conventions d'encodage

- **Scalaire** : 32 octets, petit-boutiste (*little-endian*), strictement inférieur à `ℓ`. Un scalaire non canonique (≥ ℓ) **DOIT être refusé** par tout vérificateur.
- **Point** : 32 octets, encodage canonique ristretto255 (RFC 9496). Un point mal formé **DOIT être refusé**. Le **point neutre** est l'encodage de 32 octets nuls.
- **Hexadécimal** : minuscules, deux caractères par octet. **Un vérificateur DOIT refuser les majuscules** : un même objet n'a qu'une écriture, ce qui ferme toute malléabilité des contextes et des empreintes qui l'incluent. Un point ou un scalaire en hexadécimal fait donc 64 caractères. Les fichiers et les messages échangés portent toujours de l'hexadécimal, jamais de binaire.
- **Texte** : UTF-8, sans normalisation. Les étiquettes et contextes ci-dessous sont des textes ASCII. **Aucun élément interpolé dans un contexte ne peut contenir le séparateur `|`** : les identifiants sont des entiers décimaux, les clés et les empreintes de l'hexadécimal minuscule vérifié avant usage.
- **Entier de longueur** : `u32be(n)` = `n` sur 4 octets, grand-boutiste (*big-endian*).
- **JSON** : un document JSON est du texte UTF-8. Lorsqu'une signature ou une empreinte porte sur un JSON (le contenu d'un bulletin), **elle porte sur les octets exacts transmis, jamais sur une réécriture** : un programme **NE DOIT PAS** réencoder le JSON avant de calculer une empreinte ou de vérifier une signature. Il le lit (profondeur maximale 16) seulement pour en extraire les valeurs.

### 7.3 Primitives

| Rôle | Primitive | Détail |
|---|---|---|
| Groupe | ristretto255 (RFC 9496) | ordre `ℓ = 2^252 + 27742317777372353535851937790883648493` ; générateur `G` = point de base standard, encodé `e2f2ae0a6abc4e71a884a961c500515f58e30b6aa582dd8db6a65945e08d2d76` |
| Défi des preuves | BLAKE2b-512, sans clé | voir ci-dessous (`H`) |
| Empreintes de chaîne, de bulletin, d'engagement | SHA-256 | sortie en hexadécimal minuscule |
| Signature des points de contrôle | Ed25519 (RFC 8032) | signature détachée, clé publique de 32 octets |
| Droit de vote | RSABSSA-SHA384-PSS-Deterministic (RFC 9474), signature en aveugle | exposant public 65537 ; **module de 3072 bits** (7.7) |
| Protection de la part de clé d'une tutelle | Argon2id + chiffrement authentifié | paramètres à fixer (7.15) |

**La fonction défi `H`.** Pour une liste d'éléments `x₁ … xₙ` (chacun une suite d'octets) :

```
H(x₁, …, xₙ) = réduction_mod_ℓ( BLAKE2b-512( u32be(|x₁|) ‖ x₁ ‖ … ‖ u32be(|xₙ|) ‖ xₙ ) )
```

La réduction interprète les 64 octets en petit-boutiste et les réduit modulo `ℓ` (celle de libsodium, `crypto_core_ristretto255_scalar_reduce`). Dans les listes, **les points figurent en 32 octets binaires** (pas en hexadécimal) et **les textes en UTF-8**. Le préfixe de longueur rend la concaténation sans ambiguïté.

### 7.4 Chiffrement exponentiel et clé de l'élection

- Chaque tutelle `i` (1, 2, 3) possède une **part secrète** `xᵢ` (scalaire aléatoire) et publie sa **partie publique** `hᵢ = xᵢ·G`.
- **Clé de l'élection** : `H_E = h₁ + h₂ + h₃`. La clé secrète correspondante `x₁ + x₂ + x₃` **n'existe nulle part**.
- **Chiffrement** d'un entier `m` avec le nombre aléatoire `r` : `Enc(m, r) = (a, b)` avec `a = r·G` et `b = m·G + r·H_E`.
- **Addition** de deux chiffrés : composante par composante. **Soustraction** : de même. Le chiffré nul est `(neutre, neutre)`.
- **Compteurs.** Un scrutin a une liste ordonnée de questions, chacune une liste ordonnée d'options. Le **compteur** `j` (à partir de 0) numérote les couples (question, option) dans cet ordre : toutes les options de la question 0, puis celles de la question 1, etc. Un bulletin porte un chiffré par compteur.

### 7.5 Preuves à divulgation nulle de connaissance

Toutes les preuves sont non interactives (Fiat-Shamir) et liées à un **contexte** textuel qui évite le rejeu d'une preuve dans un autre bulletin.

**(a) Preuve de connaissance, et signature de Schnorr.** Pour prouver la connaissance de `x` tel que `X = x·G`, avec une étiquette `e` et un message `μ` (textes) :

```
k aléatoire ; T = k·G ; c = H(e, X, T, μ) ; s = k + c·x  mod ℓ
preuve = (c, s)
vérification : T' = s·G − c·X ; accepter si c = H(e, X, T', μ)
```

**(b) Égalité de logarithmes (Chaum-Pedersen).** Pour prouver `x` tel que `y₁ = x·g₁` et `y₂ = x·g₂`, avec un contexte `κ` :

```
k aléatoire ; T₁ = k·g₁ ; T₂ = k·g₂
c = H("cp", κ, g₁, y₁, g₂, y₂, T₁, T₂) ; s = k + c·x
vérification : T₁' = s·g₁ − c·y₁ ; T₂' = s·g₂ − c·y₂ ; accepter si c = H("cp", κ, g₁, y₁, g₂, y₂, T₁', T₂')
```

**(c) Chiffré de 0 ou de 1 (preuve disjonctive).** Pour un chiffré `(a, b)` de `m ∈ {0,1}` avec le nombre aléatoire `r` : l'énoncé `j` (`j = 0` ou `1`) est « `(a, b − j·G)` est un couple de la forme `(r·G, r·H_E)` ». La preuve est `(c₀, s₀, c₁, s₁)` et se vérifie ainsi :

```
pour j = 0, 1 :  T1ⱼ = sⱼ·G − cⱼ·a ;  T2ⱼ = sⱼ·H_E − cⱼ·(b − j·G)
accepter si  c₀ + c₁ = H("bit", κ, H_E, a, b, T1₀, T2₀, T1₁, T2₁)  (mod ℓ)
```

**(d) Un seul choix par question.** La somme des chiffrés d'une question, `(A, B) = Σ (aⱼ, bⱼ)`, doit contenir exactement 1 : on prouve que `(A, B − G)` est de la forme `(R·G, R·H_E)` avec `R = Σ rⱼ`, par une preuve (b) avec `g₁ = G`, `y₁ = A`, `g₂ = H_E`, `y₂ = B − G`.

**Contextes (textes ASCII).**

| Preuve | Étiquette ou contexte `κ` |
|---|---|
| Connaissance de la part d'une tutelle | étiquette `pok-tutelle`, message `ceremonie\|{scrutin}\|{tutelle}` |
| Signature du votant sur un bulletin | étiquette `bulletin`, message = les octets exacts du contenu du bulletin |
| Chiffré 0/1 de l'option `j` de la question `i` | `scrutin:{id}\|cle:{clé hexa}\|revision:{n}\|question:{i}\|option:{j}` |
| Un seul choix, question `i` | `scrutin:{id}\|cle:{clé hexa}\|revision:{n}\|question:{i}\|somme` |
| Contribution d'une tutelle au compteur `j` | `contribution\|{scrutin}\|{tutelle}\|{j}\|{empreinte du total fermé}` (7.11) |

### 7.6 Cérémonie des clés

1. **Engagement.** Chaque tutelle `i` génère `xᵢ`, calcule `hᵢ`, et publie d'abord son **engagement** `SHA-256(hᵢ en 32 octets)` en hexadécimal.
2. **Révélation.** Quand les trois engagements sont publiés, chaque tutelle publie `hᵢ` et une preuve de connaissance (5.a) de `xᵢ`.
3. **Contrôle public.** Pour chaque tutelle : le numéro est 1, 2 ou 3, `hᵢ` est un point valide **et différent du point neutre**, `SHA-256(hᵢ)` égale l'engagement publié, et la preuve est juste. Il y a **exactement trois** tutelles, **de numéros distincts 1, 2 et 3**. `H_E = h₁ + h₂ + h₃` est publiée.

**Pourquoi refuser le point neutre (révision 2).** Le point neutre est un point valide, la preuve de connaissance de `x = 0` est triviale et l'engagement correspond : sans refus explicite, une tutelle (ou un boîtier trafiqué) pourrait publier une partie nulle et le seuil de 3 sur 3 tomberait silencieusement à 2 sur 2. Le refus porte sur la **vérification publique**, qui est la référence ; le programme de génération rejette en plus tout `x = 0` à la source.

L'ordre engagement puis révélation empêche une tutelle de choisir sa partie publique après avoir vu celle des autres (ce qui lui permettrait de contrôler `H_E`).

**Objet publié « partie de tutelle »** : `{"tutelle": i, "h": hexa, "engagement": hexa, "preuve": [c hexa, s hexa]}`.

### 7.7 Droit de vote : signature en aveugle

Le registre signe, sans la voir, une valeur liée à la clé publique du votant. La signature est la **signature RSA en aveugle normalisée du RFC 9474** (*RSA Blind Signatures*), dans sa variante **RSABSSA-SHA384-PSS-Deterministic** : encodage RSASSA-PSS (RFC 8017) avec SHA-384, MGF1-SHA-384 et un sel de 48 octets, **sans préfixe aléatoire** de message ; module de **3072 bits** (384 octets) et exposant public `e = 65537`. La variante sans préfixe aléatoire est celle que le RFC (section 5) autorise lorsque le message est à forte entropie : ici le message contient la clé publique du votant, tirée au hasard par son appareil.

**Message signé.** Pour la clé publique `K` du votant (32 octets) **et le numéro de scrutin `s`** (entier décimal en ASCII) : `msg = "rdv-vote-droit|" ‖ s ‖ "|" ‖ K`. **Le scrutin entre dans le message** : un droit obtenu pour un scrutin n'est pas rejouable dans un autre, même si la clé RSA du registre est la même ; sans cela, seul le contrôle a posteriori `N ≤ droits émis` détectait l'incohérence.

- **Brouillage par le votant** (*Blind*, RFC 9474, 4.2) : `EM = EMSA-PSS-ENCODE(msg, 3071)` avec un sel aléatoire de 48 octets ; `m = EM` en entier ; `r` tiré uniformément dans `[1, n)` (par rejet), `inv = r⁻¹ mod n` ; `z = m · r^e mod n`, envoyé au registre sur 384 octets. Le votant garde `inv`.
- **Signature par le registre** (*BlindSign*, 4.3) : `s' = z^d mod n` (RSA brut), sur 384 octets. **Le registre vérifie avant de répondre que `s'^e mod n = z`** : un défaut de calcul ne sort jamais.
- **Débrouillage par le votant** (*Finalize*, 4.4) : `s = s' · inv mod n`, sur 384 octets ; il **vérifie la signature** (RSASSA-PSS-VERIFY) avant de la garder.
- **Vérification publique** : RSASSA-PSS-VERIFY (RFC 8017, 8.1.2) de `msg` et `s` avec la clé du registre, SHA-384, MGF1-SHA-384 et un sel de 48 octets. Toute signature de longueur différente de 384 octets est refusée, ainsi que toute clé du registre dont le module n'a pas exactement 3072 bits.

Le registre ne voit que `z` : il ne peut pas rattacher `s` à la personne qui s'est authentifiée, car `z` est indépendant de `msg` (le brouillage est parfait). **Vecteurs de test.** Le **vecteur A.3 du RFC 9474** (RSABSSA-SHA384-PSS-Deterministic, la variante retenue) fait partie du jeu de vecteurs publics (fichier `08-rfc9474-a3.json`, valeurs recopiées sans changement) et est rejoué par le programme de tests publié (`rdv-temoin conformite`) comme par l'implémentation PHP de référence : encodage EMSA-PSS, cohérence de la signature brouillée (`blind_sig^e = blinded_msg`), débrouillage, vérification, refus d'un autre message ou d'une signature altérée. Les quatre vecteurs de l'annexe A (A.1 à A.4) sont en plus rejoués étape par étape, avec *Blind* et *BlindSign*, par les tests des trois implémentations (PHP, Rust, application du votant), sur des modules de 4096 bits : les fonctions d'encodage et de vérification acceptent toute taille de module, le protocole du vote en exige une seule (3072 bits).

**Choix de la variante : pourquoi RSABSSA-SHA384-PSS-Deterministic plutôt qu'une variante randomisée.** Le RFC 9474 recommande par défaut les variantes randomisées (PSS-Randomized ou PSSZERO-Randomized), qui ajoutent à chaque message un préfixe aléatoire de 32 octets : elles sont sûres pour tous les usages (section 7.3). Le protocole du vote s'écarte de cette recommandation, pour les raisons suivantes, consignées ici afin qu'un relecteur n'ait pas à les deviner :

- **La condition de sûreté du RFC est remplie par construction.** Le RFC (section 7.3, *Message Entropy*) reconnaît qu'une variante sans randomisation est sûre si « le message d'entrée a une valeur que le signataire ne peut pas deviner : le client a ajouté une composante à haute entropie qui n'était pas à la disposition du signataire avant qu'il choisisse sa clé de signature » (condition 2). Le message du droit est `"rdv-vote-droit|" ‖ scrutin ‖ "|" ‖ K` : **`K`, la clé publique du votant (32 octets, dérivée d'un secret de 252 bits tiré par un générateur cryptographique), est cette composante.** Elle est créée par l'appareil du votant au moment du vote, après que la cérémonie a fixé la clé du registre du scrutin ; le registre ne peut donc pas la deviner. **Exigence normative** : `K` DOIT être tirée par l'appareil avec au moins 128 bits d'entropie, avant toute interaction avec le registre pour ce vote ; elle NE DOIT PAS être dérivée d'une donnée connue du registre (identité, numéro d'électeur, adresse) ni d'un mot de passe. Il n'est pas ajouté de nonce distinct : un nonce supplémentaire n'apporterait aucune entropie de plus, et il faudrait le transporter avec chaque droit, dans chaque bulletin.
- **Le coût d'une variante randomisée serait réel, sans bénéfice.** Le préfixe de 32 octets doit accompagner la signature pour que chacun puisse vérifier (sans lui, `msg` n'est pas reconstructible) : un champ de plus dans l'enveloppe de chaque bulletin, soit environ 1,2 Go de plus par tableau à 36 millions de bulletins, un changement de format dans les trois implémentations et dans les vecteurs, pour protéger contre un risque (message à faible entropie) que la construction écarte déjà.
- **Le sel PSS reste aléatoire.** La variante retenue est la variante PSS (sel de 48 octets), et non PSSZERO : chaque signature contient un sel tiré à chaque échange, comme dans une signature RSASSA-PSS ordinaire.
- **Le RFC écarte l'autre condition.** La condition (1) du RFC (preuve que la clé du signataire est honnête) n'est pas utilisée : on ne s'appuie que sur la condition (2).
- **Réversibilité.** Passer à une variante randomisée, si un relecteur ou une évolution du protocole le demande, est un changement borné : ajouter le préfixe de 32 octets au droit et à la vérification, sans toucher au reste du protocole.
- **Point à faire valider par un cryptographe** : l'analyse ci-dessus, et le lien avec la créance de Belenios (partie 9).

**Aléa d'aveuglement et autres valeurs aléatoires (RFC 9474, section 7.4).** Toutes les valeurs aléatoires du protocole, **le facteur d'aveuglement `r`**, le sel PSS et la clé `K`, DOIVENT être tirées d'un générateur cryptographique à chaque échange. En particulier **l'aléa d'aveuglement reste obligatoire à chaque échange**, même si le message est à forte entropie : `r` est tiré uniformément dans `[1, n)` pour chaque demande de droit (un droit par scrutin), n'est jamais réutilisé d'un scrutin à l'autre ni d'un électeur à l'autre, et n'est jamais dérivé de `msg` ni d'une autre valeur connue du registre. Un facteur réutilisé ou prévisible permettrait au registre de rapprocher le message brouillé qu'il a reçu de la signature publiée, et ruinerait la séparation entre l'identité et le bulletin.

**Usage de la clé et risques propres au RFC (sections 6 et 7).** La clé du registre est propre à un scrutin et ne sert à aucun autre protocole ni à aucun autre choix d'encodage (le RFC l'interdit). Un registre malveillant pourrait publier une clé invalide pour apprendre quelque chose sur des messages à faible entropie : le message du votant étant à forte entropie, ce risque est écarté. Un vérificateur contrôle que la signature est valide sous la clé publiée avec les paramètres du scrutin, par l'émetteur attendu.
**Taille de la clé et garde de la clé du registre (révision 2, exigences de production).**

- **Taille.** Le module du registre fait **3072 bits** (384 octets), taille retenue pour un dispositif destiné à durer ; une signature coûte quelques millisecondes, négligeable à l'échelle d'un scrutin. La clé publique du registre est publiée avec les paramètres du scrutin. **Précision sur la menace quantique** : une clé RSA, quelle que soit sa taille, ne résiste pas à un ordinateur quantique ; elle ne protège cependant pas le secret du vote, car le brouillage est parfait (le message `z` vu par le registre est indépendant de `msg`) : seule la fabrication de faux droits serait possible, et seulement pendant la durée du scrutin.
- **Clé du registre.** C'est la clé qui fabrique les droits de vote : sa compromission permet du bourrage à grande échelle. Elle **DOIT** être générée et gardée dans un module matériel de sécurité (HSM) ou un KMS qualifié, **jamais** présente en clair sur le serveur d'application ; ses signatures sont journalisées dans un journal infalsifiable ; la **clé est propre à un scrutin** (en plus de la liaison du scrutin dans le message signé) et détruite après clôture. Même règle pour la **clé Ed25519 de signature de l'urne**. À l'inverse, les **parts de clé des tutelles** ne sont **jamais** confiées à un HSM ou à un prestataire : la confiance ne doit pas se concentrer. La procédure de garde est à rédiger avant tout usage réel (section 8.9).

### 7.8 Bulletin

**Contenu** (JSON, UTF-8, octets exacts transmis) :

```json
{"v":1,"scrutin":1,"cle":"<K en 64 car. hexa>","revision":1,
 "q":[ {"o":[ {"a":"<hexa>","b":"<hexa>","p":["c0","s0","c1","s1"]}, … ],
        "s":["c","s"]}, … ]}
```

`cle` est la clé publique du votant ; `revision` un entier ≥ 1 ; `q[i].o[j]` le chiffré (5.c) de l'option `j` de la question `i`, et `q[i].s` la preuve « un seul choix » (5.d).

**Enveloppe** : `{contenu, signature, droit}`. `signature` est la concaténation hexadécimale `c ‖ s` (128 caractères) de la signature de Schnorr (5.a) avec l'étiquette `bulletin` et le message = les octets de `contenu`. `droit` est la signature RSA `S` en hexadécimal (768 caractères).

**Règles de validité** (un bulletin est accepté si et seulement si toutes sont vraies) :

1. `v = 1`, `scrutin` égale l'identifiant du scrutin, `revision` entier ≥ 1, `cle` point valide.
2. `droit` est une signature valide du registre sur `cle` (7.7).
3. `signature` est une signature de Schnorr valide de `cle` sur `contenu`.
4. Il y a exactement une entrée `q` par question, et exactement un chiffré par option, chaque `a` et `b` étant un point valide.
5. Chaque chiffré porte une preuve (5.c) juste, avec son contexte.
6. Chaque question porte une preuve (5.d) juste, avec son contexte.
7. **Révision** : un bulletin d'une `cle` déjà présente n'est accepté que si sa `revision` est **strictement supérieure** à celle du dernier bulletin de cette clé.
8. **Taille** (révision 2) : le `contenu` ne dépasse pas **1 Mio** ; un bulletin plus grand est refusé **avant** toute analyse ou tout hachage (défense en profondeur ; la limite laisse de la marge à plusieurs milliers de réponses, 7.17). Les chaînes hexadécimales du bulletin (clé, signature, droit, points) sont en minuscules (7.2).

### 7.9 Urne : chaîne d'empreintes, cumul, points de contrôle

**Empreinte d'un bulletin** : `SHA-256( contenu ‖ "|" ‖ signature ‖ "|" ‖ droit )`, en hexadécimal.

**Empreinte chaînée** de la ligne de rang `seq` (à partir de 1) :

```
SHA-256( précédente ‖ "|" ‖ empreinte_bulletin ‖ "|" ‖ seq ‖ "|" ‖ recu_le )
```

où `précédente` est l'empreinte chaînée de la ligne précédente, ou le texte `GENESIS` pour la première, `seq` est écrit en décimal et `recu_le` est l'horodatage ISO 8601 inscrit par l'urne (texte conservé tel quel). Supprimer, modifier ou réordonner une ligne casse toutes les empreintes suivantes.

**Colonnes publiques et contenu signé (révision 2).** L'empreinte d'un bulletin couvre `contenu`, `signature` et `droit`, mais **pas** les colonnes `cle_votant` et `revision` du tableau. **Ces colonnes ne font pas foi** : un vérificateur **DOIT** les croiser avec le contenu signé (`cle_votant` égale `contenu.cle`, `revision` égale `contenu.revision`) et refuser la ligne qui diffère. La déduplication du cumul se fait **sur la clé et la révision du contenu signé**. Sans ce croisement, une urne malhonnête pouvait, après dépôt et sans casser la chaîne, réécrire la clé d'un bulletin remplacé, le faire compter deux fois et signer elle-même le cumul falsifié (le contrôle `N ≤ droits émis` bornait l'attaque sans l'empêcher). Alternative non retenue : inclure ces colonnes dans l'empreinte du bulletin (elle casserait les reçus des électeurs). **Cohérence avec le reçu :** le reçu remis à l'électeur est l'empreinte `SHA-256(contenu ‖ "|" ‖ signature ‖ "|" ‖ droit)` ; la déduplication se fait sur le contenu signé, donc sur les mêmes octets : un bulletin dont le contenu serait modifié change d'empreinte, ne correspond plus au reçu et casse la chaîne ; un bulletin dont seules les colonnes seraient réécrites reste retrouvable par son reçu mais est refusé par le croisement (gardes `bulletins` et `revisions` en **échec**, jamais en avertissement).

**Cumul.** Pour chaque compteur `j`, `Cⱼ = Σ` des chiffrés du compteur `j` du **dernier bulletin de chaque clé** (le bulletin remplacé est retiré, par soustraction, quand un revote arrive). Le cumul est un cache : la vérité est le tableau public.

**Empreinte du cumul** : `SHA-256( a₀ ‖ b₀ ‖ a₁ ‖ b₁ ‖ … )` où les `aⱼ`, `bⱼ` sont écrits en hexadécimal, concaténés dans l'ordre des compteurs.

**Point de contrôle.** Tous les `N` bulletins (10 dans le démonstrateur, 10 000 en exploitation) et à la clôture (`final`), l'urne signe avec sa clé Ed25519 le **texte** :

```
point|{scrutin}|{seq}|{empreinte_chainee}|{empreinte_du_cumul}|final      (ou |intermediaire)
```

Le point de contrôle publie aussi le cumul (liste de couples hexadécimaux) à cet instant. Le point **final** est établi à l'heure de clôture ; les bulletins en transit sont départagés par l'horodatage inscrit.

### 7.9 bis Vote indivisible : droits, dépôt et reçu en lot (version 36)

Un vote n'est pris en compte que pour **l'ensemble des questions de la session** (7.17) : chaque question est un scrutin avec son propre tableau, et l'électeur dépose ses réponses **en un seul lot**, accepté en entier ou refusé en entier. Cette section décrit le rôle de chacun. **Le format du bulletin (7.8) ne change pas** : chaque bulletin reste complet et indépendant (son scrutin, son droit, sa signature, ses preuves) ; le lot n'est qu'une enveloppe de transport et de transaction. Il n'est **pas** lié dans le contenu signé du bulletin : le recollage de bulletins de lots différents se détecte par le contrôle de cohérence ci-dessous.

**1. Droits : au début du parcours, en une seule demande.** Pour éviter qu'un parcours complet ne soit refusé à la fin, la prise des droits reste la première étape. L'application génère sa paire de clés comme avant ; elle envoie au registre, **en une seule requête**, une demande de signature aveugle **par scrutin de la session** (le message de chaque scrutin est lié à son identifiant et à la même clé publique, 7.7). Le registre contrôle l'éligibilité de l'électeur, signe les n demandes ensemble, et n'inscrit **qu'un seul émargement** (un par électeur et par session). Le compteur public des droits émis compte une fois par session : c'est celui du scrutin principal, et il **vaut pour chacun des tableaux** (un droit est délivré par scrutin à chaque vote, avec un seul émargement), ce qui laisse le contrôle des compteurs (clés distinctes ≤ droits émis ≤ authentifiés) inchangé pour chaque tableau. La cérémonie des clés est unique pour la session : les preuves de cérémonie portent l'identifiant de la cérémonie, que chaque tableau publie avec ses paramètres (`ceremonie`) pour que chacun se vérifie seul. Les règles du droit (7.7) sont inchangées : chaque droit n'est valable que pour son scrutin. Un électeur qui a reçu ses droits sans déposer de lot est invité à reprendre son vote (7.6, « Vous n'avez pas terminé votre vote »).

**2. Dépôt : à la fin, en un seul lot.** L'application construit un bulletin par scrutin, **avec la même clé de votant et la même révision**, et les envoie ensemble. Le lot : `{ "session": <id>, "bulletins": [ {contenu, signature, droit}, … ] }`. L'urne l'accepte si et seulement si :

- (a) il contient **exactement un bulletin par scrutin de la session**, ni plus, ni moins ;
- (b) tous les bulletins portent la **même `cle`** et la **même `revision`** ;
- (c) chaque bulletin satisfait les règles 1 à 6 et 8 de 7.8 pour son scrutin ;
- (d) la `revision` est **strictement supérieure** à celle du dernier lot de cette clé (règle 7 de 7.8, appliquée à chaque tableau ; elle est la même dans tous les tableaux par construction).

Si l'une de ces conditions échoue, **rien n'est écrit** : le refus nomme la question ou la règle en cause, et l'application peut corriger et renvoyer. Sinon, l'urne écrit **toutes les lignes en une seule transaction** : une ligne par tableau, chaînée dans son propre tableau (7.9), avec le **même horodatage** `recu_le`. Le cumul chiffré de chaque tableau est mis à jour dans la même transaction ; pour une révision, l'ancien bulletin est retiré du cumul de chacun des tableaux. Les tableaux d'une session sont **stockés dans la même base** de l'urne (ils ne sont publiés séparément qu'à la clôture), ce qui donne l'atomicité sans protocole de validation en deux temps entre bases. La séparation des pouvoirs est inchangée : le registre ne voit aucun bulletin, l'urne aucune identité.

**3. Reçu.** L'électeur reçoit **un seul reçu** : l'empreinte SHA-256 de la concaténation, dans l'ordre croissant des identifiants de scrutin, des empreintes des n bulletins (7.9). L'écran rappelle l'empreinte de chaque bulletin, que l'électeur retrouve dans chaque tableau.

**4. Contrôle public de cohérence des tableaux.** Le vérificateur public ajoute un contrôle propre aux sessions à plusieurs tableaux : pour chaque tableau, l'ensemble des couples `(cle, revision)` de ses lignes doit être **identique** dans tous les tableaux de la session. Un vote partiel (un tableau sans les autres), un bulletin retiré d'un seul tableau ou un lot recollé de révisions différentes y apparaît comme un écart, avec les clés concernées. Le programme de dépouillement des tutelles contrôle un tableau à la fois et ne change pas ; le second vérificateur reçoit le même contrôle croisé.

**5. Charge.** Le dépôt d'un lot coûte la vérification de n bulletins : le coût proportionnel au nombre de réponses est le même que pour un bulletin unique portant toutes les questions, auquel s'ajoute le coût fixe d'environ 1,05 ms par tableau (7.17). Le cumul de chaque question est mis à jour dans la même transaction, avec un verrou par tableau : l'étude des totaux par tranche (8.8) reste le levier si ces verrous limitent le débit.

### 7.10 Tableau public

Le tableau public est tout ce que n'importe qui peut télécharger, **sans donnée personnelle** :

- les paramètres du scrutin (questions, options, `H_E`, les trois parties de tutelle, clé publique RSA du registre, clé publique Ed25519 de l'urne) ;
- les bulletins, dans l'ordre : `seq`, `cle_votant`, `revision`, `droit`, `contenu`, `signature`, `empreinte_bulletin`, `recu_le`, `empreinte_chainee` ;
- les points de contrôle (rang, empreinte chaînée, empreinte du cumul, signature, drapeau `final`, cumul) ;
- le cumul final, les contributions des tutelles, le résultat ;
- les deux compteurs publics du registre (droits de vote émis, authentifications).

**Format de transport (cible).** Un manifeste et des **tranches** : chaque tranche est un fichier de lignes JSON (une ligne par bulletin), et le manifeste liste, pour chaque tranche, son intervalle de `seq` et l'empreinte SHA-256 de ses octets. **Le manifeste DOIT lister tous les fichiers que le chargeur lit** (`parametres.json`, `points-controle.json`, `cumul-final.json`, `contributions.json`, `resultats.json`, `compteurs-registre.json`, et les tranches) : un chargeur **refuse** tout tableau dont un de ces fichiers n'est pas listé, faute de quoi il échapperait au contrôle d'empreinte (révision 2). Le cumul final publié a **exactement une ligne par compteur**. Les tranches permettent de vérifier au fil de l'eau et de répartir la vérification sur plusieurs cœurs.

#### Taille et circulation du tableau public (précisions v25)

**Ce que c'est.** Le tableau public est la liste de tous les bulletins fermés d'une session, sans aucun nom d'électeur, avec la chaîne d'empreintes, les points de contrôle signés et le total chiffré. Il est **en ajout seul** et **public**.

**Taille.** Un bulletin pèse environ 0,78 Ko plus 0,192 Ko par réponse possible (section 7.17). Pour 36 millions de bulletins et 6 compteurs, **environ 70 Go** ; l'enveloppe retenue est de **400 Go** au plus par tableau, un tableau par question (section 7.17) ; les tailles s'entendent pour un tableau publié en binaire. Dans le démonstrateur : 90 bulletins, quelques centaines de Ko.

**Circulation.**
1. **Pendant la semaine du vote**, le tableau est publié par **tranches** (une tranche entre deux points de contrôle, soit 10 000 bulletins et de l'ordre de 18 Mo en exploitation). Les **collecteurs** des tutelles et les vérificateurs les copient au fil de l'eau et contrôlent la chaîne tranche par tranche.
2. **À la clôture**, le serveur publie automatiquement le dernier point de contrôle, le manifeste et la dernière tranche, avec l'**empreinte du manifeste** (64 caractères, lisible à voix haute). Il ne manque aux collecteurs que la dernière tranche.
3. **Pour le boîtier hors réseau**, chaque institution copie le tableau de son collecteur sur un **disque amovible rapide** (SSD), qu'elle apporte à son boîtier. Ordre de grandeur pour 70 Go : de l'ordre de 2 minutes de copie à 500 Mo/s, 12 minutes à 100 Mo/s ; le recalcul des empreintes par le boîtier prend de quelques minutes à un quart d'heure (section 8.8). Le boîtier compare l'empreinte du manifeste à celle qui a été lue à voix haute et refuse de continuer si elles diffèrent.
4. **Les clés USB** ne conviennent qu'aux petits volumes : fichiers de la cérémonie (parties publiques, clé de l'élection), contributions de dépouillement, tableau du démonstrateur ou d'un pilote.

**Ce qu'il devient.** Après la certification, le tableau reste **public et conservé** : c'est lui qui permet à chacun de refaire les vérifications (niveaux 2 et 3 de la section « Vérification publique »). La **durée de conservation** et le lieu d'archivage sont à fixer.
### 7.11 Dépouillement : contribution et combinaison

Le **total fermé** du compteur `j` est `Cⱼ = (Aⱼ, Bⱼ)`. À la clôture :

- **Contribution** de la tutelle `i` au compteur `j` : `dᵢ,ⱼ = xᵢ·Aⱼ`, avec une preuve (5.b) de `xᵢ` tel que `hᵢ = xᵢ·G` et `dᵢ,ⱼ = xᵢ·Aⱼ` (donc `g₁ = G`, `y₁ = hᵢ`, `g₂ = Aⱼ`, `y₂ = dᵢ,ⱼ`), contexte `contribution|{scrutin}|{i}|{j}|{E}`, où `E` est l'**empreinte du total fermé recalculé** (empreinte du cumul, 7.9, sur tous les compteurs) : la contribution est ainsi liée à ce total précis (révision 2). Dans un essai de cérémonie, `E` est l'empreinte du fichier de bulletins de test.
- **Combinaison** : `Mⱼ = Bⱼ − d₁,ⱼ − d₂,ⱼ − d₃,ⱼ`. Puis le **résultat** `tⱼ` est l'entier tel que `Mⱼ = tⱼ·G`, avec `0 ≤ tⱼ ≤ N`, où `N` est le nombre de clés distinctes du tableau. On le trouve par la méthode « pas de bébé, pas de géant » (`√N` pas, quelques milliers pour 30 millions).
- **Contrôle de cohérence (DOIT)** : pour chaque question, la somme des `tⱼ` de ses options égale `N`, puisque chaque bulletin valide porte exactement un choix par question. Un écart prouve un défaut en amont (bulletin non conforme, total altéré) et **interdit la publication**.

Une contribution seule ne permet de déchiffrer aucun bulletin individuel : elle porte sur `Aⱼ` du total, pas sur le `a` d'un bulletin.

### 7.12 Le programme des tutelles : entrées, gardes, sorties

C'est la procédure que le programme de chaque tutelle **DOIT** suivre sur sa machine coupée du réseau. **Décision : le programme part du tableau public et ne se fie pas au serveur.**

**Entrées.**

1. Le **tableau public**, apporté sur support amovible (tranches et manifeste).
2. Les **empreintes de référence** lues à voix haute devant les témoins : empreinte du manifeste, clé publique Ed25519 de l'urne, `H_E`.
3. Le **support de la part secrète** de la tutelle, ouvert par son code.

**Gardes** (tous DOIVENT passer, dans cet ordre ; un seul échec arrête tout, sans jamais toucher à la part secrète) :

| # | Garde | Pourquoi |
|---|---|---|
| G1 | Les empreintes des tranches égalent celles du manifeste, et l'empreinte du manifeste égale la référence lue devant les témoins | Le tableau est bien celui qui a été publié |
| G2 | Cérémonie : engagements, preuves de connaissance, `H_E = Σ hᵢ`, trois tutelles ; et la partie publique du support de la tutelle égale son `hᵢ` publié | La clé en main est la bonne |
| G3 | **Chaîne d'empreintes** recalculée depuis `GENESIS` sur tout le tableau | Aucune suppression, modification ni réordonnancement |
| G4 | **Chaque bulletin** satisfait les règles 1 à 7 de la section 7.8 | Aucun bulletin non conforme dans le total |
| G5 | **Cumul recalculé** depuis les derniers bulletins par clé, égal au cumul du point de contrôle final | Le total à déchiffrer est bien la somme du tableau, et non un bulletin isolé |
| G6 | Le **point de contrôle final** a une signature Ed25519 valide (clé publique de référence), son `seq` est le dernier rang, son empreinte chaînée égale celle de la dernière ligne, et son empreinte de cumul égale celle de G5 | Le tableau est clos et complet |
| G7 | **Seuil** : le nombre de clés distinctes `N` est au moins égal au seuil du scrutin ; il est cohérent avec les compteurs publics (`N` ≤ droits émis ≤ authentifications) | Jamais déchiffrer un total qui pourrait n'être qu'un bulletin isolé |
| G8 | **Un seul usage** : le support n'a pas déjà servi pour ce scrutin, et ce service est inscrit **avant** de produire la contribution | Une part de clé ne sert qu'une fois |

G5 est ce qui supprime la confiance dans le serveur : le total n'est jamais « reçu », il est **recalculé**. Si le tableau public lui-même était truqué, G1 et le contrôle par les vérificateurs indépendants (partie 5) le rattrapent.

**Sorties.** Le fichier de contribution (7.13) : pour chaque compteur `j`, `dᵢ,ⱼ` et sa preuve, plus le rappel de `seq`, de l'empreinte du cumul final et de l'identité de la tutelle. Rien d'autre n'est écrit sur le support de sortie. **La part secrète ne quitte jamais la machine.**

**Après combinaison** (par n'importe qui, publiquement) : le contrôle de cohérence de 7.11, puis la publication du résultat avec les trois fichiers de contribution.

### 7.13 Fichiers d'échange (cible)

| Fichier | Sens | Contenu | Intégrité |
|---|---|---|---|
| `manifeste.json` + tranches `tableau-NNNN.jsonl` | urne → machines | paramètres et bulletins (7.10) | SHA-256 de chaque tranche dans le manifeste ; empreinte du manifeste lue à voix haute |
| `contribution-tutelle-{i}.json` | machine → public | `{"v":1,"scrutin":…,"tutelle":i,"seq_final":…,"empreinte_cumul":hexa,"contributions":[{"compteur":j,"d":hexa,"preuve":[c,s]}…]}` | SHA-256 du fichier, affichée à l'écran pour comparaison à voix haute |
| `resultat.json` | public | les `tⱼ`, les trois fichiers de contribution (par leur empreinte) | rédigé et signé par le procès-verbal |

Les empreintes affichées pour lecture à voix haute sont écrites en groupes de quatre caractères hexadécimaux (`e1a3 a9c4 …`) et, en complément, en une suite de mots d'une liste fixe (plus facile à lire et à retenir).

### 7.14 Vecteurs de test et conformité

Un programme est **conforme** s'il passe une suite de vecteurs de test publics, produite par l'implémentation de référence. Catégories :

1. **Primitives** : `G`, multiplications, addition, la fonction `H` (par exemple `H("a","b")` = `e790dc86fb6b39a72619fa159baf27a4e7f1d3e32f4d43609984cc7f256e8608`), réduction modulo `ℓ`, encodages invalides à refuser. Les seize premiers multiples de `G` sont identiques à ceux du RFC 9496, ce qui contrôle le démonstrateur par une source extérieure.
2. **Preuves** : pour chaque type (5.a à 5.d), des preuves justes et des preuves fausses à refuser, dont des scalaires non canoniques.
3. **Cérémonie** : trois parties de tutelle et la clé de l'élection ; un cas d'engagement qui ne correspond pas.
4. **Bulletin** : des bulletins valides et un bulletin par règle violée (1 à 7).
5. **Chaîne et points de contrôle** : un petit scrutin complet (quelques électeurs, un revote) avec ses empreintes chaînées, ses cumuls, ses points de contrôle signés.
6. **Dépouillement** : les contributions des trois tutelles sur ce petit scrutin et son résultat ; un cas à refuser pour chaque garde G1 à G8.

**Scrutin témoin.** Le démonstrateur exporte un scrutin témoin (tableau public au format de transport de la section 7.10, paramètres, parts secrètes de démonstration, contributions attendues). Le programme des tutelles **DOIT** produire des contributions **vérifiées justes** (les octets des preuves diffèrent puisqu'elles sont aléatoires) et **refuser** chaque variante altérée.

**Jeu `vecteurs-vote-v1`, révision 3.** 224 vérifications côté Rust et 207 côté PHP, dont : parties de cérémonie neutre et dupliquée refusées, droit de vote lié au scrutin (fichier `07-droit-de-vote.json`), **vecteur de test A.3 du RFC 9474 recopié sans changement (fichier `08-rfc9474-a3.json`)**, colonnes du tableau réécrites, cumul tronqué. *Le détail ci-dessous est celui de la révision 1 (188 vérifications) :*

**Jeu publié en révision 1 : `vecteurs-vote-v1` (étape 1 faite).** 188 vérifications : 72 sur les primitives, 26 sur les preuves, 7 sur la cérémonie, 16 sur les bulletins (une violation pour chacune des règles 1 à 6 de 7.8), 30 sur le tableau public (dont 18 altérations qui doivent chacune faire échouer un contrôle précis) et 37 sur le dépouillement. Le scrutin témoin compte 10 bulletins (8 électeurs distincts, 2 revotes, 1 vote en poste partagé), 2 questions de 3 options, un point de contrôle tous les 4 bulletins. Le démonstrateur a rejoué toute la suite avant l'export, sans écart. Il se régénère et se rejoue avec `php artisan vote:vecteurs` et `php artisan vote:conformite` (dev uniquement). Le mode d'emploi des fichiers est dans `LISEZ-MOI.md`, à côté des vecteurs. **Ce jeu est le premier test d'acceptation du programme en Rust.**

### 7.16 Formats de réponse : une réponse possible = un numéro

**Principe.** Le système ne sait compter que des choix uniques : « parmi M réponses possibles, l'électeur en choisit exactement une ». Toute question dont l'ensemble des réponses est fini et assez petit se ramène à ce cas : on **énumère toutes les réponses possibles**, on leur donne un numéro de 0 à M-1 dans un ordre fixé par la question, et c'est l'**interface de l'électeur** qui traduit sa réponse en numéro avant de chiffrer. Le serveur, l'urne, la preuve de validité (« un seul numéro valide parmi M ») et le programme des tutelles ne voient qu'un choix unique parmi M options. Le total déchiffré donne, pour chaque réponse possible, le nombre d'électeurs qui l'ont choisie.

**Ce que cela couvre.**

| Type de question | Réponses possibles | M |
|---|---|---|
| Choix unique, pour/contre/blanc | Chaque option | n |
| Classement complet de k éléments | Les k! classements | k! (3 → 6, 4 → 24, 5 → 120, 6 → 720) |
| Au plus 3 éléments choisis et ordonnés parmi 8 | 1 (aucun) + 8 + 8×7 + 8×7×6 = 1 + 8 + 56 + 336 | 401 (400 sans la réponse vide) |
| Notation de n options sur g notes | Une note par option : g^n combinaisons (ou, plus léger, un compteur par option et par note, voir plus bas) | g^n |

**Conséquences favorables.**
- **La validité est garantie par construction** : un classement incohérent (un cycle, un doublon) n''a pas de numéro, il ne peut pas être envoyé. Aucune preuve de cohérence supplémentaire n''est nécessaire.
- **Le mix-net devient inutile pour les classements de petite taille**, y compris le vote alternatif (STV) : l''ensemble des totaux par classement contient toute l''information dont STV, Condorcet, Schulze ou Borda ont besoin. Le dépouillement donne les totaux, puis la méthode de décompte s''applique en clair et publiquement.

**Limites.**
1. **La taille.** Chaque bulletin porte un chiffré et une preuve par réponse possible : de l''ordre de 190 octets par réponse, soit environ 23 Ko pour 120 réponses, ou plusieurs centaines de gigaoctets pour un scrutin national (ordre de grandeur, à mesurer). Raisonnable jusqu''à quelques centaines de réponses ; au-delà, il faut une autre représentation.
2. **Autre représentation pour les grands ensembles** : un compteur par paire d''options (matrice de préférences, Condorcet/Schulze) ou par couple (option, note) (jugement majoritaire). Elle est plus compacte mais demande de prouver la cohérence du bulletin (par exemple l''absence de cycle) : c''est ce qui a motivé le choix du mix-net dans Belenios.
3. **La fuite des réponses rares.** Si le résultat publie le total pour chaque réponse possible, on peut demander à un électeur de voter une réponse très rare et vérifier qu''elle apparaît (attaque « par signature »). Le risque croît avec M. Il n''est pas propre à cette méthode : un mix-net, qui publie chaque bulletin déchiffré, y est plus exposé. À M modéré et corps électoral large, il reste faible ; il ne disparaît pas.

   **Règle numérique (proposition, à valider par le relecteur et par l'auteur ; révision 2).** Avant l'ouverture d'une question, le nombre attendu d'électeurs `Nₐ` (borne basse, fixée par le cadrage de la question) et le nombre de réponses possibles `M` doivent satisfaire **`Nₐ ≥ 100 × M`**, soit en moyenne au moins 100 électeurs par réponse possible, et **`M ≤ 500`** (limite du catalogue 7.17). Une question qui ne respecte pas la règle est refusée à l'ouverture, ou remplacée par un format moins fin. Les valeurs 100 et 500 sont des paramètres à confirmer, non des résultats établis. Après la clôture, le résultat d'une question **n'est publié par réponse que si le plus petit total non nul atteint au moins 5** ; sinon les réponses concernées sont regroupées (« autres »).
4. **L''interface.** La fiabilité de l''application (elle doit chiffrer le numéro correspondant à ce que l''électeur a choisi) est un sujet distinct, commun à tous les formats : le récapitulatif affiché avant validation (« Votre classement : Santé › Transports › École ») et l''audit de l''application en sont les garde-fous.

**Convention du démonstrateur.** Une question de classement est déclarée avec le type `classement`, la liste de ses éléments et la liste de toutes les réponses possibles dans l''ordre du dictionnaire des numéros d''éléments (pour trois éléments A, B, C : ABC, ACB, BAC, BCA, CAB, CBA). L''application calcule le rang du classement choisi dans cet ordre.
### 7.18 Modèle de menaces et garanties non données (révision 2)

Cette section répond à la demande de la relecture externe d'un modèle de menaces écrit. Elle dit **ce qui est protégé, contre qui, et ce qui ne l'est pas**.

**Ce qui est protégé.** (1) L'**exactitude du résultat** : n'importe qui peut recalculer le total à partir du tableau public et vérifier les preuves. (2) Le **secret du vote** face à un serveur honnête mais curieux, au registre seul, à l'urne seule, et à une ou deux tutelles. (3) L'**absence de bourrage** par quiconque n'a pas la clé du registre.

**Acteurs et pouvoirs supposés.**

| Acteur | Peut | Ne peut pas |
|---|---|---|
| Une tutelle (ou deux) | refuser de contribuer (le scrutin est alors perdu : le seuil est de 3 sur 3) ; fuiter sa part | déchiffrer seule ou à deux ; choisir sa partie publique après avoir vu les autres ; publier une part nulle |
| L'urne malhonnête | **omettre d'inscrire** un bulletin ; retarder ; refuser le service | modifier, supprimer ou réordonner un bulletin inscrit sans casser la chaîne ; réécrire les colonnes sans être vue (7.9) ; fabriquer un résultat |
| Le registre malhonnête | refuser un électeur ; **émettre des droits en trop et incrémenter son propre compteur** | lier un droit à un électeur (aveugle) |
| Un électeur | voter une fois (revoter remplace) | voter deux fois, voter avec la clé d'un autre, prouver à un tiers pour qui il a voté (voir limites) |
| Un observateur | recalculer, vérifier, auditer | rattacher un bulletin à une personne |

**Limites reconnues, à ne pas masquer.**

1. **Omission de bulletin par l'urne.** La chaîne protège contre la modification a posteriori, pas contre un bulletin jamais inscrit. Le **reçu d'inclusion** permet à chaque électeur de le vérifier, mais son efficacité dépend du **taux de vérification réel, invérifiable**. C'est la conséquence assumée de l'abandon de la vérification individuelle exigée de tous (argumentée en partie 5). À garder dans toute communication sur les garanties : *le système rend la fraude à grande échelle détectable si une part suffisante d'électeurs vérifie son reçu ; il ne la rend pas impossible.*
2. **Registre compromis : bourrage par émission de droits en trop.** Le compteur public des droits est tenu **par le registre lui-même** : un registre malveillant peut émettre des droits en trop et incrémenter son compteur en conséquence. Reste le recoupement avec les listes d'émargement et le contrôle `N ≤ droits émis ≤ authentifiés`, qui ne détectent que l'incohérence interne. **C'est le seul vecteur de fraude massive dont la parade repose sur la confiance dans l'acteur compromis.** Parades à chiffrer avant tout usage réel : clé du registre en HSM avec journal infalsifiable (7.7) ; **un second compteur tenu par FranceConnect+** (nombre d'authentifications), publié indépendamment ; **recoupement après clôture** entre le nombre de clés distinctes de l'urne, le compteur du registre et le compteur de l'authentifieur. **Tolérance proposée : zéro** sur les deux inégalités `clés distinctes ≤ droits émis ≤ authentifications` (aucun dépassement n'est expliqué par un fonctionnement normal) ; en revanche l'écart `droits émis − clés distinctes` (électeurs qui ont obtenu un droit sans déposer de bulletin) est normal et n'est pas une anomalie. Tout dépassement déclenche une enquête **avant** la certification. Cette tolérance est une proposition de l'équipe technique : elle est à fixer par l'autorité de certification.
3. **Contrainte et achat de vote.** Le revote (le dernier bulletin remplace les autres) atténue la contrainte à distance ; il ne l'élimine pas : un électeur contraint sous surveillance continue ne peut pas revoter. Aucune garantie de **résistance à la coercition** n'est donnée. À examiner par le relecteur.
4. **Métadonnées.** L'horodatage `recu_le`, l'ordre d'arrivée et les adresses réseau peuvent rapprocher un dépôt d'une authentification si l'urne et le registre collaborent ou sont corrélés par un observateur du réseau. Les parades (heures arrondies, lots, réseau anonymisant) sont à étudier. Depuis la révision 2, `cle_votant` et `revision` n'ont de valeur que **dans le contenu signé** (les colonnes du tableau sont croisées avec lui) : la réécriture après coup de ces colonnes n'est plus un vecteur d'attaque ; l'analyse de corrélation entre horodatage et authentification reste, elle, pertinente.
5. **Disponibilité.** Le seuil de 3 sur 3 est un point de défaillance : si une tutelle perd sa part, le dépouillement est impossible. Les deux copies chiffrées indépendantes par tutelle (option A) réduisent le risque pour la perte d'un support, pas pour la perte de la tutelle entière.
6. **Plateforme et poste de l'électeur.** Un téléphone compromis peut voter à la place de son propriétaire ; ce modèle ne le protège pas.

**Garanties à ne pas annoncer publiquement** : « vote infalsifiable », « secret garanti » sans condition, « audité », « certifié ». Le projet n'a fait l'objet d'aucun audit externe à ce jour (une relecture indépendante de la spécification et d'une partie du code est en cours).

### 7.19 Journal des révisions du protocole

**Révision 2 (octobre 2026), première relecture externe** (spécification et sources de `rdv-vote-core`). Constats **corrigés** : refus du point neutre dans la cérémonie ; tutelles 1, 2 et 3 distinctes ; droit de vote lié au scrutin ; colonnes `cle_votant` et `revision` croisées avec le contenu signé ; manifeste exhaustif ; cumul publié exact ; contribution liée à l'empreinte du total ; hexadécimal en minuscules imposé ; taille d'un bulletin bornée ; recherche des points de contrôle en une seule passe (le contrôle de G6 était en `points × bulletins`) ; zéroïsation des nonces et du coefficient de partage dans la bibliothèque ; plancher Argon2id ; commande `essai` retirée du programme livré ; rejet à la source d'une part nulle. Constats **documentés sans changement de code** : modèle de menaces (7.18), garde de la clé du registre (7.7), règle numérique des réponses rares (7.16, proposition). Constats **reportés** : passage à RSA-3072 (7.7, 7.15). Le détail et la preuve de chaque correction sont dans les tests `revue1` (Rust, PHP) et dans les vecteurs `v1`, révisés.

**Second tour de relecture (15 octobre 2026) : correctifs, sans changement du protocole ni des vecteurs.** (1) **Plancher Argon2id le jour J** : le profil « essai » n'est accepté, à la génération comme à l'ouverture d'une part, que si l'environnement déclare une démonstration (variable `RDV_DEMONSTRATION`, posée par le démonstrateur et par les images d'ESSAI du boîtier, reconnues à leur console série que la construction de production refuse) ; un opérateur ne peut pas abaisser le plancher d'une machine de cérémonie avec `--profil essai`. (2) **Effacement de la part sur toutes les sorties de `contribuer`** (retour précoce, erreur, panique) par un type qui efface à la fermeture. (3) `rdv-init` : les supports montés sont **démontés avant l'extinction** ; la ligne de commande est **bornée à 64 Kio** ; la prise de la console est **vérifiée** (arrêt clair si elle échoue) ; un **test de fréquence grossier** sur les dés (aucune face absente, khi-deux sous 20,5 : ce n'est pas un test d'aléa, les dés s'ajoutent à l'aléa du noyau) ; un argument vide est refusé à la découpe. (4) Vérificateur public : une **contribution en double** n'écrase plus la première en silence ; un seul parcours de moins du JSON par bulletin ; la tolérance des majuscules sur la référence tapée par l'opérateur est **explicitée** dans le code. (5) Harnais de conformité : une mutation inapplicable est une **erreur du vecteur**, jamais un succès ; un vecteur mal formé donne un message clair ; le refus d'un fichier non listé au manifeste est testé dans les deux implémentations. (6) Toutes les dépendances directes sont **épinglées** (`=version`). **Non traité, dit comme tel :** RSA-3072 (critère : avant tout scrutin réel) ; fuzzing continu ; effacement mémoire garanti de la machine cible ; effacement par type garanti seulement dans `contribuer` (les autres commandes qui ouvrent une part l'effacent explicitement mais pas sur tous leurs retours d'erreur).

**Révision 3 (octobre 2026) : taille de la clé RSA du registre.** Le constat reporté de la première relecture (taille de la clé RSA du registre) est traité : la clé fait **3072 bits** (7.7). Le protocole change à un seul endroit : la signature en aveugle du droit suit le RFC 9474 (RSABSSA-SHA384-PSS-Deterministic), avec un module de 3072 bits et des signatures de 384 octets ; le format du bulletin, les preuves et le reste du protocole ne changent pas. Les vecteurs de test ( 4-bulletins,  7-droit-de-vote) et le scrutin témoin sont régénérés, les vecteurs officiels du RFC 9474 sont rejoués par les trois implémentations, les exécutables reconstruits. Reste reporté de la relecture : fuzzing continu.
