Informatique au lycée Faustin Fleret

Entraînement 1 : le code de César

L’exemple le plus connu de chiffrement symétrique, et un des plus simples, est le chiffre de César. Pour obtenir le texte chiffré, le chiffre de César consiste à remplacer chaque lettre du texte en clair par la lettre obtenue après un décalage d’un nombre fixe de lettres dans l’alphabet.
Pour un décalage de 3 lettres, le A devient D, le B devient E… Comme le montre l’image ci-dessous :

Le nombre 3, qui correspond au nombre de lettres à décaler, est appelé la clef secrète de chiffrement. Pour déchiffrer le message, il suffit de donner la clef de chiffrement au destinataire du message qui réalise l’opération inverse pour déchiffrer le message.

La fonction position_alphabet ci-dessous prend en paramètre un caractère lettre et renvoie la position de lettre dans la chaîne de caractères ALPHABET s’il s’y trouve et -1 sinon.
La fonction cesar prend en paramètre une chaîne de caractères message et un nombre entier décalage et renvoie le nouveau message codé avec le codage de César utilisant le décalage .

ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def position_alphabet(lettre):
    # lettre.upper() convertit la lettre en majuscule
    return ALPHABET.find(lettre.upper())

def cesar(message, decalage):
    resultat = ...
    for lettre in message:
        if lettre.isalpha():  # Vérifie si la lettre est alphabétique
            indice = (position_alphabet(...) + ...) % 26
            # lettre.isupper() vérifie si la lettre était en majuscule
            if lettre.isupper():
                resultat += ALPHABET[...]
            else:
                resultat += ALPHABET[...].lower()
        else:
            resultat += ...
    return ...

Compléter la fonction cesar.
Exemples :

# Résultat attendu : 'FSRNSYV E XSYW. ZMZI PE QEXMIVI RWM !'
print(cesar('BONJOUR A TOUS. VIVE LA MATIERE NSI !', 4))

# Résultat attendu : 'BONJOUR A TOUS. VIVE LA MATIERE NSI !'
print(cesar('GTSOTZW F YTZX. ANAJ QF RFYNJWJ SXN !', -5))

Entraînement 2 :

Décrypter le message suivant (code cesar)

Entraînement 3 : Analyse fréquentielle

Dans la langue française, la lettre "E" est la plus employée. Des études statistiques ont permis d'estimer la fréquence des lettres en fonction de la langue. Voici ce tableau de fréquences pour le français et l'anglais.

Si on connaît la langue d'un texte, alors on peut par exemple, dans le cas d'un chiffrement de César, retrouver le décalage.
Pour que cette analyse soit efficace, il faut que le texte soit suffisamment long.

1. Écrire une fonction, `analyse_frequence`, qui renvoie un dictionnaire des fréquences en pourcentages des différentes lettres utilisées dans un message passé en argument.

>>> analyse_frequence("hello world")
{'h': 10.0, 'e': 10.0, 'l': 30.0, 'o': 20.0, 'w': 10.0, 'r': 10.0, 'd': 10.0}

2. Effectuez une analyse fréquentielle du fichier suivant.
3. En déduire, dans le cas d'utilisation du code César, la clé utilisée pour ce texte.
4. Que venez-vous de décoder ?

Entraînement 4 :Le Sortilège du Secret ( Chiffrement XOR)

Le Défi de Poudlard

Harry Potter doit envoyer un message secret à Hermione pour contrer les Mangemorts. Le professeur Flitwick leur enseigne un sort de chiffrement puissant : le XOR magique.

Partie 1 : Le Sortilège XOR

Le XOR (⊕) est une opération binaire magique :

Question 1 : Pratique du sort

Calculez : 1100 ⊕ 1010

Partie 2 : Application sur des mots

Pour chiffrer "NSI" avec la clé "XOR" :

Étape 1 : Conversion en runes binaires (ASCII)

N = 78 → 01001110
S = 83 → 01010011
I = 73 → 01001001

Question 2 : Chiffrement

Calculez 01001110 ⊕ 01011000 (N ⊕ X)

Mission : Décrypter le message secret

Hermione a reçu ce message chiffré :

11000111 10101101 01010100 10011001 00100110 11101110 00101111 01010011 00011001

10101010 11001100 00110011 11110000 01010101 10011001 01001010 00111100 01101101

Question 3 : Implémentation du sort

Complétez les fonctions Python suivantes :

def texte_vers_binaire(texte):
    """Convertit un texte en sa représentation binaire (8 bits par caractère)."""
    binaire = ""
    for caractere in texte:
        # Convertit le caractère en code ASCII, puis en binaire sur 8 bits
        binaire += format(ord(___), '08b') # À compléter
    return ___ # À compléter

def xor_binaire(binaire1, binaire2):
    """Applique un XOR entre deux chaînes binaires de même longueur."""
    resultat = ""
    for bit1, bit2 in zip(binaire1, binaire2):
        resultat += str(int(___) ^ int(___))  # ^ Opération XOR # À compléter
    return ___ # À compléter

def binaire_vers_texte(binaire):
    """Convertit une chaîne binaire (8 bits par caractère) en texte."""
    texte = ___ # À compléter
    for i in range(0, len(binaire), 8):
        octet = binaire[i:i+8]
        texte += chr(int(___, 2))  # Convertit l'octet en caractère
    return ___ # À compléter