La cryptographie est la science de la communication sécurisée, qui implique le chiffrement et le déchiffrement des données. Voici quelques termes couramment utilisés :
1️⃣ Chiffrement : le processus de conversion de données claires en données chiffrées à l'aide d'un algorithme et d'une clé.
2️⃣ Déchiffrement : le processus inverse du chiffrement, qui consiste à convertir les données chiffrées en données claires à l'aide de la clé appropriée.
3️⃣ Clé : une valeur utilisée par l'algorithme de chiffrement pour transformer les données claires en données chiffrées et vice versa.
4️⃣ Cryptographie symétrique : un système de chiffrement où la même clé est utilisée pour le chiffrement et le déchiffrement.
5️⃣ Cryptographie asymétrique : un système de chiffrement où une paire de clés distinctes (clé publique et clé privée) est utilisée pour le chiffrement et le déchiffrement.
2. Chiffrement de César
Le chiffrement de César est une méthode de chiffrement par substitution simple, où chaque lettre du texte clair est décalée d'un certain nombre de positions dans l'alphabet. Voici un exemple d'implémentation en Python du chiffrement de César :
L'AES (Advanced Encryption Standard) est un algorithme de chiffrement symétrique largement utilisé. Il utilise une clé secrète pour chiffrer et déchiffrer les données. Voici un exemple d'implémentation en Python utilisant la bibliothèque cryptography pour AES :
# AES Simplifié (non complet, juste à des fins éducatives)
# Fonction AddRoundKey (simplifiée) def add_round_key(state, key): for i in range(4): for j in range(4): state[i][j] ^= key[i][j]
# Fonction de chiffrement AES simplifiée def aes_encrypt(plaintext, key): state = [[plaintext[i][j] for j in range(4)] for i in range(4)] add_round_key(state, key)
for _ in range(9): # 9 Rounds sub_bytes(state) shift_rows(state) # MixColumns(state) # Non implémenté pour la simplicité add_round_key(state, key) # Clé de round simplifiée
sub_bytes(state) shift_rows(state) add_round_key(state, key) # Clé finale
Le RSA (Rivest-Shamir-Adleman) est un algorithme de chiffrement asymétrique largement utilisé pour le chiffrement et la signature numérique. Il utilise une paire de clés distinctes : une clé publique pour le chiffrement et une clé privée pour le déchiffrement. Il repose sur la difficulté de factoriser de grands nombres premiers.
4.1 Génération des Clés 1. Choisir deux grands nombres premiers \( p \) et \( q \). 2. Calculer \( n = p \times q \). 3. Calculer \( \phi(n) = (p-1)(q-1) \). 4. Choisir un entier \( e \) tel que \( 1 < e < \phi(n) \) et \( \text{pgcd}(e, \phi(n)) = 1 \). 5. Calculer \( d \) tel que \( d \times e \equiv 1 \mod \phi(n) \). 4.2 Chiffrement Pour chiffrer un message \( m \): \[ c \equiv m^e \mod n \] 4.3 Déchiffrement Pour déchiffrer le message chiffré \( c \): \[ m \equiv c^d \mod n \]Voici une implémentation basique de l'algorithme RSA :
def gcd(a, b): while b != 0: a, b = b, a % b return a
def mod_inverse(e, phi): for d in range(1, phi): if (e * d) % phi == 1: return d return None
def rsa_keygen(p, q): n = p * q phi = (p - 1) * (q - 1)
e = 65537 # Choix commun pour e while gcd(e, phi) != 1: e += 2 # Incrémenter jusqu'à trouver un e valide
Ceci conclut notre cours sur la sécurisation des communications, en mettant l'accent sur la cryptographie et le chiffrement de César, ainsi que des exemples de code Python pour chaque concept.
Écrivez une fonction en Python qui utilise l'algorithme AES (Advanced Encryption Standard) pour chiffrer et déchiffrer un message en utilisant une clé symétrique.
from Crypto.Cipher import AES from Crypto.Util.Padding import pad, unpad from Crypto.Random import get_random_bytes
# Exemple d'utilisation cle = get_random_bytes(16) # Génération d'une clé AES de 128 bits (16 octets) message = b"Bonjour, ceci est un message secret."
Écrivez une fonction en Python qui génère automatiquement une clé aléatoire pour l'algorithme AES.
import random
def generate_aes_key(): # Générer 16 octets aléatoires pour la clé AES de 128 bits key = bytearray(random.getrandbits(8) for _ in range(16)) return key
Implémentez une fonction pour générer une paire de clés RSA : une clé publique et une clé privée.
import random
def generer_cles_RSA(taille): p = nombre_premier(taille) q = nombre_premier(taille)
n = p * q phi_n = (p - 1) * (q - 1) e = choisir_exposant_chiffrement(phi_n) d = inverser_modulo(e, phi_n)
return (n, e), (n, d)
def nombre_premier(taille): # Génère un nombre aléatoire de la taille spécifiée nombre = random.getrandbits(taille)
# Vérifie si le nombre généré est premier while not est_premier(nombre): nombre = random.getrandbits(taille)
return nombre
def est_premier(nombre): if nombre < 2: return False if nombre == 2: return True if nombre % 2 == 0: return False for i in range(3, int(nombre**0.5) + 1, 2): if nombre % i == 0: return False return True
def choisir_exposant_chiffrement(phi_n): e = random.randint(2, phi_n) while pgcd(e, phi_n) != 1: e = random.randint(2, phi_n) return e
def pgcd(a, b): while b != 0: a, b = b, a % b return a
def inverser_modulo(a, m): r, r_prec = m, a s, s_prec = 0, 1
while r != 0: quotient = r_prec // r r_prec, r = r, r_prec - quotient * r s_prec, s = s, s_prec - quotient * s
if r_prec > 1: raise ValueError("L'inverse modulo n'existe pas.") if s_prec < 0: s_prec += m
return s_prec
Exercice 5: Chiffrement et déchiffrement RSA
Implémentez les fonctions de chiffrement et de déchiffrement RSA.
def chiffrer_RSA(message, cle_publique): n, e = cle_publique
m = convertir_message_entier(message) c = pow(m, e, n)
return c
def dechiffrer_RSA(message_chiffre, cle_privee): n, d = cle_privee
m = pow(message_chiffre, d, n) message = convertir_entier_message(m)
return message
def convertir_message_entier(message): # Convertit chaque caractère du message en valeur entière selon un encodage spécifique entier = 0 for caractere in message: entier = (entier << 8) + ord(caractere) return entier
def convertir_entier_message(entier): # Convertit la valeur entière en un message lisible en inversant l'encodage spécifique message = "" while entier > 0: caractere = chr(entier & 0xFF) message = caractere + message entier >>= 8 return message
Plongez dans l'univers fascinant des suites numériques, où chaque terme révèle des patterns surprenants et des applications pratiques dans les mathématiques et au-delà.
Découvrez comment les fonctions tissent des liens entre les nombres et les concepts, transformant des idées abstraites en outils puissants pour résoudre des problèmes du quotidien.
Éducation
