CLOISON manuel d'utilisation
Périmètre honnête — ne couvre que ce qui est prouvé

Manuel d'utilisation du proxy de confidentialité CLOISON

Installer et configurer le daemon local (N0) par script ou à la main, vérifier le masquage, rejouer les preuves de bout en bout, activer l'audit signé et reproduire le benchmark GO/NO-GO. Chaque bloc se copie d'un clic.

01 — Installation

Installation & configuration

A · Script (recommandé)

Le parcours script installe le binaire, génère la configuration locale (n0.env en 0600, ou n0.env.ps1 sous Windows), le script de démarrage start-n0, puis affiche la clé composite une seule fois. Trois étapes par OS.

Distribution par release GitHub : binaire par OS, NER léger embarqué (ONNX int8, 135 Mo), lib onnxruntime, checksums SHA-256 vérifiés. Aucune toolchain Rust, aucun torch.

Windows
1 · Installation
PowerShell — installation
powershell -ExecutionPolicy Bypass -File https://raw.githubusercontent.com/coucagog/cloison-proxy/main/install-n0.ps1
2 · Configuration
PowerShell — configuration
powershell -ExecutionPolicy Bypass -File .\deploy\configure-n0.ps1          # interactif
powershell -ExecutionPolicy Bypass -File .\deploy\configure-n0.ps1 -Start   # configure PUIS démarre
3 · Démarrage
PowerShell — démarrage
powershell -ExecutionPolicy Bypass -File $env:USERPROFILE\.cloison\start-n0.ps1
Linux
1 · Installation
bash — installation
bash <(curl -fsSL https://raw.githubusercontent.com/coucagog/cloison-proxy/main/install-n0.sh)
2 · Configuration
bash — configuration
bash deploy/configure-n0.sh          # interactif
bash deploy/configure-n0.sh --start  # configure PUIS démarre
3 · Démarrage
bash — démarrage
~/.cloison/start-n0.sh
macOS
1 · Installation
bash — installation
bash <(curl -fsSL https://raw.githubusercontent.com/coucagog/cloison-proxy/main/install-n0.sh)
2 · Configuration
bash — configuration
bash deploy/configure-n0.sh          # interactif
bash deploy/configure-n0.sh --start  # configure PUIS démarre
3 · Démarrage
bash — démarrage
~/.cloison/start-n0.sh

Ce que font les scripts configure-n0

Ils génèrent la configuration locale — ~/.cloison/n0.env (0600) sur Linux/macOS, %USERPROFILE%\.cloison\n0.env.ps1 sur Windows — le script start-n0, et affichent la clé composite une seule fois. Idempotents : rejouables, ils ne démarrent le daemon qu'avec --start / -Start.

Options communes (script d'installation)

OptionEffet
--version v0.3.1installe une version précise (défaut : latest)
--prefix DIRrépertoire d'installation (défaut ~/.cloison)
--skip-ner / -SkipNersans le NER léger (gazetteers + alias seuls — la limite « texte libre » de §07 reste alors assumée)

Composants installés : binaire cloison-proxy(.exe) · NER léger ner/model-int8.onnx + tokenizer.json + label_map.json · lib onnxruntime (chargée dynamiquement).

Mise à jour
Re-exécuter le script : il écrase le binaire mais conserve le coffre vault.redb et le sel .salt — vos conversations restent restaurables.
Périmètre prouvé
Les scripts configure-n0 sont nouveaux — à valider. L'installation (install-n0) et le daemon, eux, sont prouvés (journaux STACK-N0 → N0V13).
B · Manuel

Le mode N0 s'active en posant CLOISON_VAULT_PATH : coffre chiffré AES-256-GCM persistant, auth 100 % locale, fail-loud au boot. Le daemon expose un endpoint compatible OpenAI sur http://localhost:8787.

Linux / macOS

bash — config N0
export CLOISON_ROLE=edge
export CLOISON_LISTEN_ADDR=127.0.0.1:8787
export CLOISON_UPSTREAM_BASE_URL=https://openrouter.ai/api/v1
export CLOISON_VAULT_PATH=~/.cloison/vault.redb
export CLOISON_VAULT_PASSPHRASE='votre-passphrase'
export CLOISON_EXPECTED_ACCESS_TOKEN=mon_jeton
export CLOISON_TENANT_KEY_HEX=$(openssl rand -hex 32)
cloison-proxy

Windows (PowerShell)

PowerShell — config N0
$env:CLOISON_ROLE='edge'
$env:CLOISON_LISTEN_ADDR='127.0.0.1:8787'
$env:CLOISON_UPSTREAM_BASE_URL='https://openrouter.ai/api/v1'
$env:CLOISON_VAULT_PATH="$env:USERPROFILE\.cloison\vault.redb"
$env:CLOISON_VAULT_PASSPHRASE='votre-passphrase'
$env:CLOISON_EXPECTED_ACCESS_TOKEN='mon_jeton'
$env:CLOISON_TENANT_KEY_HEX=(-join (1..32 | ForEach-Object { '{0:x2}' -f (Get-Random -Max 256) }))
cloison-proxy.exe

NER léger embarqué (optionnel mais recommandé — prouvé)

Ajouter les chemins pour couvrir les noms/lieux en texte libre (distilbert ONNX int8, ~11 ms/doc) ; absent → dégradation gracieuse sur N0 v1 (gazetteers + alias), avec avertissement :

variables NER (à poser avant le lancement)
export CLOISON_NER_MODEL_ONNX=~/.cloison/ner/model-int8.onnx
export CLOISON_NER_TOKENIZER=~/.cloison/ner/tokenizer.json
export CLOISON_ONNX_LIB=libonnxruntime.so   # .dylib (macOS) / onnxruntime.dll (Windows)

Brancher votre interface IA : deux champs

configuration client
Base URL : http://localhost:8787/v1
Clé      : mn_mon_jeton.sk-or-v1-<votre-cle-fournisseur>
Clé composite
Le format est mn_<jeton>.<clé amont>, découpé sur le premier point. La partie gauche autorise localement ; la partie droite (votre clé fournisseur) est transmise à l'amont uniquement via l'en-tête — jamais en URL, jamais en log.

Comportements garantis (prouvés)

  • Fail-loud au boot : passphrase absente, mauvaise ou coffre corrompu → le daemon refuse de démarrer (jamais de recréation silencieuse).
  • Sel de session persistant (vault.redb.salt, 0600) : mêmes jetons à travers les redémarrages. Rotation : supprimer le fichier et redémarrer.
  • Généralisation des faibles cardinalités : date → YYYY-MM, IP → [IP], carte bancaire → masque, ville → [VILLE_SN] — jamais tokenisées.
  • Alias intra-session (v1.1) : « Mamadou » établi → « Momo » masqué aussi (jamais les pronoms).
  • /v1/embeddings : bloqué (404) par défaut.
02 — Périmètre

Ce qui est prouvé

Ce manuel ne documente que des comportements déjà prouvés, chacun avec sa trace dans les journaux du dépôt. Tout le reste (intégrations en cours) n'y figure pas.

Prouvé en local

Daemon N0 sur Windows

Smoke test réel : exit 0 (cœur) et exit 0 (NER embarqué). Masquage amont, restauration client, coffre sans clair, ville généralisée [VILLE_SN], embeddings bloqués (404).

journal/STACK-N0V13.md · NEXT-SESSION.md §8

Prouvé E2E

Passerelle OpenAI-compatible

Contre faux LLM : 12/12 (non-stream, stream, tool-calls, 401, jeton forgé…). Contre LLM réel (OpenRouter, gpt-4o-mini) : 8/8 — le fournisseur ne reçoit que des sentinelles.

journal/STACK-7.md

Prouvé en stack

Audit signé + journal de transparence

Reçus Ed25519 (compteurs, jamais de texte), rapports k-anonymes, journal append-only vérifiable, ingestion control → ledger testée de bout en bout.

journal/STACK-4.md · STACK-5.md

Prouvé par benchmark

Fossé ouest-africain (verdict GO)

Grille pré-enregistrée v1.1, modèles réels sur CPU : PERSON 0.937 · LOC 0.835 · CNI/MAIL/TEL 1.000 · macro 0.954 · spécificité 0.77.

journal/STACK-8.md · bench/cloison-bench/results/

Rappel
CLOISON pseudonymise (réversible au bord) plutôt que d'anonymiser : le fournisseur LLM ne reçoit que des sentinelles ⟦…⟧ et les vraies valeurs sont restaurées dans la réponse, uniquement si elles ont été émises pendant la requête.
03 — Vérification

Vérifier

Deux contrôles : le smoke test distribué (prouvé exit 0 sur Windows réel) et le roundtrip manuel qui reproduit la preuve e2e des journaux.

Smoke test (Windows)

PowerShell
powershell -ExecutionPolicy Bypass -File https://raw.githubusercontent.com/coucagog/cloison-proxy/main/smoke-n0.ps1

Ce que le smoke prouve : boot du daemon N0 (coffre persistant, fail-loud, sel 0600), NER embarqué chargé, masquage amont (sentinelles ⟦…⟧, aucune PII), restauration client complète, ville généralisée [VILLE_SN], coffre sans clair, embeddings → 404.

Roundtrip manuel (le scénario prouvé des journaux)

curl — chat completions via le daemon
curl http://127.0.0.1:8787/v1/chat/completions \
  -H "Authorization: Bearer mn_mon_jeton.sk-or-v1-XXXX" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"Appelez Xolani Ndlovu au 77 123 45 67, il habite a Ziguinchor."}]}'

Résultat prouvé : l'amont ne reçoit que Appelez ⟦…·PE⟧ ⟦…·PE⟧ au ⟦…·PH⟧, il habite à [VILLE_SN]. — le nom (hors gazetteer) est masqué par le NER embarqué, le téléphone +221 par les regex, la ville est généralisée ; la réponse du client contient les vraies valeurs restaurées, zéro jeton résiduel.

Attention
Un jeton non résoluble n'est jamais émis brut : il devient un marqueur neutre [REDACTED] + un compteur s'incrémente (fail-loud).
04 — Preuves de bout en bout

Preuves E2E de la passerelle

Le harnais deploy/e2e_reel.sh prouve le masquage anti-pass-through : il vérifie que le corps reçu par l'amont contient des sentinelles ⟦ et PAS la PII. Résultats historiques : mock 12/12, LLM réel 8/8.

Mode mock (sans clé, sans réseau externe)

bash — E2E faux LLM
cd cloison
sudo -E bash deploy/e2e_reel.sh

Mode réel (OpenRouter, gpt-4o-mini)

bash — E2E LLM réel
cd cloison
CLOISON_E2E_MODE=real OPENROUTER_API_KEY=<votre-cle> bash deploy/e2e_reel.sh

Scénarios couverts (prouvés) : chat non-stream, stream SSE (sentinelle découpée sur les chunks), tool-calls (arguments masqués/restaurés, stream compris), 401 sur clé invalide, jeton forgé → marqueur neutre, /v1/models, completions legacy.

05 — Conformité

Mode Audit & journal

Observe-only : le proxy détecte et compte sans rien masquer, émet des reçus signés Ed25519 (compteurs uniquement — jamais de texte) et sert un rapport de conformité k-anonyme (défaut k=5).

Activer le mode audit

variables — mode audit
export CLOISON_AUDIT_MODE=1
export CLOISON_AUDIT_KEYS=/data/audit_key        # clé Ed25519 de l'agent
export CLOISON_AUDIT_LEDGER_FILE=/data/audit_ledger.jsonl   # reçus persistés (0600)
export CLOISON_AUDIT_K=5                          # seuil k-anonymat

Lire le rapport de conformité

curl — rapport k-anonyme signé
curl "http://127.0.0.1:8787/v1/audit/report?period=daily" \
  -H "Authorization: Bearer mn_mon_jeton.sk-or-v1-XXXX"

Chaque réponse non-stream porte aussi l'en-tête X-Cloison-Audit-Receipt (reçu signé, base64url). Les périodes valides : hourly | daily | weekly | all. Les cellules sous le seuil k ne sont jamais publiées.

Chaîne de confiance
En stack serveur, cloison-control contresigne les reçus et les engage dans le journal de transparence append-only (chaîne de hachage, signatures Ed25519, checkpoint anti-troncature) — vérifiable publiquement via cloison-verify (WASM inclus). Prouvé par tests (STACK-4/5) et en production.
06 — Benchmark

Benchmark GO/NO-GO

Le fossé ouest-africain est mesuré sur un jeu 100 % synthétique sénégalais (seed 42, 500 docs, 0 PII réelle), contre une baseline Presidio forte, avec une grille de scoring pré-enregistrée (v1.1, non modifiable). Verdict : GO.

bash — harnais de benchmark
cd bench/cloison-bench
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python -m spacy download fr_core_news_md
pytest test_benchmark.py                      # 32 tests du harnais
CLOISON_OFFLINE=1 python3 run_detect_target.py --offline   # détecteur cible

Résultats mesurés (modèles réels sur CPU, reproductibles)

MétriqueBaseline Presidio forteCLOISON (afroxlmr + consensus)Grille v1.1
PERSON0.5180.937≥ 0.638 ✅
LOC0.5960.835≥ 0.746 ✅
CNI / MAIL / TEL1.000 / 0.985 / 0.6521.000 / 1.000 / 1.000non-régression ✅
Macro F10.7500.954≥ 0.850 ✅
Spécificité non-PII0.420.77≥ 0.60 ✅
Leçon du GO
Seul afroxlmr (MasakhaNER) + gazetteer ville_sn + fusion consensus remplissent les 5 conditions simultanées. La détection des noms sénégalais n'est pas couverte par les outils génériques du marché — c'est le fossé mesuré.
07 — Honnêteté

Limites & niveaux N0–N3

À lire avant d'acheter. Ce que le produit ne prétend pas résoudre est rendu visible, jamais dissimulé.

  • Quasi-identifiants : « le patient de 42 ans opéré le 3 mars à Ziguinchor » peut ré-identifier sans aucun nom. La jauge (opt-in) signale la densité ; elle ne résout rien.
  • PII hallucinée : le modèle peut inventer une donnée sans jeton (grounding) — hors de portée d'un proxy, item de recherche.
  • Poste compromis : N0 ne protège pas contre un malware ou le vol du poste (le coffre et sa clé y vivent).
  • Sans NER embarqué : un nom hors gazetteer jamais mentionné peut partir en clair (limite N0 v1, levée par le NER léger v1.2).
  • Embeddings : /v1/embeddings est bloqué par défaut (un embedding de PII reste dérivé de PII).

Les quatre niveaux (ce que l'opérateur peut lire)

NiveauOù tourne le moteurCe que l'opérateur lit
N0 · localposte de l'utilisateurrien — promesse absolue (hors poste compromis)
N1 · siteserveur du clientseul le client, chez lui
N2 · enclavematériel scellé attestépersonne, et c'est prouvé
N3 · hébergéchez l'éditeurl'éditeur lit le clair — entrée de gamme, jamais l'argument
Ne pas confondre
Pour le fournisseur LLM qui ne peut pas inverser les sentinelles, la donnée pseudonymisée est anonyme ; pour qui détient la table de correspondance, elle reste personnelle. L'endroit où vit le coffre décide de qui porte la responsabilité.