fhe-cli 1.3.1__py3-none-any.whl

fhecli/data/originals/ex10_ckks_bonus.py

@@ -0,0 +1,84 @@
+"""
+Ex10 (bonus) : votre premier calcul FHE réel avec CKKS (TenSEAL)
+=================================================================
+
+Paillier n'additionne que des entiers. Pour un vrai score à base de nombres
+réels (revenus, ratios, poids décimaux), on utilise CKKS, le schéma de la
+bibliothèque TenSEAL (wrapper de Microsoft SEAL). CKKS chiffre des vecteurs de
+réels et sait, sur les chiffrés, additionner, multiplier et faire des produits
+scalaires. C'est le même schéma que la démo web du projet (04_demo).
+
+Ce bonus nécessite TenSEAL, non installé par défaut :
+    pip install "fhe-cli[ckks]"
+Sans lui, les tests de cet exercice sont simplement ignorés (skipped).
+
+make_context() est fourni (mêmes paramètres que la démo). Vous implémentez le
+produit scalaire chiffré.
+
+À implémenter :
+    - encrypted_dot_product(context, values, weights) -> float
+        1. Chiffrer values dans un vecteur CKKS :  ts.ckks_vector(context, values)
+        2. Produit scalaire avec les poids CLAIRS :  enc_vector.dot(weights)
+        3. Déchiffrer et renvoyer le premier élément :  .decrypt()[0]
+
+Ce que ça démontre : le serveur calcule une combinaison pondérée des données
+du client sans jamais les voir en clair. CKKS étant approximatif, le résultat
+est très proche de la valeur attendue, pas exactement égal (d'où le abs(...) <
+1e-3 dans les tests).
+
+Testez avec : fhecli run ex10_ckks_bonus
+"""
+
+# I AM NOT DONE
+
+try:
+    import tenseal as ts
+except ImportError:  # bonus optionnel : pip install "fhe-cli[ckks]"
+    ts = None
+
+
+def make_context():
+    """Fourni : contexte CKKS prêt à l'emploi (mêmes paramètres que la démo)."""
+    context = ts.context(
+        ts.SCHEME_TYPE.CKKS,
+        poly_modulus_degree=8192,
+        coeff_mod_bit_sizes=[60, 40, 40, 60],
+    )
+    context.generate_galois_keys()
+    context.global_scale = 2 ** 40
+    return context
+
+
+def encrypted_dot_product(context, values, weights):
+    """Chiffre `values`, calcule le produit scalaire chiffré avec `weights`, déchiffre."""
+    # TODO: implémentez les 3 étapes décrites dans l'énoncé
+    raise NotImplementedError
+
+
+# ---------------------------------------------------------------------------
+# Tests : ne modifiez pas cette section, elle valide votre implémentation.
+# ---------------------------------------------------------------------------
+
+import pytest
+
+
+def test_matches_plaintext_dot_product():
+    pytest.importorskip("tenseal", reason="bonus CKKS : pip install \"fhe-cli[ckks]\"")
+    context = make_context()
+    values = [1500.0, 30.0, 1.0]
+    weights = [0.005, -0.9, -10.0]
+
+    result = encrypted_dot_product(context, values, weights)
+    expected = sum(v * w for v, w in zip(values, weights))
+    assert abs(result - expected) < 1e-3
+
+
+def test_matches_plaintext_dot_product_other_values():
+    pytest.importorskip("tenseal", reason="bonus CKKS : pip install \"fhe-cli[ckks]\"")
+    context = make_context()
+    values = [-1500.0, 55.0, 4.0]
+    weights = [0.005, -0.9, -10.0]
+
+    result = encrypted_dot_product(context, values, weights)
+    expected = sum(v * w for v, w in zip(values, weights))
+    assert abs(result - expected) < 1e-3

fhecli/data/originals/ex1_cesar.py

@@ -0,0 +1,92 @@
+"""
+Ex1 : Le chiffrement de César
+=============================
+
+Avant de parler de chiffrement homomorphe, il faut être à l'aise avec
+l'arithmétique modulaire : c'est elle qui est derrière absolument tous les
+schémas de chiffrement que vous verrez dans ce projet (Paillier, CKKS...).
+
+Le chiffrement de César décale chaque lettre de `shift` positions dans
+l'alphabet, en bouclant à la fin (Z + 1 = A). C'est exactement une addition
+modulo 26.
+
+À implémenter :
+    - caesar_encrypt(text: str, shift: int) -> str
+    - caesar_decrypt(text: str, shift: int) -> str
+
+Règles :
+    - Les lettres minuscules et majuscules sont décalées, chacune restant
+      dans sa casse ('a'..'z' / 'A'..'Z').
+    - Tout ce qui n'est pas une lettre (espaces, ponctuation, chiffres,
+      lettres accentuées) est recopié SANS modification.
+    - `shift` peut être négatif ou plus grand que 26 : ça doit fonctionner
+      quand même (pensez à l'opérateur %).
+
+Exemple :
+    caesar_encrypt("Hello, World!", 3) == "Khoor, Zruog!"
+    caesar_decrypt("Khoor, Zruog!", 3) == "Hello, World!"
+
+Indice : pour une lettre `c`, sa position dans l'alphabet est
+`ord(c) - ord('a')` (ou ord('A') pour les majuscules), et la nouvelle
+position est `(position + shift) % 26`.
+
+ATTENTION : pour détecter si `c` est une lettre, préférez une comparaison
+explicite ('a' <= c <= 'z') plutôt que c.islower() / c.isupper() : ces
+méthodes renvoient aussi True pour des lettres accentuées comme « é » ou
+« à », qui doivent pourtant rester inchangées.
+
+Testez avec : fhecli run ex1_cesar
+"""
+
+# I AM NOT DONE
+
+
+def caesar_encrypt(text: str, shift: int) -> str:
+    """Décale chaque lettre de `text` de `shift` positions (modulo 26)."""
+    # TODO: implémentez cette fonction
+    raise NotImplementedError
+
+
+def caesar_decrypt(text: str, shift: int) -> str:
+    """Opération inverse de caesar_encrypt."""
+    # TODO: implémentez cette fonction
+    raise NotImplementedError
+
+
+# ---------------------------------------------------------------------------
+# Tests : ne modifiez pas cette section, elle valide votre implémentation.
+# ---------------------------------------------------------------------------
+
+
+def test_known_vector():
+    assert caesar_encrypt("Hello, World!", 3) == "Khoor, Zruog!"
+
+
+def test_decrypt_is_inverse_of_encrypt():
+    for shift in [1, 3, 13, 25]:
+        for text in ["Bonjour", "PYTHON is FUN", "a b c Z"]:
+            enc = caesar_encrypt(text, shift)
+            assert caesar_decrypt(enc, shift) == text
+
+
+def test_non_letters_untouched():
+    assert caesar_encrypt("123 !? éà", 5) == "123 !? éà"
+
+
+def test_wraps_around_alphabet():
+    assert caesar_encrypt("xyz", 3) == "abc"
+    assert caesar_encrypt("XYZ", 3) == "ABC"
+
+
+def test_negative_and_large_shift():
+    assert caesar_encrypt("abc", -1) == caesar_encrypt("abc", 25)
+    assert caesar_encrypt("abc", 29) == caesar_encrypt("abc", 3)
+
+
+def test_case_is_preserved():
+    result = caesar_encrypt("AbC", 1)
+    assert result[0].isupper() and result[1].islower() and result[2].isupper()
+
+
+def test_accented_letters_are_not_shifted():
+    assert caesar_encrypt("café", 1) == "dbgé"

fhecli/data/originals/ex2_xor_malleability.py

@@ -0,0 +1,102 @@
+"""
+Ex2 : XOR et le danger de la malléabilité
+==========================================
+
+Le XOR (^) a une propriété étonnante : si `k` est une clé et `m` un message
+(en octets), alors :
+
+    chiffrer(m, k)   = m XOR k
+    déchiffrer(c, k) = c XOR k    (car (m XOR k) XOR k == m)
+
+C'est un chiffrement « homomorphe » jouet... mais c'est justement ce qui le
+rend dangereux dès qu'on réutilise la même clé deux fois : c'est l'attaque
+classique du « two-time pad ».
+
+À implémenter :
+    - xor_bytes(a: bytes, b: bytes) -> bytes
+      XOR octet par octet de deux suites de même longueur.
+    - xor_encrypt(message: bytes, key: bytes) -> bytes
+      XOR du message avec la clé répétée autant de fois que nécessaire pour
+      couvrir sa longueur. (xor_decrypt est déjà fourni : le XOR est son
+      propre inverse.)
+    - reveal_xor_of_plaintexts(c1: bytes, c2: bytes) -> bytes
+      Si c1 et c2 sont deux messages chiffrés AVEC LA MÊME clé, cette
+      fonction doit renvoyer le XOR des deux messages en clair, SANS jamais
+      connaître la clé. (Indice : une seule ligne, qui réutilise xor_bytes.)
+
+Pourquoi c'est important : ceci illustre une idée centrale du projet. Dans
+un chiffrement classique, toute malléabilité est une faille de sécurité.
+Ici, réutiliser la clé permet de retrouver de l'information sur les
+messages en clair sans jamais les déchiffrer. Le FHE renverse ce principe :
+il rend le chiffré délibérément et strictement malléable, mais uniquement
+pour les opérations mathématiques choisies par le concepteur du schéma
+(addition, multiplication...), avec des garanties de sécurité prouvées.
+C'est toute la différence entre une malléabilité subie (dangereuse) et une
+malléabilité conçue (le FHE).
+
+Testez avec : fhecli run ex2_xor_malleability
+"""
+
+# I AM NOT DONE
+
+
+def xor_bytes(a: bytes, b: bytes) -> bytes:
+    """XOR octet par octet. `a` et `b` ont la même longueur."""
+    # TODO: implémentez cette fonction
+    raise NotImplementedError
+
+
+def xor_encrypt(message: bytes, key: bytes) -> bytes:
+    """Chiffre `message` en le XORant avec `key` répétée."""
+    # TODO: implémentez cette fonction (réutilisez xor_bytes)
+    raise NotImplementedError
+
+
+def xor_decrypt(ciphertext: bytes, key: bytes) -> bytes:
+    """Le XOR est son propre inverse : déchiffrer = chiffrer à nouveau."""
+    return xor_encrypt(ciphertext, key)
+
+
+def reveal_xor_of_plaintexts(c1: bytes, c2: bytes) -> bytes:
+    """
+    Si c1 et c2 ont été chiffrés avec LA MÊME clé (two-time pad), renvoie
+    le XOR des deux messages en clair, sans jamais connaître la clé.
+    """
+    # TODO: implémentez cette fonction
+    raise NotImplementedError
+
+
+# ---------------------------------------------------------------------------
+# Tests : ne modifiez pas cette section, elle valide votre implémentation.
+# ---------------------------------------------------------------------------
+
+
+def test_xor_bytes_basic():
+    assert xor_bytes(b"\x00\xff", b"\xff\x00") == b"\xff\xff"
+    assert xor_bytes(b"AB", b"AB") == b"\x00\x00"
+
+
+def test_encrypt_decrypt_roundtrip():
+    key = b"secret"
+    for message in [b"hello world", b"a", b"", b"x" * 50]:
+        enc = xor_encrypt(message, key)
+        assert xor_decrypt(enc, key) == message
+
+
+def test_key_is_repeated():
+    key = b"ab"
+    message = b"1234"
+    enc = xor_encrypt(message, key)
+    assert enc == xor_bytes(message, b"abab")
+
+
+def test_two_time_pad_attack():
+    key = b"supersecretkey!!"
+    p1 = b"TRANSFER 100 EUR"
+    p2 = b"TRANSFER 999 EUR"
+    c1 = xor_encrypt(p1, key)
+    c2 = xor_encrypt(p2, key)
+
+    # sans connaître `key`, on doit retrouver p1 XOR p2
+    revealed = reveal_xor_of_plaintexts(c1, c2)
+    assert revealed == xor_bytes(p1, p2)

fhecli/data/originals/ex3_fernet_tamper.py

@@ -0,0 +1,92 @@
+"""
+Ex3 : Chiffrement authentifié avec Fernet
+===========================================
+
+Dans la démo web du projet Scoring FHE (04_demo/backend/app/crypto/classic_aes.py),
+on utilise Fernet (AES-128-CBC + HMAC) pour montrer qu'un chiffrement
+classique détecte et rejette toute donnée falsifiée. Ici, vous allez
+reproduire ce comportement vous-même, avec la vraie bibliothèque
+`cryptography`.
+
+À implémenter :
+    - encrypt_value(value: str, key: bytes) -> bytes
+      Chiffre une chaîne avec Fernet(key). `value` doit être encodée en
+      bytes avant chiffrement (value.encode()).
+    - decrypt_value(token: bytes, key: bytes) -> str
+      Opération inverse, renvoie une chaîne (.decode()).
+    - tamper_and_check(token: bytes, key: bytes) -> bool
+      Modifie UN SEUL octet du token (par exemple en inversant ses bits
+      avec XOR 0xFF), puis tente de le déchiffrer. Renvoie True si la
+      falsification est détectée (exception InvalidToken levée), False
+      sinon.
+
+Indice :
+    from cryptography.fernet import Fernet, InvalidToken
+    key = Fernet.generate_key()   # à utiliser dans vos propres tests
+
+Pour modifier un octet d'un objet bytes (immuable), passez par un bytearray :
+    data = bytearray(token)
+    data[0] ^= 0xFF
+    tampered = bytes(data)
+
+Ce que ça démontre : un chiffrement authentifié ne laisse aucune marge de
+manœuvre. La moindre modification du chiffré, même d'un seul bit, est
+détectée. C'est une excellente propriété de sécurité... mais c'est aussi
+précisément ce qui rend tout calcul sur le chiffré impossible avec ce type
+de schéma.
+
+Testez avec : fhecli run ex3_fernet_tamper
+"""
+
+from cryptography.fernet import Fernet, InvalidToken
+
+# I AM NOT DONE
+
+
+def encrypt_value(value: str, key: bytes) -> bytes:
+    """Chiffre `value` avec Fernet(key)."""
+    # TODO: implémentez cette fonction
+    raise NotImplementedError
+
+
+def decrypt_value(token: bytes, key: bytes) -> str:
+    """Déchiffre `token` avec Fernet(key)."""
+    # TODO: implémentez cette fonction
+    raise NotImplementedError
+
+
+def tamper_and_check(token: bytes, key: bytes) -> bool:
+    """
+    Modifie un octet de `token`, tente de le déchiffrer, et renvoie True
+    si InvalidToken a bien été levée (falsification détectée).
+    """
+    # TODO: implémentez cette fonction
+    raise NotImplementedError
+
+
+# ---------------------------------------------------------------------------
+# Tests : ne modifiez pas cette section, elle valide votre implémentation.
+# ---------------------------------------------------------------------------
+
+import pytest
+
+
+def test_roundtrip():
+    key = Fernet.generate_key()
+    token = encrypt_value("hello bank", key)
+    assert isinstance(token, bytes)
+    assert decrypt_value(token, key) == "hello bank"
+
+
+def test_different_keys_cannot_decrypt():
+    key1 = Fernet.generate_key()
+    key2 = Fernet.generate_key()
+    token = encrypt_value("secret data", key1)
+    with pytest.raises(Exception):
+        decrypt_value(token, key2)
+
+
+def test_tampering_is_detected():
+    key = Fernet.generate_key()
+    token = encrypt_value("revenu=4000", key)
+    assert tamper_and_check(token, key) is True

fhecli/data/originals/ex4_modpow.py

@@ -0,0 +1,73 @@
+"""
+Ex4 : Exponentiation modulaire rapide (square-and-multiply)
+============================================================
+
+On quitte le chiffrement classique pour poser les briques mathématiques du
+chiffrement homomorphe. La toute première est l'exponentiation modulaire :
+calculer (base ** exp) % mod. Paillier, RSA et beaucoup d'autres schémas
+reposent dessus, avec des exposants de plusieurs centaines de chiffres.
+
+Calculer base ** exp puis prendre le modulo est impossible en pratique : le
+nombre intermédiaire aurait des millions de chiffres. L'algorithme
+« square-and-multiply » garde au contraire des nombres petits (toujours
+réduits modulo `mod`) en parcourant l'exposant bit par bit.
+
+À implémenter :
+    - mod_pow(base, exp, mod) -> int
+      Calcule (base ** exp) % mod SANS passer par base ** exp.
+
+Algorithme :
+    result = 1
+    base = base % mod
+    tant que exp > 0 :
+        si le bit de poids faible de exp vaut 1 (exp & 1) :
+            result = (result * base) % mod
+        base = (base * base) % mod   # on élève base au carré
+        exp = exp // 2               # on passe au bit suivant
+
+Contrainte : n'utilisez pas le pow(base, exp, mod) intégré à trois arguments
+(c'est justement ce que vous reconstruisez ici). Vous pourrez l'utiliser dans
+les exercices suivants.
+
+Testez avec : fhecli run ex4_modpow
+"""
+
+# I AM NOT DONE
+
+
+def mod_pow(base: int, exp: int, mod: int) -> int:
+    """Calcule (base ** exp) % mod par exponentiation rapide."""
+    # TODO: implémentez l'algorithme square-and-multiply décrit ci-dessus
+    raise NotImplementedError
+
+
+# ---------------------------------------------------------------------------
+# Tests : ne modifiez pas cette section, elle valide votre implémentation.
+# ---------------------------------------------------------------------------
+
+import random
+
+
+def test_small_values():
+    assert mod_pow(4, 13, 497) == pow(4, 13, 497)
+    assert mod_pow(2, 10, 1000) == pow(2, 10, 1000)
+
+
+def test_exponent_zero():
+    assert mod_pow(123, 0, 97) == 1
+
+
+def test_matches_builtin_pow_on_random_values():
+    random.seed(42)
+    for _ in range(30):
+        base = random.randint(2, 10_000)
+        exp = random.randint(0, 1000)
+        mod = random.randint(2, 10_000)
+        assert mod_pow(base, exp, mod) == pow(base, exp, mod)
+
+
+def test_large_numbers_like_real_crypto():
+    base = 123456789012345678901234567890
+    exp = 987654321
+    mod = 100000000000000000000000000000000000039
+    assert mod_pow(base, exp, mod) == pow(base, exp, mod)

fhecli/data/originals/ex5_modinv.py

@@ -0,0 +1,77 @@
+"""
+Ex5 : PGCD étendu et inverse modulaire
+=======================================
+
+Deuxième brique mathématique. Dans Paillier, le déchiffrement a besoin de
+« diviser » modulo n, c'est-à-dire de multiplier par un inverse modulaire :
+l'entier x tel que (a * x) % mod == 1. Cet inverse n'existe que si a et mod
+sont premiers entre eux (pgcd == 1).
+
+On l'obtient avec l'algorithme d'Euclide étendu, qui calcule en même temps le
+pgcd de a et b et les coefficients de Bézout x, y tels que a*x + b*y == pgcd.
+
+À implémenter :
+    - extended_gcd(a, b) -> (g, x, y)
+      avec a*x + b*y == g == pgcd(a, b). Version récursive :
+          si b == 0 : renvoyer (a, 1, 0)
+          sinon :
+              g, x1, y1 = extended_gcd(b, a % b)
+              renvoyer (g, y1, x1 - (a // b) * y1)
+    - mod_inverse(a, mod) -> int
+      Réutilise extended_gcd. Si g != 1, l'inverse n'existe pas : levez une
+      ValueError. Sinon, renvoyez x % mod (le % ramène l'inverse dans
+      [0, mod) même si x est négatif).
+
+Testez avec : fhecli run ex5_modinv
+"""
+
+# I AM NOT DONE
+
+
+def extended_gcd(a: int, b: int) -> tuple[int, int, int]:
+    """Renvoie (g, x, y) tel que a*x + b*y == g == pgcd(a, b)."""
+    # TODO: implémentez la récursion décrite ci-dessus
+    raise NotImplementedError
+
+
+def mod_inverse(a: int, mod: int) -> int:
+    """Renvoie x tel que (a * x) % mod == 1. Lève ValueError si impossible."""
+    # TODO: réutilisez extended_gcd pour calculer l'inverse
+    raise NotImplementedError
+
+
+# ---------------------------------------------------------------------------
+# Tests : ne modifiez pas cette section, elle valide votre implémentation.
+# ---------------------------------------------------------------------------
+
+import math
+import random
+
+import pytest
+
+
+def test_extended_gcd_bezout_identity():
+    for a, b in [(35, 15), (240, 46), (17, 5), (1000000007, 998244353)]:
+        g, x, y = extended_gcd(a, b)
+        assert a * x + b * y == g
+        assert g == math.gcd(a, b)
+
+
+def test_mod_inverse_matches_builtin():
+    random.seed(7)
+    mod = 1_000_000_007  # nombre premier
+    for _ in range(20):
+        a = random.randint(1, mod - 1)
+        assert mod_inverse(a, mod) % mod == pow(a, -1, mod)
+
+
+def test_mod_inverse_paillier_like_modulus():
+    n = 1009 * 1013
+    for a in [5, 123, 99999]:
+        inv = mod_inverse(a, n)
+        assert (a * inv) % n == 1
+
+
+def test_mod_inverse_raises_when_not_coprime():
+    with pytest.raises(ValueError):
+        mod_inverse(6, 9)  # pgcd(6, 9) == 3, pas d'inverse

fhecli/data/originals/ex6_paillier_keygen.py

@@ -0,0 +1,85 @@
+"""
+Ex6 : Générer une paire de clés Paillier
+==========================================
+
+On attaque le chiffrement homomorphe partiel de Paillier (1999). Sa propriété
+remarquable : on peut ADDITIONNER deux messages chiffrés sans les déchiffrer.
+C'est exactement ce qu'il faut pour un score = somme pondérée de features.
+
+Tout commence par les clés. On part de deux nombres premiers p et q (petits
+ici, pour que les tests soient rapides ; énormes en vrai).
+
+Les deux fonctions utilitaires _extended_gcd et _mod_inverse sont déjà
+fournies (c'est votre travail de l'ex5). Vous n'implémentez que la génération
+de clés.
+
+À implémenter :
+    - generate_keypair(p, q) -> (public_key, private_key)
+      avec la variante classique g = n + 1 :
+          n   = p * q
+          g   = n + 1
+          lam = (p - 1) * (q - 1)          # lambda = indicatrice d'Euler
+          mu  = inverse modulaire de lam modulo n
+      puis :
+          public_key  = {"n": n, "g": g, "n2": n * n}
+          private_key = {"lam": lam, "mu": mu}
+
+Testez avec : fhecli run ex6_paillier_keygen
+"""
+
+# I AM NOT DONE
+
+
+def _extended_gcd(a: int, b: int) -> tuple[int, int, int]:
+    """Fourni (ex5) : (g, x, y) tel que a*x + b*y == g == pgcd(a, b)."""
+    if b == 0:
+        return a, 1, 0
+    g, x1, y1 = _extended_gcd(b, a % b)
+    return g, y1, x1 - (a // b) * y1
+
+
+def _mod_inverse(a: int, mod: int) -> int:
+    """Fourni (ex5) : inverse modulaire de a modulo mod."""
+    g, x, _ = _extended_gcd(a, mod)
+    if g != 1:
+        raise ValueError(f"{a} n'a pas d'inverse modulo {mod}")
+    return x % mod
+
+
+def generate_keypair(p: int, q: int) -> tuple[dict, dict]:
+    """Construit une paire de clés Paillier simplifiée (g = n + 1)."""
+    # TODO: calculez n, g, lam, mu et renvoyez (public_key, private_key)
+    raise NotImplementedError
+
+
+# ---------------------------------------------------------------------------
+# Tests : ne modifiez pas cette section, elle valide votre implémentation.
+# ---------------------------------------------------------------------------
+
+P, Q = 1009, 1013
+
+
+def test_public_key_values():
+    pub, _ = generate_keypair(P, Q)
+    n = P * Q
+    assert pub["n"] == n
+    assert pub["g"] == n + 1
+    assert pub["n2"] == n * n
+
+
+def test_private_key_values():
+    _, priv = generate_keypair(P, Q)
+    lam = (P - 1) * (Q - 1)
+    n = P * Q
+    assert priv["lam"] == lam
+    # mu doit être l'inverse modulaire de lam mod n (vérifié indépendamment)
+    assert (priv["mu"] * lam) % n == 1
+
+
+def test_keys_are_consistent_for_other_primes():
+    p, q = 61, 53
+    pub, priv = generate_keypair(p, q)
+    n = p * q
+    lam = (p - 1) * (q - 1)
+    assert pub["n"] == n
+    assert (priv["mu"] * lam) % n == 1