fhe-cli 1.3.1__py3-none-any.whl

fhe_cli-1.3.1.dist-info/METADATA

@@ -0,0 +1,280 @@
+Metadata-Version: 2.4
+Name: fhe-cli
+Version: 1.3.1
+Summary: Atelier d'exercices en ligne de commande, à la rustlings : chiffrement classique et chiffrement homomorphe (FHE)
+Author: Ravin THILAGARASA, Thomas GRUNDSZTEJN
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Defl3ct-941/Scoring_FHE
+Project-URL: Source, https://github.com/Defl3ct-941/Scoring_FHE/tree/main/03_cas_pratiques/fhe-exercices-cli
+Project-URL: Issues, https://github.com/Defl3ct-941/Scoring_FHE/issues
+Project-URL: GitLab, https://gitlab.securechat.fr/esgi/5a/Scoring_FHE
+Project-URL: Changelog, https://github.com/Defl3ct-941/Scoring_FHE/blob/main/CHANGELOG.md
+Keywords: fhe,chiffrement homomorphe,homomorphic encryption,cryptographie,cryptography,exercices,rustlings,enseignement,scoring
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Education
+Classifier: Natural Language :: French
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Education
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytest<10,>=9.2
+Requires-Dist: cryptography<51,>=50.0
+Provides-Extra: ckks
+Requires-Dist: tenseal<0.4,>=0.3.16; extra == "ckks"
+Dynamic: license-file
+
+# fhecli : atelier CLI de chiffrement classique et FHE
+
+Un atelier d'exercices en ligne de commande, inspiré de
+[rustlings](https://github.com/rust-lang/rustlings) : vous éditez les fichiers
+d'exercice dans votre propre éditeur, avec votre propre environnement Python,
+et un petit outil (`fhecli`) surveille vos fichiers et relance les tests à
+chaque sauvegarde.
+
+Il accompagne le cours « Scoring financier sur données chiffrées via FHE »
+(FYC, ESGI) : c'est la même progression pédagogique que l'atelier web du
+projet, adaptée pour tourner directement dans votre terminal.
+
+> **Version actuelle : 3 exercices.** Seul le module A (chiffrement
+> classique) est publié pour le moment. Les modules suivants (arithmétique
+> modulaire, Paillier from scratch, scoring chiffré, bonus CKKS) arriveront
+> dans une prochaine mise à jour.
+
+## Installation
+
+Python 3.11 ou plus récent est requis.
+
+```bash
+python -m venv .venv
+# Windows
+.venv\Scripts\activate
+# macOS / Linux
+source .venv/bin/activate
+
+pip install fhe-cli
+fhecli init            # crée le dossier ./fhe-exercices avec les exercices
+cd fhe-exercices
+fhecli watch
+```
+
+Le paquet s'installe sous le nom **`fhe-cli`** ; la commande et le module
+Python restent `fhecli`.
+
+`fhecli init [dossier]` crée un **espace de travail** : le dossier
+`exercises/` (vos fichiers), un `pytest.ini` et un fichier marqueur
+`fhecli.toml`. Les commandes de `fhecli` retrouvent cet espace depuis n'importe
+quel sous-dossier. `fhecli init` refuse d'écraser un espace existant.
+
+### Sans Python : exécutable autonome
+
+Pour chaque OS, un exécutable unique embarque tout (Python, `fhecli`,
+`pytest`, `cryptography` et les exercices) : **aucune installation de Python
+n'est nécessaire**. Téléchargez celui de votre système
+(`fhecli-<version>-windows-x86_64.exe`, `-linux-x86_64`, `-macos-arm64` ou
+`-macos-x86_64`), puis :
+
+```bash
+# Windows (PowerShell)
+.hecli-1.2.0-windows-x86_64.exe init
+# macOS / Linux
+chmod +x fhecli-1.2.0-linux-x86_64
+./fhecli-1.2.0-linux-x86_64 init
+```
+
+Renommez-le en `fhecli` (ou `fhecli.exe`) et placez-le dans un dossier du
+`PATH` pour l'utiliser comme dans les exemples ci-dessous. Le code et les
+solutions y sont embarqués compressés, jamais en clair. Sous macOS, au premier
+lancement, autorisez le binaire dans Réglages système > Confidentialité et
+sécurité (il n'est pas signé).
+
+## Utilisation
+
+### Mode guidé (recommandé pour commencer)
+
+```bash
+fhecli watch
+```
+
+Affiche l'exercice courant, relance ses tests à chaque fois que vous
+sauvegardez le fichier, et passe automatiquement au suivant une fois qu'il est
+résolu (en proposant alors d'afficher la solution de référence pour comparer).
+Ctrl+C pour quitter à tout moment : rien n'est perdu, vos fichiers restent sur
+le disque.
+
+### Autres commandes
+
+```bash
+fhecli list                  # vue d'ensemble des exercices et de leur statut
+fhecli run ex1_cesar         # lance les tests d'un seul exercice
+fhecli hint ex1_cesar        # affiche un indice ciblé
+fhecli solution ex1_cesar    # affiche la solution (une fois l'exercice résolu)
+fhecli reset ex1_cesar       # remet CET exercice à son énoncé de départ (avec confirmation)
+fhecli reset --all           # remet TOUS les exercices à leur énoncé de départ (avec confirmation)
+fhecli reset --all -y        # idem, sans confirmation
+fhecli --version
+```
+
+Codes de sortie de `fhecli run` : `0` exercice résolu, `1` tests en échec
+(ou erreur), `2` tests OK mais ligne `# I AM NOT DONE` encore présente.
+
+Vous pouvez aussi lancer les tests vous-même avec `python -m pytest` depuis
+l'espace de travail : le `pytest.ini` fourni collecte bien les exercices.
+
+## Comment marche un exercice
+
+Chaque exercice est un unique fichier `.py` dans `exercises/`, qui contient
+tout :
+
+1. Un docstring en haut du fichier avec l'énoncé complet (contexte,
+   formules, ce qu'il faut implémenter, indices).
+2. Une ligne `# I AM NOT DONE` juste après : tant qu'elle est présente,
+   l'exercice est considéré comme « pas terminé », même si les tests passent
+   déjà. **Retirez-la vous-même** une fois satisfait de votre solution :
+   c'est un geste délibérément manuel, pour vous forcer à vraiment valider
+   votre travail.
+3. La ou les fonctions à compléter (marquées `raise NotImplementedError`).
+4. Une section de tests en bas du fichier (à ne pas modifier), exécutée par
+   `pytest` à chaque `fhecli run` / `fhecli watch`.
+
+## Solutions
+
+La solution de référence d'un exercice est **verrouillée** tant que
+l'exercice n'est pas résolu : `fhecli solution` ne l'affiche qu'une fois que
+les tests passent **et** que la ligne `# I AM NOT DONE` a été retirée.
+
+Dans le paquet, les solutions ne sont pas stockées en clair : elles sont
+compressées et encodées (zlib + base64). C'est une **dissuasion**, pour
+éviter de tomber sur la correction par hasard en fouillant le dossier du
+paquet, **pas une protection** : rien n'empêche quelqu'un de déterminé de les
+décoder. Le vrai garde-fou reste pédagogique.
+
+## Progression (dans l'ordre suivi par `fhecli watch`)
+
+| # | Exercice | Catégorie |
+|---|----------|-----------|
+| 1 | ex1_cesar | A. Chiffrement classique |
+| 2 | ex2_xor_malleability | A. Chiffrement classique |
+| 3 | ex3_fernet_tamper | A. Chiffrement classique |
+| 4 | ex4_modpow | B. Briques mathématiques |
+| 5 | ex5_modinv | B. Briques mathématiques |
+| 6 | ex6_paillier_keygen | C. Paillier, pas à pas |
+| 7 | ex7_paillier_enc_dec | C. Paillier, pas à pas |
+| 8 | ex8_paillier_homomorphic | C. Paillier, pas à pas |
+| 9 | ex9_scoring_paillier | D. Scoring chiffré |
+| 10 | ex10_ckks_bonus | E. Bonus : FHE réel avec CKKS |
+
+Le parcours va du chiffrement classique (où tout calcul sur le chiffré est
+impossible) à Paillier reconstruit à la main, puis à un score bancaire chiffré
+de bout en bout, et enfin à un vrai calcul FHE avec CKKS.
+
+Le bonus **ex10 (CKKS)** s'appuie sur [TenSEAL](https://github.com/OpenMined/TenSEAL),
+une dépendance native qui n'est pas installée par défaut (et qui n'est pas
+embarquée dans les exécutables autonomes). Pour le faire :
+
+```bash
+pip install "fhe-cli[ckks]"
+```
+
+Sans TenSEAL, les tests de l'ex10 sont simplement ignorés (skipped).
+
+## Développement (depuis le dépôt Scoring FHE)
+
+Le dossier `03_cas_pratiques/fhe-exercices-cli` du dépôt est lui-même un
+espace de travail (il contient `fhecli.toml`, `pytest.ini` et `exercises/`) :
+
+```bash
+cd 03_cas_pratiques/fhe-exercices-cli
+python -m venv .venv
+.venv\Scripts\activate          # macOS / Linux : source .venv/bin/activate
+pip install -e .
+fhecli watch
+python -m pytest tests -q       # tests de l'outil lui-même
+```
+
+Avant de commiter : `fhecli reset --all -y`, pour ne jamais versionner de
+réponses dans `exercises/`.
+
+```
+fhe-exercices-cli/
+├── pyproject.toml             # empaquetage (PyPI), point d'entrée `fhecli`
+├── LICENSE, MANIFEST.in
+├── fhecli/                    # le paquet
+│   ├── cli.py                 # commandes : init, watch, list, run, hint, solution, reset
+│   ├── workspace.py           # création et recherche de l'espace de travail
+│   ├── watch.py               # boucle de surveillance des fichiers
+│   ├── runner.py              # exécution de pytest en sous-processus isolé
+│   ├── info.py, resources.py  # liste des exercices, accès aux données du paquet
+│   ├── solutions.py           # encodage / décodage des solutions
+│   ├── ui.py                  # couleurs, UTF-8, confirmations
+│   └── data/                  # embarqué dans le paquet (lecture seule)
+│       ├── info.toml          # métadonnées des exercices (titre, catégorie, indice)
+│       ├── originals/         # énoncés d'origine (fhecli init / reset)
+│       └── solutions/         # solutions ENCODÉES (.sol)
+├── solutions_src/             # solutions en clair : dans le dépôt, JAMAIS dans la wheel ni le sdist
+├── scripts/                   # encode_solutions.py, build_binary.py, check_binary.py
+├── packaging/                 # spécification PyInstaller (exécutables autonomes)
+├── tests/                     # tests automatisés de l'outil
+├── exercises/                 # espace de travail de développement
+├── fhecli.toml, pytest.ini    # marqueur et configuration de cet espace
+└── requirements.txt
+```
+
+Après toute modification d'une solution dans `solutions_src/` :
+
+```bash
+python scripts/encode_solutions.py
+```
+
+Construire le paquet (sans le publier) :
+
+```bash
+python -m pip install build
+python -m build                # dist/fhe_cli-<version>-py3-none-any.whl et .tar.gz
+```
+
+## Exécutables, CI et publication
+
+Construire et vérifier l'exécutable de l'OS courant (PyInstaller ne fait pas
+de compilation croisée) :
+
+```bash
+pip install -e . pyinstaller
+python scripts/build_binary.py   # dist/fhecli-<version>-<os>-<arch>[.exe]
+```
+
+`scripts/build_binary.py` lance ensuite `scripts/check_binary.py`, qui
+rejoue le parcours d'un étudiant avec le binaire seul (sans Python dans le
+`PATH`) et vérifie qu'aucun source, aucune solution ni aucun énoncé n'apparaît
+en clair dans le fichier.
+
+La CI **GitHub Actions** (`.github/workflows/fhecli.yml`) fait tout cela
+automatiquement : tests sur Linux, Windows et macOS (Python 3.11 et 3.15),
+exécutables Windows, Linux, macOS arm64 et macOS x86_64, wheel et sdist.
+
+Pour publier une version : mettre à jour `fhecli.__version__` et le
+CHANGELOG, puis pousser un tag `fhecli-vX.Y.Z` (il doit correspondre à la
+version). GitHub crée alors une release avec les exécutables et publie sur
+PyPI. Une version publiée sur PyPI ne peut pas être republiée : en cas de
+problème, publier la version suivante.
+
+Configuration à faire une seule fois :
+
+- PyPI, « trusted publishing » : sur pypi.org, ajouter un *pending publisher*
+  pour le projet `fhecli` (dépôt `Defl3ct-941/Scoring_FHE`, workflow
+  `fhecli.yml`, environnement `pypi`), et créer l'environnement `pypi` dans
+  les réglages du dépôt GitHub (limité aux tags `fhecli-v*`). Aucun jeton
+  API n'est nécessaire.
+
+## Licence
+
+MIT, voir [LICENSE](LICENSE).

fhe_cli-1.3.1.dist-info/RECORD

@@ -0,0 +1,37 @@
+fhe_cli-1.3.1.dist-info/licenses/LICENSE,sha256=vWfv3xoZi_mWXZkX8miHXnN_V6U6cAi6gLb3YhgiZys,1094
+fhecli/__init__.py,sha256=KsQ8hLzDhFfh7u8kltwTRXdOzHkbD_MTvZbjIJstyw8,177
+fhecli/__main__.py,sha256=r6-2p5dAcP4a77CVKwjBx9EmW267PfbI9bTPBJQvC2o,119
+fhecli/cli.py,sha256=U3dj7bWb5WQM26-UH31GCuilkb9iZKrV8ehYqviMyCo,8223
+fhecli/info.py,sha256=3iVuPgPIzGl3KMODPOYAJjm2vzj2meEDsTI3Z-0U16o,1201
+fhecli/resources.py,sha256=FcCEhubBAeEhL9aCCweJOz-H49zptA6o6usVmY-DNQw,842
+fhecli/runner.py,sha256=m_jkNm1Pgb7KSm1890KieCVGCMxGZ2dZQ4LwcvaZyMA,2371
+fhecli/solutions.py,sha256=1LyTfymz8AbZAWoL3v1elzBh2yxxQHjabbyDO36nTA4,1173
+fhecli/ui.py,sha256=nZC5y4lOj40MXrwvIkoscnIIHQUlVRvB_8OQHYUgSjg,1760
+fhecli/watch.py,sha256=6Dg37DiEBV2luN0mzHc_F3KUFlHQ4k0EOtYi_ecKJYk,4422
+fhecli/workspace.py,sha256=dnaZRfQIo13JMv6u3Thf59ASOzqMTaDGNPP5mG2KSFU,2059
+fhecli/data/info.toml,sha256=yk9RDSMCHvFrjG9pD2JJrzpPpW514iyPyzfLLtHO4QQ,4024
+fhecli/data/originals/ex10_ckks_bonus.py,sha256=-54y7tm7WvFKrkVwMMo5262cmknfdd_09qxmIOIAhms,3181
+fhecli/data/originals/ex1_cesar.py,sha256=8fAbsJHWLTe5venxOINIDB5UU6HY_SEi1rrLOSGIklc,3165
+fhecli/data/originals/ex2_xor_malleability.py,sha256=mLUOa-1c9KiIwd8pm9t-rPrWWz4STE_MAgGzHYbsaH4,3767
+fhecli/data/originals/ex3_fernet_tamper.py,sha256=dSfH_zeHrsFVzJih0kyQ25O-7VJ6yv565S4RcMmigTI,3180
+fhecli/data/originals/ex4_modpow.py,sha256=7E0MDUDDQIuwy_UfWa78W3ThfJYws9qovpl51ab-FLA,2526
+fhecli/data/originals/ex5_modinv.py,sha256=e-zUlyF-1WnuY69r-wx1uTQdo3x1U-7y77ScrzDHKFo,2535
+fhecli/data/originals/ex6_paillier_keygen.py,sha256=Fyhcd-rpZDDbzvzGDRrgspXGrv6LgIbu_wBq2a6LL7o,2723
+fhecli/data/originals/ex7_paillier_enc_dec.py,sha256=gxQ3ciXMR5hFjbed4_nBlFt3MwIU_hnxiYb2XvCBodk,3670
+fhecli/data/originals/ex8_paillier_homomorphic.py,sha256=HkUJEO-l-_m6y0mBJv5UtdMdmb8TMiZ75uvN24Pq8d4,4494
+fhecli/data/originals/ex9_scoring_paillier.py,sha256=sZesevdix9KJOdbJ3ul4fBCguKIGN3xoStaJrEdDMmE,4497
+fhecli/data/solutions/ex10_ckks_bonus.sol,sha256=Qc_Wehf7gmy5gkgbzB7weHLeg8zvlk7PJ2q14wDWyKU,545
+fhecli/data/solutions/ex1_cesar.sol,sha256=uKkiDnpdzTw344mxT57k9BqHcm_KfW0JaMeOLcSLD7U,363
+fhecli/data/solutions/ex2_xor_malleability.sol,sha256=ftzmK_TBaHumWqA39BvcxrNO2EJkUosijrkKyKQDUhA,440
+fhecli/data/solutions/ex3_fernet_tamper.sol,sha256=BTpUkFwci0CxEuoRiLg4pf36-k_7TjR6sS760qo4wzk,424
+fhecli/data/solutions/ex4_modpow.sol,sha256=SYBr20o1WesQSotVBoary2ErOTmpFDESjEq2K_T95sw,286
+fhecli/data/solutions/ex5_modinv.sol,sha256=eZQLwqfghF7w8XpEydcLkO_LE-Gl3ehKm4yF7d-YWys,391
+fhecli/data/solutions/ex6_paillier_keygen.sol,sha256=rEPnicNhe3xaHqAJn447zdr02uT_G0wlvc38OSllpu8,549
+fhecli/data/solutions/ex7_paillier_enc_dec.sol,sha256=gnaw9EHj9h4S0ZmI4Y7W1UYuKTSQe9VYhk2_1y0U6xo,716
+fhecli/data/solutions/ex8_paillier_homomorphic.sol,sha256=D0zoixYhg8PlmKbxROoT0hPGUAlN3nPzI9iHapq3_w0,817
+fhecli/data/solutions/ex9_scoring_paillier.sol,sha256=9tBin-kI7puipz0VJ66cR7aeswpf71cCr7CVHhKhbDU,1068
+fhe_cli-1.3.1.dist-info/METADATA,sha256=atRRMKbxGoO_SG7ry9AazKK82DvmdIRnzwbIV9cKgLM,11897
+fhe_cli-1.3.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+fhe_cli-1.3.1.dist-info/entry_points.txt,sha256=Rhwd2ixRkUJlh3COEK8uOd72ZBYVqqjSB0Oih5lhC-E,43
+fhe_cli-1.3.1.dist-info/top_level.txt,sha256=X1XW-ry2gtjQW9sgKA8Z9Q_5Q1_XTOb8AxVZCpTskVs,7
+fhe_cli-1.3.1.dist-info/RECORD,,

fhe_cli-1.3.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fhe_cli-1.3.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fhecli = fhecli.cli:main

fhe_cli-1.3.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ravin THILAGARASA, Thomas GRUNDSZTEJN
+
+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.

fhe_cli-1.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+fhecli

fhecli/__init__.py

@@ -0,0 +1,5 @@
+"""fhecli : un atelier d'exercices en ligne de commande, à la rustlings,
+pour apprendre le chiffrement classique et le chiffrement homomorphe (FHE).
+"""
+
+__version__ = "1.3.1"

fhecli/__main__.py

@@ -0,0 +1,6 @@
+"""Permet `python -m fhecli`."""
+
+from fhecli.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fhecli/cli.py

@@ -0,0 +1,220 @@
+"""Point d'entrée de la commande `fhecli`."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from fhecli import __version__, resources, ui
+from fhecli.info import exercise_names, find_exercise, load_exercises
+from fhecli.runner import PYTEST_SUBCOMMAND, has_marker, run_tests, status
+from fhecli.watch import watch as watch_loop
+from fhecli.workspace import DEFAULT_DIR, WorkspaceNotFound, find_workspace, init_workspace
+
+# Codes de sortie
+EXIT_OK = 0
+EXIT_ERROR = 1          # tests en échec, exercice inconnu, pas d'espace de travail...
+EXIT_MARKER_LEFT = 2    # tests OK mais « # I AM NOT DONE » encore présent
+
+STATUS_ICON = {
+    "done": ui.success("[x]"),
+    "almost": ui.warn("[~]"),
+    "pending": ui.failure("[ ]"),
+}
+
+
+def _workspace() -> Path:
+    try:
+        return find_workspace()
+    except WorkspaceNotFound:
+        print(ui.failure("Aucun espace de travail fhecli trouvé dans ce dossier ni dans ses parents."))
+        print(f"Lancez d'abord {ui.bold('fhecli init')} (il crée le dossier ./{DEFAULT_DIR}),")
+        print("puis placez-vous dans ce dossier.")
+        raise SystemExit(EXIT_ERROR)
+
+
+def _exercise_or_exit(name: str):
+    ex = find_exercise(_workspace(), name)
+    if ex is None:
+        print(ui.failure(f"Exercice inconnu : {name}"))
+        print(f"Utilisez {ui.bold('fhecli list')} pour voir les noms disponibles.")
+        raise SystemExit(EXIT_ERROR)
+    return ex
+
+
+def cmd_init(args) -> int:
+    target = Path(args.directory)
+    try:
+        ws = init_workspace(target, exercise_names())
+    except FileExistsError:
+        print(ui.failure(f"Un espace de travail existe déjà dans {target.resolve()}."))
+        print("Rien n'a été modifié. Choisissez un autre dossier : fhecli init <dossier>")
+        return EXIT_ERROR
+    print(ui.success(f"Espace de travail créé : {ws}"))
+    print()
+    print("Pour commencer :")
+    print(f"  cd {ws}")
+    print("  fhecli watch")
+    return EXIT_OK
+
+
+def cmd_list(args) -> int:
+    exercises = load_exercises(_workspace())
+    print(ui.bold(f"{len(exercises)} exercices :"))
+    print()
+    last_category = None
+    done_count = 0
+    for ex in exercises:
+        if ex.category != last_category:
+            print(ui.info(ex.category))
+            last_category = ex.category
+        st = status(ex.path)
+        if st == "done":
+            done_count += 1
+        bonus_tag = ui.warn(" (bonus)") if ex.bonus else ""
+        print(f"  {STATUS_ICON[st]} {ex.name:<24} {ex.title}{bonus_tag}")
+    print()
+    print(f"Progression : {done_count}/{len(exercises)} exercices résolus.")
+    print(ui.DIM + "[x] résolu   [~] tests OK, marqueur à retirer   [ ] pas encore bon" + ui.RESET)
+    return EXIT_OK
+
+
+def cmd_run(args) -> int:
+    ex = _exercise_or_exit(args.name)
+    print(ui.bold(f"{ex.name} - {ex.title}"))
+    print(f"Fichier : {ex.path}")
+    print()
+    passed, output = run_tests(ex.path)
+    print(output)
+    print()
+    if passed and has_marker(ex.path):
+        print(ui.warn(
+            "Tests OK, mais le fichier contient encore « # I AM NOT DONE ». "
+            "Retirez cette ligne une fois satisfait de votre solution."
+        ))
+        return EXIT_MARKER_LEFT
+    if passed:
+        print(ui.success("Tous les tests passent."))
+        return EXIT_OK
+    print(ui.failure("Des tests échouent encore."))
+    print(f"Besoin d'un coup de pouce ? {ui.bold('fhecli hint ' + ex.name)}")
+    return EXIT_ERROR
+
+
+def cmd_hint(args) -> int:
+    ex = _exercise_or_exit(args.name)
+    print(ui.bold(f"Indice pour {ex.name} :"))
+    print(ex.hint or "Pas d'indice supplémentaire : relisez le docstring en haut du fichier.")
+    return EXIT_OK
+
+
+def cmd_solution(args) -> int:
+    ex = _exercise_or_exit(args.name)
+    if not resources.has_solution(ex.name):
+        print(ui.failure("Pas de solution disponible pour cet exercice."))
+        return EXIT_ERROR
+    if status(ex.path) != "done":
+        print(ui.warn(f"La solution de {ex.name} est verrouillée."))
+        print("Elle se débloque quand l'exercice est résolu : les tests passent ET la")
+        print("ligne « # I AM NOT DONE » a été retirée du fichier.")
+        print(f"Vérifiez où vous en êtes avec {ui.bold('fhecli run ' + ex.name)}, "
+              f"ou demandez un indice avec {ui.bold('fhecli hint ' + ex.name)}.")
+        return EXIT_ERROR
+    print(ui.bold(f"Solution de référence pour {ex.name} :"))
+    print(ui.rule())
+    print(resources.solution_text(ex.name))
+    print(ui.rule())
+    return EXIT_OK
+
+
+def cmd_reset(args) -> int:
+    ws = _workspace()
+    if args.all:
+        targets = load_exercises(ws)
+        question = (f"Remettre les {len(targets)} exercices à leur énoncé de départ ? "
+                    "Tout votre code sera perdu.")
+    elif args.name:
+        targets = [_exercise_or_exit(args.name)]
+        question = f"Remettre {targets[0].name} à son énoncé de départ ? Votre code sera perdu."
+    else:
+        print(ui.failure("Précisez un nom d'exercice, ou utilisez --all."))
+        return EXIT_ERROR
+
+    if not args.yes and not ui.confirm(question):
+        print("Annulé, rien n'a été modifié.")
+        return EXIT_OK
+
+    for ex in targets:
+        ex.path.parent.mkdir(parents=True, exist_ok=True)
+        ex.path.write_text(resources.original_text(ex.name), encoding="utf-8")
+    if args.all:
+        print(ui.success(f"Les {len(targets)} exercices ont été réinitialisés."))
+    else:
+        print(ui.success(f"{targets[0].name} a été réinitialisé à son énoncé de départ."))
+    return EXIT_OK
+
+
+def cmd_watch(args) -> int:
+    watch_loop(load_exercises(_workspace()))
+    return EXIT_OK
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="fhecli",
+        description=(
+            "Atelier d'exercices en ligne de commande : chiffrement classique "
+            "et chiffrement homomorphe (FHE). Inspiré de rustlings."
+        ),
+        epilog="Pour commencer : fhecli init, puis cd fhe-exercices et fhecli watch.",
+    )
+    parser.add_argument("--version", action="version", version=f"fhecli {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True, metavar="commande")
+
+    p_init = sub.add_parser("init", help="Crée un espace de travail avec les exercices")
+    p_init.add_argument("directory", nargs="?", default=DEFAULT_DIR,
+                        help=f"Dossier à créer (défaut : {DEFAULT_DIR})")
+    p_init.set_defaults(func=cmd_init)
+
+    p_watch = sub.add_parser("watch", help="Mode guidé : avance exercice par exercice")
+    p_watch.set_defaults(func=cmd_watch)
+
+    p_list = sub.add_parser("list", help="Liste tous les exercices et leur statut")
+    p_list.set_defaults(func=cmd_list)
+
+    p_run = sub.add_parser("run", help="Lance les tests d'un seul exercice")
+    p_run.add_argument("name", help="Nom de l'exercice (ex : ex1_cesar)")
+    p_run.set_defaults(func=cmd_run)
+
+    p_hint = sub.add_parser("hint", help="Affiche un indice pour un exercice")
+    p_hint.add_argument("name")
+    p_hint.set_defaults(func=cmd_hint)
+
+    p_solution = sub.add_parser("solution", help="Affiche la solution (une fois l'exercice résolu)")
+    p_solution.add_argument("name")
+    p_solution.set_defaults(func=cmd_solution)
+
+    p_reset = sub.add_parser("reset", help="Remet un exercice à son énoncé de départ")
+    p_reset.add_argument("name", nargs="?", help="Nom de l'exercice (à omettre avec --all)")
+    p_reset.add_argument("--all", action="store_true", help="Réinitialise tous les exercices")
+    p_reset.add_argument("-y", "--yes", action="store_true", help="Ne pas demander de confirmation")
+    p_reset.set_defaults(func=cmd_reset)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    ui.setup_console()
+    argv = sys.argv[1:] if argv is None else argv
+    if argv and argv[0] == PYTEST_SUBCOMMAND:
+        # Usage interne (exécutable autonome) : `fhecli _run-pytest <args>`
+        # exécute le pytest embarqué. Absent de l'aide.
+        import pytest
+
+        return int(pytest.main(argv[1:]))
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fhecli/data/info.toml

@@ -0,0 +1,77 @@
+# Liste des exercices, dans l'ordre pédagogique suivi par `fhecli watch`.
+#
+# Parcours : du chiffrement classique (où tout calcul sur le chiffré est
+# impossible) jusqu'au chiffrement homomorphe, en reconstruisant Paillier à la
+# main, puis un score bancaire chiffré de bout en bout, et enfin un vrai calcul
+# FHE avec CKKS (bonus).
+
+[[exercises]]
+name = "ex1_cesar"
+category = "A. Chiffrement classique"
+title = "Le chiffrement de César"
+difficulty = "facile"
+hint = "Pour tester si `c` est une lettre, utilisez 'a' <= c <= 'z' (et 'A' <= c <= 'Z'), pas c.islower() / c.isupper() : ces méthodes renvoient aussi True pour les lettres accentuées comme « é » ou « à », qui doivent rester inchangées. La nouvelle position est (position + shift) % 26."
+
+[[exercises]]
+name = "ex2_xor_malleability"
+category = "A. Chiffrement classique"
+title = "XOR et le danger de la malléabilité"
+difficulty = "facile"
+hint = "reveal_xor_of_plaintexts ne fait qu'une seule chose : XOR de c1 et c2 entre eux (réutilisez xor_bytes). C'est le XOR qui annule la clé, pas une astuce compliquée."
+
+[[exercises]]
+name = "ex3_fernet_tamper"
+category = "A. Chiffrement classique"
+title = "Chiffrement authentifié avec Fernet"
+difficulty = "facile"
+hint = "bytearray(token) permet de modifier un octet d'un objet bytes immuable : data[0] ^= 0xFF. Attrapez cryptography.fernet.InvalidToken avec un try/except."
+
+[[exercises]]
+name = "ex4_modpow"
+category = "B. Briques mathématiques"
+title = "Exponentiation modulaire rapide"
+difficulty = "facile"
+hint = "À chaque tour : si le bit de poids faible de exp vaut 1 (exp & 1), multipliez result par base modulo mod ; puis élevez base au carré modulo mod et faites exp //= 2. Ne calculez jamais base ** exp directement."
+
+[[exercises]]
+name = "ex5_modinv"
+category = "B. Briques mathématiques"
+title = "PGCD étendu et inverse modulaire"
+difficulty = "moyen"
+hint = "extended_gcd est récursif : cas de base b == 0 -> (a, 1, 0) ; sinon g, x1, y1 = extended_gcd(b, a % b) puis renvoyez (g, y1, x1 - (a // b) * y1). Dans mod_inverse, si g != 1 levez ValueError, sinon renvoyez x % mod (le % gère les x négatifs)."
+
+[[exercises]]
+name = "ex6_paillier_keygen"
+category = "C. Paillier, pas à pas"
+title = "Générer une paire de clés Paillier"
+difficulty = "moyen"
+hint = "n = p*q, g = n+1, lam = (p-1)*(q-1), et mu = _mod_inverse(lam, n) (la fonction est déjà fournie). Renvoyez public_key = {\"n\": n, \"g\": g, \"n2\": n*n} et private_key = {\"lam\": lam, \"mu\": mu}."
+
+[[exercises]]
+name = "ex7_paillier_enc_dec"
+category = "C. Paillier, pas à pas"
+title = "Chiffrer et déchiffrer avec Paillier"
+difficulty = "moyen"
+hint = "encrypt : ((1 + m*n) % n2) * pow(r, n, n2) % n2 (pensez à m = m % n). decrypt : u = pow(c, lam, n2), puis m = (_l(u, n) * mu) % n, et enfin si m > n // 2 : m -= n (représentation symétrique pour les négatifs)."
+
+[[exercises]]
+name = "ex8_paillier_homomorphic"
+category = "C. Paillier, pas à pas"
+title = "Les propriétés homomorphes de Paillier"
+difficulty = "moyen"
+hint = "add_encrypted : (c1 * c2) % n2 (multiplier les chiffrés = additionner les clairs). mul_by_scalar : pow(c, k, n2) si k >= 0 ; si k < 0, pow(_mod_inverse(c, n2), -k, n2)."
+
+[[exercises]]
+name = "ex9_scoring_paillier"
+category = "D. Scoring chiffré"
+title = "Un score bancaire chiffré de bout en bout"
+difficulty = "difficile"
+hint = "Chiffrez chaque feature avec encrypt(pub, x, _random_r(pub[\"n\"])), multipliez chaque chiffré par son poids avec mul_by_scalar, partez de total = encrypt(pub, bias, 1), additionnez tous les termes avec add_encrypted, et ne déchiffrez qu'à la toute fin."
+
+[[exercises]]
+name = "ex10_ckks_bonus"
+category = "E. Bonus : FHE réel avec CKKS"
+title = "Votre premier calcul FHE avec CKKS (TenSEAL)"
+difficulty = "bonus"
+bonus = true
+hint = "Trois lignes : enc_vector = ts.ckks_vector(context, values) ; enc_result = enc_vector.dot(weights) ; return enc_result.decrypt()[0]. Ce bonus nécessite TenSEAL : pip install \"fhe-cli[ckks]\"."