Exemples et tutoriels du chiffre affine

Apprendre le chiffre Affine avec des exemples détaillés et le code de travail

Exemples de chiffrement de base

Chiffrement simple des mots

a = 5b = 8

Chiffrement des phrases

a = 5b = 8

Différentes clés

a = 7b = 3

Chiffre d'identité (a=1)

a = 1b = 3

Mise en œuvre de Python

def gcd(a, b):
    """Calculate Greatest Common Divisor using Euclidean algorithm"""
    while b:
        a, b = b, a % b
    return a

def mod_inverse(a, m):
    """Calculate modular multiplicative inverse using Extended Euclidean Algorithm"""
    if gcd(a, m) != 1:
        raise ValueError(f"{a} and {m} are not coprime")

    m0 = m
    x0, x1 = 0, 1

    while a > 1:
        q = a // m
        a, m = m, a % m
        x0, x1 = x1 - q * x0, x0

    return x1 + m0 if x1 < 0 else x1

def affine_encrypt(text, a, b):
    """Encrypt text using Affine cipher: E(x) = (ax + b) mod 26"""
    result = []

    for char in text:
        if char.isupper():
            x = ord(char) - ord('A')
            encrypted = (a * x + b) % 26
            result.append(chr(encrypted + ord('A')))
        elif char.islower():
            x = ord(char) - ord('a')
            encrypted = (a * x + b) % 26
            result.append(chr(encrypted + ord('a')))
        else:
            result.append(char)

    return ''.join(result)

def affine_decrypt(text, a, b):
    """Decrypt text using Affine cipher: D(y) = a⁻¹(y - b) mod 26"""
    a_inv = mod_inverse(a, 26)
    result = []

    for char in text:
        if char.isupper():
            y = ord(char) - ord('A')
            decrypted = (a_inv * (y - b)) % 26
            result.append(chr(decrypted + ord('A')))
        elif char.islower():
            y = ord(char) - ord('a')
            decrypted = (a_inv * (y - b)) % 26
            result.append(chr(decrypted + ord('a')))
        else:
            result.append(char)

    return ''.join(result)

# Example usage
plaintext = "HELLO"
a, b = 5, 8

ciphertext = affine_encrypt(plaintext, a, b)
print(f"Plaintext: {plaintext}")
print(f"Ciphertext: {ciphertext}")
print(f"Decrypted: {affine_decrypt(ciphertext, a, b)}")

Fonctionnalités : Cette implémentation inclut le calcul GCD, le calcul inverse modulaire à l'aide de l'algorithme Euclidean étendu, ainsi que les fonctions de chiffrement et de déchiffrement avec la gestion complète des erreurs.

Problèmes pratiques

Chiffrer "CRYPTOGRAPHY" en utilisant a=3, b=5
Déchiffrer "WJPPJ" avec a=5, b=8
Quelle est l'inverse modulaire de 7 (mod 26) ?

Tutoriel complet

Comprendre le chiffre Affine

Le chiffre Affine utilise une fonction mathématique pour chiffrer le texte. Chaque lettre est convertie en un nombre (A=0, B=1,..., Z=25), puis transformée en utilisant:

E(x) = (ax + b) mod 26

Où :

  • x est la position de la lettre en texte en clair (0-25)
  • a est la clé multiplicative (doit être coprime avec 26)
  • b est la clé additive (0-25)
  • Modèle 26 assure que le résultat reste dans l'alphabet

Pourquoi "a" doit être Coprime avec 26?

La valeur de 'a' doit être coprime avec 26 (GCD(a, 26) = 1) pour s'assurer que chaque lettre correspond à une lettre unique. Si 'a' partage un facteur commun avec 26, plusieurs lettres chiffreraient à la même lettre, rendant impossible le décryptage.

Valeurs valides pour 'a': 1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25

Formule de déchiffrement

Pour déchiffrer, nous avons besoin de l'inverse modulaire de 'a' (dénommé a−1):

D(y) = a⁻¹(y - b) mod 26

Exemples de code affine

Apprendre le chiffre affine est plus facile avec des exemples pratiques. Cette page fournit des démonstrations de chiffrement et de déchiffrement étape par étape, un code Python complet et des problèmes pratiques pour tester votre compréhension.

Exemple de chiffrement de base

Let's chiffre le mot "HELLO" en utilisant les touches A=5 et B=8:

Étape 1: Convertir les lettres en nombres (A=0, B=1,..., Z=25)

  • H=7, E=4, L=11, L=11, O=14

Étape 2: Appliquer la formule de chiffrement E(x) = (5x + 8) mod 26

  • H: (5×7 + 8) mod 26 = 43 mod 26 = 17 = R
  • E: (5×4 + 8) mod 26 = 28 mod 26 = 2 = C
  • L: (5×11 + 8) mod 26 = 63 mod 26 = 11 = L
  • L: (5×11 + 8) mod 26 = 63 mod 26 = 11 = L
  • O: (5×14 + 8) mod 26 = 78 mod 26 = 0 = A

Résultat: HELLO → RCLLA

Exemple de déchiffrement

Pour déchiffrer "RCLLA" avec A=5, B=8, nous avons besoin de l'inverse modulaire de 5 mod 26, qui est 21.

Étape 1: Appliquer la formule de décryptage D(y) = 21(y - 8) mod 26

  • R(17): 21×(17-8) mod 26 = 21×9 mod 26 = 189 mod 26 = 7 = H
  • C(2): 21×(2-8) mod 26 = 21×(-6) mod 26 = 21×20 mod 26 = 420 mod 26 = 4 = E
  • L(11): 21×11-8) mod 26 = 21×3 mod 26 = 63 mod 26 = 11 = L
  • L(11): 21×11-8) mod 26 = 21×3 mod 26 = 63 mod 26 = 11 = L
  • A(0): 21×(0-8) mod 26 = 21×(-8) mod 26 = 21×18 mod 26 = 378 mod 26 = 14 = O

Résultat: RCLLA → HELLO

Mise en œuvre de Python

Voici une implémentation complète du chiffre affine:

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

def mod_inverse(a, m):
    for x in range(1, m):
        if (a * x) % m == 1:
            return x
    return None

def affine_encrypt(plaintext, a, b):
    if gcd(a, 26) != 1:
        raise ValueError("Key 'a' must be coprime with 26")

    result = []
    for char in plaintext.upper():
        if char.isalpha():
            x = ord(char) - ord('A')
            encrypted = (a * x + b) % 26
            result.append(chr(encrypted + ord('A')))
        else:
            result.append(char)
    return ''.join(result)

def affine_decrypt(ciphertext, a, b):
    if gcd(a, 26) != 1:
        raise ValueError("Key 'a' must be coprime with 26")

    a_inv = mod_inverse(a, 26)
    result = []
    for char in ciphertext.upper():
        if char.isalpha():
            y = ord(char) - ord('A')
            decrypted = (a_inv * (y - b)) % 26
            result.append(chr(decrypted + ord('A')))
        else:
            result.append(char)
    return ''.join(result)

# Example usage
plaintext = "HELLO WORLD"
a, b = 5, 8
encrypted = affine_encrypt(plaintext, a, b)
decrypted = affine_decrypt(encrypted, a, b)
print(f"Plaintext: {plaintext}")
print(f"Encrypted: {encrypted}")
print(f"Decrypted: {decrypted}")

Problèmes pratiques

Testez votre compréhension avec ces exercices:

Problème 1: Chiffrer "ATTACK" avec A=7, B=3

Problème 2: Déchiffrer "FGXOT" avec A=3, B=5

Problème 3: Trouver l'inverse modulaire de 7 mod 26

Problème 4: Chiffrer "CIPHER" avec A=11, B=15

Problème 5: Quelles sont toutes les valeurs valides pour la clé A?

Answers

  1. ATTACK → EZZHFP
  2. FGXOT → HELLO
  3. L'inverse modulaire de 7 mod 26 est de 15 (parce que 7×15 = 105 = 4×26 + 1)
  4. CIPHER → AFLWPC
  5. Valeurs A valides: 1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25

Essayez ces exemples dans notre outil de chiffrement Affine ou utilisez le Calculateur pour vérifier les inverses modulaires.

Foire aux questions

Comment puis-je calculer l'inverse modulaire?

L'inverse modulaire de A mod 26 est un nombre A−1 tel que (A × A−1) mod 26 = 1. Vous pouvez le trouver en testant les numéros 1-25 ou en utilisant l'algorithme euclidien étendu. Notre calculateur calcule cela automatiquement.

Que se passe-t-il si j'utilise une valeur A invalide?

Si A partage un facteur commun avec 26 (comme 2, 4, 6, 8, 10, 12, 13, etc.), plusieurs lettres en texte en clair seront cartographiées à la même lettre de chiffrement, rendant le décryptage impossible.

Peut J'implémente le chiffre affine dans d'autres langues ?

Oui ! L'algorithme fonctionne de même dans n'importe quel langage de programmation. Les opérations principales sont l'arithmétique modulaire (% opérateur) et la recherche d'inverses modulaires. Voir notre exemple Python ci-dessus comme une référence.

En quoi le chiffre affine est-il lié au chiffre César ?

Le chiffre César est un cas particulier du chiffre affine où A=1. Cela réduit la formule à E(x) = (x + b) mod 26, ce qui n'est qu'un simple déplacement.