B3.3 - Cryptographie et Chiffrement

César, Vigenère, Hash et Blockchain - BTS SIO

🎯 Objectifs du cours

À l'issue de ce cours, vous serez capable de : - Comprendre les principes fondamentaux de la cryptographie - Implémenter les chiffrements César et Vigenère - Utiliser les fonctions de hachage pour sécuriser les données - Appréhender les bases de la blockchain et des cryptomonnaies

---

🔐 Fondamentaux de la cryptographie

Cryptographie

Science qui étudie les techniques de chiffrement permettant de protéger des informations en les rendant incompréhensibles sans la clé de déchiffrement appropriée.

Types de cryptographie

🔑

Cryptographie symétrique

Utilise la même clé pour chiffrer et déchiffrer. Rapide mais nécessite un échange sécurisé de la clé.

🔐

Cryptographie asymétrique

Utilise une paire de clés (publique/privée). Plus sécurisé pour l'échange mais plus lent.

🔨

Fonctions de hachage

Transforment des données de taille variable en une empreinte de taille fixe. Irréversible et unique.

🔍 Principe de Kerckhoffs : La sécurité d'un système cryptographique ne doit reposer que sur le secret de la clé, jamais sur celui de l'algorithme.

---

🏛️ Chiffrement de César

Chiffrement de César

Technique de chiffrement par substitution où chaque lettre du texte est remplacée par une lettre située à une position fixe dans l'alphabet (décalage).

Principe du chiffrement César

Exemple avec un décalage de 3

Texte clair	A	B	C	D	E	F	G	H	I	J
Texte chiffré	D	E	F	G	H	I	J	K	L	M

Exemple : "HELLO" → "KHOOR"

Implémentation en Python

Chiffrement de César en Python

def chiffrement_cesar(texte, decalage):
    """
    Chiffre un texte avec le chiffrement de César
    """
    resultat = ""

    for caractere in texte:
        if caractere.isalpha():
            # Déterminer si c'est une majuscule ou minuscule
            debut = ord('A') if caractere.isupper() else ord('a')

            # Appliquer le décalage avec modulo 26
            nouveau_char = chr((ord(caractere) - debut + decalage) % 26 + debut)
            resultat += nouveau_char
        else:
            # Garder les caractères non alphabétiques
            resultat += caractere

    return resultat

def dechiffrement_cesar(texte_chiffre, decalage):
    """
    Déchiffre un texte chiffré avec César
    """
    return chiffrement_cesar(texte_chiffre, -decalage)

# Exemple d'utilisation
message = "HELLO WORLD"
message_chiffre = chiffrement_cesar(message, 3)
print(f"Message original : {message}")
print(f"Message chiffré : {message_chiffre}")
print(f"Message déchiffré : {dechiffrement_cesar(message_chiffre, 3)}")

Cryptanalyse du chiffrement César

🔍 Attaque par force brute

Tester les 25 clés possibles (décalages de 1 à 25) jusqu'à obtenir un texte cohérent.

📊 Analyse fréquentielle

Analyser la fréquence des lettres et comparer avec les fréquences typiques de la langue.

---

🔤 Chiffrement de Vigenère

Chiffrement de Vigenère

Amélioration du chiffrement de César utilisant un mot-clé pour varier le décalage. Chaque lettre du message est chiffrée avec un décalage différent basé sur le mot-clé.

Principe du chiffrement Vigenère

Exemple avec le mot-clé "KEY"

Message	H	E	L	L	O	W	O	R	L	D
Clé répétée	K	E	Y	K	E	Y	K	E	Y	K
Décalage	10	4	24	10	4	24	10	4	24	10
Résultat	R	I	J	V	S	U	Y	V	J	N

Implémentation en Python

Chiffrement de Vigenère en Python

def chiffrement_vigenere(texte, cle):
    """
    Chiffre un texte avec le chiffrement de Vigenère
    """
    resultat = ""
    cle = cle.upper()
    index_cle = 0

    for caractere in texte:
        if caractere.isalpha():
            # Déterminer la base (A ou a)
            debut = ord('A') if caractere.isupper() else ord('a')

            # Calculer le décalage basé sur la clé
            decalage = ord(cle[index_cle % len(cle)]) - ord('A')

            # Appliquer le chiffrement
            nouveau_char = chr((ord(caractere.upper()) - ord('A') + decalage) % 26 + debut)
            resultat += nouveau_char

            index_cle += 1
        else:
            resultat += caractere

    return resultat

def dechiffrement_vigenere(texte_chiffre, cle):
    """
    Déchiffre un texte chiffré avec Vigenère
    """
    resultat = ""
    cle = cle.upper()
    index_cle = 0

    for caractere in texte_chiffre:
        if caractere.isalpha():
            debut = ord('A') if caractere.isupper() else ord('a')
            decalage = ord(cle[index_cle % len(cle)]) - ord('A')

            # Soustraire le décalage pour déchiffrer
            nouveau_char = chr((ord(caractere.upper()) - ord('A') - decalage) % 26 + debut)
            resultat += nouveau_char

            index_cle += 1
        else:
            resultat += caractere

    return resultat

# Exemple d'utilisation
message = "HELLO WORLD"
cle = "KEY"
message_chiffre = chiffrement_vigenere(message, cle)
print(f"Message : {message}")
print(f"Clé : {cle}")
print(f"Chiffré : {message_chiffre}")
print(f"Déchiffré : {dechiffrement_vigenere(message_chiffre, cle)}")

---

🔨 Fonctions de hachage

Fonction de hachage cryptographique

Fonction mathématique qui transforme des données de taille arbitraire en une chaîne de caractères de taille fixe (empreinte ou hash). Elle est irréversible et déterministe.

Propriétés des fonctions de hachage

🔄 Déterministe

La même entrée produit toujours la même sortie.

⚡ Rapide

Calcul efficace de l'empreinte pour toute donnée d'entrée.

🌊 Effet avalanche

Un petit changement dans l'entrée modifie drastiquement la sortie.

🔒 Irréversible

Impossible de retrouver l'entrée à partir de l'empreinte.

🎯 Résistance aux collisions

Très difficile de trouver deux entrées avec la même empreinte.

Utilisation avec Python hashlib

Fonctions de hachage avec hashlib

import hashlib

def calculer_hash(texte, algorithme='sha256'):
    """
    Calcule l'empreinte d'un texte avec l'algorithme spécifié
    """
    # Encoder le texte en bytes
    texte_bytes = texte.encode('utf-8')

    # Créer l'objet hash
    if algorithme == 'md5':
        hash_obj = hashlib.md5(texte_bytes)
    elif algorithme == 'sha1':
        hash_obj = hashlib.sha1(texte_bytes)
    elif algorithme == 'sha256':
        hash_obj = hashlib.sha256(texte_bytes)
    elif algorithme == 'sha512':
        hash_obj = hashlib.sha512(texte_bytes)
    else:
        raise ValueError("Algorithme non supporté")

    # Retourner l'empreinte en hexadécimal
    return hash_obj.hexdigest()

# Exemples d'utilisation
message = "Hello World"
print(f"Message : {message}")
print(f"MD5    : {calculer_hash(message, 'md5')}")
print(f"SHA1   : {calculer_hash(message, 'sha1')}")
print(f"SHA256 : {calculer_hash(message, 'sha256')}")
print(f"SHA512 : {calculer_hash(message, 'sha512')}")

# Démonstration de l'effet avalanche
print(f"\nEffet avalanche :")
print(f"'Hello World'  : {calculer_hash('Hello World')}")
print(f"'Hello World!' : {calculer_hash('Hello World!')}")

Applications des fonctions de hachage

🔧 Utilisations courantes :

• Stockage de mots de passe : Jamais en clair, toujours hachés
• Intégrité des données : Vérifier qu'un fichier n'a pas été modifié
• Signatures numériques : Authentification et non-répudiation
• Blockchain : Chaînage des blocs et preuve de travail
• Tables de hachage : Structures de données efficaces

---

⛓️ Introduction à la Blockchain

Blockchain

Technologie de stockage et de transmission d'informations, transparente et sécurisée, fonctionnant sans organe central de contrôle. Elle constitue une base de données distribuée et immuable.

Structure d'un bloc

🧱 Composants d'un bloc

• Hash du bloc précédent : Lien cryptographique
• Timestamp : Horodatage de création
• Données : Transactions ou informations
• Nonce : Nombre utilisé une seule fois (proof of work)
• Hash du bloc : Empreinte unique du bloc

Implémentation simple d'une blockchain

Blockchain basique en Python

import hashlib
import time
import json

class Bloc:
    def __init__(self, donnees, hash_precedent):
        self.timestamp = time.time()
        self.donnees = donnees
        self.hash_precedent = hash_precedent
        self.nonce = 0
        self.hash = self.calculer_hash()

    def calculer_hash(self):
        """Calcule le hash du bloc"""
        contenu = f"{self.hash_precedent}{self.timestamp}{self.donnees}{self.nonce}"
        return hashlib.sha256(contenu.encode()).hexdigest()

    def miner_bloc(self, difficulte):
        """Mine le bloc avec une difficulté donnée (proof of work)"""
        cible = "0" * difficulte

        while self.hash[:difficulte] != cible:
            self.nonce += 1
            self.hash = self.calculer_hash()

        print(f"Bloc miné : {self.hash}")

class Blockchain:
    def __init__(self):
        self.chaine = [self.creer_bloc_genese()]
        self.difficulte = 2

    def creer_bloc_genese(self):
        """Crée le premier bloc de la chaîne"""
        return Bloc("Bloc Genèse", "0")

    def obtenir_dernier_bloc(self):
        """Retourne le dernier bloc de la chaîne"""
        return self.chaine[-1]

    def ajouter_bloc(self, nouveau_bloc):
        """Ajoute un nouveau bloc à la chaîne"""
        nouveau_bloc.hash_precedent = self.obtenir_dernier_bloc().hash
        nouveau_bloc.miner_bloc(self.difficulte)
        self.chaine.append(nouveau_bloc)

    def valider_chaine(self):
        """Vérifie l'intégrité de la blockchain"""
        for i in range(1, len(self.chaine)):
            bloc_actuel = self.chaine[i]
            bloc_precedent = self.chaine[i-1]

            # Vérifier le hash du bloc
            if bloc_actuel.hash != bloc_actuel.calculer_hash():
                return False

            # Vérifier le lien avec le bloc précédent
            if bloc_actuel.hash_precedent != bloc_precedent.hash:
                return False

        return True

# Exemple d'utilisation
blockchain = Blockchain()

print("Création de la blockchain...")
blockchain.ajouter_bloc(Bloc("Transaction 1: Alice -> Bob 10€", ""))
blockchain.ajouter_bloc(Bloc("Transaction 2: Bob -> Charlie 5€", ""))

print(f"\nBlockchain valide : {blockchain.valider_chaine()}")

Caractéristiques de la blockchain

🔗

Immutabilité

Une fois ajoutées, les données ne peuvent plus être modifiées sans altérer toute la chaîne.

🌐

Décentralisation

Aucune autorité centrale, le réseau est distribué entre tous les participants.

👁️

Transparence

Toutes les transactions sont visibles et vérifiables par tous les participants.

🔐

Sécurité

Protection cryptographique et consensus distribué pour garantir l'intégrité.

---

💰 Applications et cryptomonnaies

### Domaines d'application

💳 Cryptomonnaies

Bitcoin, Ethereum, monnaies numériques décentralisées

📜 Contrats intelligents

Automatisation d'accords sans intermédiaire

🏥 Santé

Dossiers médicaux sécurisés et traçables

🗳️ Vote électronique

Systèmes de vote transparents et vérifiables

📦 Supply Chain

Traçabilité des produits de la production au consommateur

🎓 Certification

Diplômes et certifications infalsifiables

⚡ Défis de la blockchain :

• Consommation énergétique : Le minage nécessite beaucoup d'énergie
• Scalabilité : Limitation du nombre de transactions par seconde
• Régulation : Cadre juridique en évolution
• Adoption : Nécessité de former les utilisateurs

---

📚 Pour aller plus loin

🔗 Ressources complémentaires :

• Cryptool : Logiciel éducatif pour la cryptographie
• Python cryptography : Bibliothèque avancée
• OpenSSL : Outils cryptographiques en ligne de commande
• Blockchain.info : Explorateur de blockchain Bitcoin

---

✅ Points clés à retenir

1. César : Chiffrement par substitution simple, facilement cassable
2. Vigenère : Amélioration avec mot-clé, plus résistant
3. Hachage : Irréversible, utilisé pour l'intégrité et l'authentification
4. Blockchain : Registre distribué et immuable
5. Applications : De la sécurisation des mots de passe aux cryptomonnaies

🎓 Prochaine étape : Dans le cours B3.4, nous étudierons la sécurité des applications web et la protection des données.