{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# \n", "\n", "\"Cryptographie" ], "id": "c9168a74-c0b3-4d5a-8b22-3ce1564ecaaf" }, { "cell_type": "markdown", "metadata": {}, "source": [ "# TP2. Chiffrement symétrique, oracles et cryptanalyse\n", "\n", "Dans ce TP nous travaillerons en Python 3, directement à l’intérieur de\n", "ce notebook jupyter.\n", "\n", "L’objectif de cette fiche est double :\n", "\n", "1. d’une part découvrir l’utilisation en pratique d’AES, des modes\n", " opératoires et du padding ;\n", "2. d’autre part comprendre pourquoi la brique de chiffrement symétrique\n", " ne suffit pas à assurer la confidentialité d’un protocole de\n", " communication.\n", "\n", "Pour illustrer le second point, nous revisitons l’attaque du *padding\n", "CBC* vue en cours ainsi que l’attaque *chopchop* contre le protocole WEP\n", "de chiffrement de réseau sans fil.\n", "\n", "Nous avons choisi d’utiliser la bibliothèque\n", "[PyCryptodome](http://www.pycryptodome.org/). Pour rejouer cette fiche\n", "en dehors du TP, il convient d’installer une version récente de\n", "[PyCryptodome](http://www.pycryptodome.org/) sur votre système." ], "id": "aef587a8-18c7-46ba-8d14-3c769a5b4f06" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Échauffement : bytes, XOR, AES, CBC/CTR et padding" ], "id": "9da26e96-4b7b-4bbf-bbbb-a4b9379add71" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Objectifs — Partie 1 (≈ 30 min)\n", " \n", "
" ], "id": "b7624384-5612-496e-b878-bafe8b8057f4" }, { "cell_type": "markdown", "metadata": {}, "source": [ "En Python 3, les séquences d’octets sont représentées par le type\n", "`bytes` lorsqu’elles ne sont pas modifiables (comme des chaînes de\n", "caractères) et par le type `bytearray` lorsqu’elles sont modifiables\n", "(comme des listes). Le passage d’une chaîne de caractère à une séquence\n", "d’octets prend en compte le codage des caractères (par défaut on suppose\n", "que vous utilisez UTF-8 mais des arguments optionnels permettent de\n", "préciser autre chose)." ], "id": "eeb427fe-91b4-404e-8ca2-29fa26d59b76" }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "s = \"L'éléphant se dandine sur le toit.\" 34\n", "b = b\"L'\\xc3\\xa9l\\xc3\\xa9phant se dandine sur le toit.\" 36\n", "x = b'\\x00\\x00\\x00\\x00\\x00'\n", "y = b'ABCD'\n", "z = bytearray(b'AbCD')\n", "t = 'AbCD'\n", "[65, 98, 67, 68]" ] } ], "source": [ "s = \"L'éléphant se dandine sur le toit.\"\n", "print(\"s =\", repr(s), len(s))\n", "b = s.encode()\n", "print(\"b =\", repr(b), len(b))\n", "x = bytes(5)\n", "print(\"x =\", repr(x))\n", "y = bytes([65, 66, 67, 68])\n", "print(\"y =\", repr(y))\n", "z = bytearray(y)\n", "z[1] += 32\n", "print(\"z =\", repr(z))\n", "t = z.decode()\n", "print(\"t =\", repr(t))\n", "l = list(z)\n", "print(l)" ], "id": "3f4fc87a" }, { "cell_type": "markdown", "metadata": {}, "source": [ "La bibliothèque `Crypto` fourni une fonction très pratique pour\n", "appliquer un masque sur une séquence d’octets." ], "id": "df8bbe0b-de7f-450c-b63a-7d3e222f1b56" }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "b'lapin' ⊕ b'poule' = b'\\x1c\\x0e\\x05\\x05\\x0b'\n", "b'\\x1c\\x0e\\x05\\x05\\x0b' ⊕ b'poule' = b'lapin'" ] } ], "source": [ "from Crypto.Util.strxor import strxor\n", "\n", "m = b\"lapin\"\n", "k = b\"poule\"\n", "c = strxor(m, k)\n", "print(m, \"⊕\", k, \"=\", c)\n", "s = strxor(c, k)\n", "print(c, \"⊕\", k, \"=\", s)" ], "id": "5f30a0c5" }, { "cell_type": "markdown", "metadata": {}, "source": [ "✏️✏️✏️ **Question 1.** Déchiffrer le message `l` ci-dessous qui a été\n", "chiffré par le chiffrement du XOR avec la clé `CAKE`." ], "id": "26090fdc-7d19-4184-9f3b-e504bf90cf4e" }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "l = [1, 51, 42, 51, 44, 109, 107, 51, 44, 52, 56, 101, 48, 32, 61, 32, 57, 97, 62, 49, 42, 45, 34, 54, 38, 51, 107, 41, 38, 97, 40, 45, 42, 39, 45, 55, 38, 44, 46, 43, 55, 97, 59, 36, 49, 97, 51, 42, 49, 97, 46, 43, 99, 17, 50, 49, 43, 46, 37, 101, 98]" ], "id": "af40968c" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il est temps de lire un peu de documentation avant de chiffrer des\n", "messages :\n", "\n", "1. [Crypto.Cipher](https://www.pycryptodome.org/src/cipher/cipher)\n", " permet de manipuler les briques de chiffrement symétrique comme\n", " `AES` en précisant le mode opératoire ;\n", "2. [Crypto.Util.Padding](https://www.pycryptodome.org/src/util/util.html#crypto-util-padding-module)\n", " permet le bourrage réversible des séquences d’octet pour obtenir des\n", " séquences de longueur multiple de la taille d’un bloc ;\n", "3. [Crypto.Random](https://www.pycryptodome.org/src/random/random.html)\n", " permet de générer des séquences pseudo-aléatoires de qualité\n", " cryptographique.\n", "\n", "Voici comment chiffrer un message avec une clé et un IV aléatoire :" ], "id": "22afe7e0-f232-418a-9e72-1f2f71b089e0" }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "c = b'\\xf6\\xad\\xa9\\x91!\\xc2=\\xf8&\\xc3\\x0e\\x01AD:>\\xa2\\xd1\\x92\\x11q\"6\\xcb\\x1f\\xfc\\\\\\xdf%\\x1d\\xfdG\\x08\\xbe\\x16\\x1c\\x01\\xfd\\xd2\\x8dD\\x9f\\x9f\\xd3\\xcd]\\xa0la!\\xf2\"\n", "e = strxor(c, d)\n", "print(repr(e))" ], "id": "3ecc28a9" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Attaque padding CBC" ], "id": "8728f9b9-2401-4013-8194-8a21c9dc0817" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Objectifs — Partie 2 (≈ 1 h)\n", " \n", "
" ], "id": "7d6b75ce-89d9-42e4-8702-dcef80161e03" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Le code ci-dessous reproduit le protocole étudié en cours (l’envoi du\n", "message en moins) :\n", "\n", "- `alice` chiffre le message à envoyer à l’aide d’AES-256-CBC après\n", " avoir appliqué le bourrage et retourne la concaténation de l’IV et\n", " du message ainsi chiffré ;\n", "- `bob` déchiffre le message reçu grâce à l’IV, applique le débourrage\n", " et retourne le message déchiffré ou `None` si le bourrage est\n", " incorrect ;\n", "- `oracle` permet de savoir si `bob` serait capable ou non de\n", " déchiffrer le message (c’est l’équivalent du message ACK/NACK du\n", " cours).\n", "\n", "Le but de l’exercice est d’écrire une fonction `attaque(c)` capable de\n", "déchiffrer tout message `c` obtenu en appelant `alice(m)` pour un\n", "certain `m`. Cette fonction `attaque` n’a pas le droit d’utiliser la clé\n", "`k` mais elle peut appeler la fonction `oracle` autant de fois qu’elle\n", "le souhaite." ], "id": "f477966d-b844-4af4-8421-95a882bf388e" }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "key = get_random_bytes(32)\n", "\n", "\n", "def alice(m):\n", " p = pad(m, 16)\n", " cipher = AES.new(key, AES.MODE_CBC)\n", " c = cipher.iv + cipher.encrypt(p)\n", " return c\n", "\n", "\n", "def bob(m):\n", " iv = m[:16]\n", " c = m[16:]\n", " cipher = AES.new(key, AES.MODE_CBC, iv=iv)\n", " p = cipher.decrypt(c)\n", " try:\n", " m = unpad(p, 16)\n", " return m\n", " except ValueError:\n", " return None\n", "\n", "\n", "def oracle(m):\n", " return bob(m) is not None" ], "id": "4486e21f" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Voici un exemple d’utilisation des fonctions `alice`, `bob` et `oracle`\n", ":" ], "id": "36711f83-fa1f-498f-86c7-6aff8718c12a" }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "pad(m) = b\"Coucou c'est moi !\\x0e\\x0e\\x0e\\x0e\\x0e\\x0e\\x0e\\x0e\\x0e\\x0e\\x0e\\x0e\\x0e\\x0e\"\n", "c = b'I\\x92c\\xbe\\xca\\xf4\\xcb\\x85\\xdb\\xb7s\\xa6\\x13B\\xc4\\xd4\\xba\\xa5\\xa5b\\xd1\\x15\\x89G\\x99\\x1f\\xb8N\\xfb\\x91\\xd9wR\\x90\\xfa\\x8fF\\xae\\x15a\\xc6\\xd7\\x08\\xc3Ps|\\x13' (longueur : 3 blocs dont IV)\n", "oracle(c) = True\n", "bob(c) = b\"Coucou c'est moi !\"\n", "oracle(d) = False\n", "bob(d) = None" ] } ], "source": [ "m = b\"Coucou c'est moi !\"\n", "print(\"pad(m) =\", pad(m, 16))\n", "c = alice(m)\n", "print(\"c =\", c, \"(longueur :\", len(c) // 16, \"blocs dont IV)\")\n", "print(\"oracle(c) =\", oracle(c))\n", "print(\"bob(c) =\", bob(c))\n", "d = strxor(c, bytes(len(c) - 3) + b\"XXX\")\n", "print(\"oracle(d) =\", oracle(d))\n", "print(\"bob(d) =\", bob(d))" ], "id": "b6df1afb" }, { "cell_type": "markdown", "metadata": {}, "source": [ "En mode CBC, le déchiffrement du ième bloc $C_i$ chiffré d’un message en\n", "clair $M_i$ nécessite de connaître uniquement la clé $K$ et le (i-1)ème\n", "bloc chiffré $C_{i-1}$ (avec la convention $C_0=\\operatorname{IV}$) : $$\n", "M_i = D_K(C_i) \\oplus C_{i-1}\n", "$$\n", "\n", "Dans la suite on se concentre donc sur le déchiffrement d’un unique bloc\n", "$C$ à partir de son IV $I$ (la méthode se généralise ensuite à tout bloc\n", "$C_i$ avec l’IV $C_{i-1}$).\n", "\n", "Si, au lieu de transmettre $I\\cdot C$ à l’oracle, on lui transmet\n", "$(I\\oplus\\Delta)\\cdot C$, l’oracle va tester si $M\\oplus\\Delta$ possède\n", "un bourrage valide. En effet : $$\n", "M \\oplus \\Delta = (D_K(C) \\oplus I) \\oplus \\Delta = D_K(C) \\oplus (I \\oplus \\Delta)\n", "$$\n", "\n", "Un message possède un bourrage valide si et seulement si il termine par\n", "la séquence $k k \\cdots k$ qui répète $k$ fois une certaine valeur $k$.\n", "\n", "En particulier lorsque $I\\oplus \\Delta$ termine par la valeur 1,\n", "l’oracle valide le message. Il suffit pour cela de modifier uniquement\n", "le dernier octet de $I$ en trouvant le bon élément parmi les 256\n", "possible.\n", "\n", "✏️✏️✏️ **Question 4.** Écrire une fonction `flip(iv,j)` qui retourne le\n", "bloc `iv` reçu en entrée dans lequel le dernier octet a été remplacé par\n", "son XOR avec l’entier `j` (c’est à dire par `iv[-1] ^ j`). Utiliser\n", "cette fonction pour afficher parmi les 256 valeurs possibles pour `j`\n", "celles pour lesquels l’oracle valide `flip(iv,j) + b`. En déduire le\n", "dernier caractère du déchiffrement de `b`." ], "id": "0b933fc7-5e34-4bf1-9418-845da9b3ff39" }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "iv = c[:16]\n", "b = c[16:32]\n", "\n", "\n", "def flip(c, j):\n", " # TODO\n", " pass\n", "\n", "\n", "for j in range(256):\n", " # TODO\n", " pass" ], "id": "c1cd2f3a" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Une fois qu’on a trouvé le dernier caractère en clair de $M$, on sait\n", "comment modifier le dernier octet de $I$ pour que $I\\oplus\\Delta$\n", "termine par la valeur $2$. Il suffit d’utiliser l’oracle pour trouver la\n", "modification (parmi 256) à appliquer à l’avant-dernier octet de $I$ pour\n", "que $I\\oplus\\Delta$ termine par le padding valide $22$. Et on itère !\n", "\n", "✏️✏️✏️ **Question 5.** Écrire une fonction `gnapgnap(iv,b)` qui\n", "déchiffre le bloc `b` à l’aide de l’oracle. En déduire une fonction\n", "`attaque(c)` qui déchiffre complétement un message `c` produit par un\n", "certain `alice(m)` sans utiliser la clé." ], "id": "05905911-d0ea-4018-9943-dc4f3ab53ac9" }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "None" ] } ], "source": [ "def gnapgnap(iv, b):\n", " # TODO\n", " pass\n", "\n", "\n", "print(gnapgnap(iv, b))" ], "id": "40e992c6" }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "None" ] } ], "source": [ "def attaque(c):\n", " # TODO\n", " pass\n", "\n", "\n", "print(attaque(c))" ], "id": "2fe6ae22" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Attaque ChopChop contre WEP" ], "id": "6a0b4a8d-b70d-4bc1-816b-55cf7c0ec14d" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Objectifs — Partie 3 (Bonus)
\n", " Cette partie est optionnelle. Ne la commencez qu’une fois la partie 1 et la partie 2 terminées.\n", " \n", "
" ], "id": "419e2047-cbbf-46b4-82f0-93efe790bd22" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Le (désuet) protocole WEP chiffre les trames Wifi (IEEE 802.11) à l’aide\n", "de l’algorithme de chiffrement par flot RC4. Le contrôle d’intégrité est\n", "assuré par l’utilisation d’un checksum CRC32. Pour transmettre un\n", "message $M$ avec la clé secrète $K$ de 40 ou 104 bits, un IV aléatoire\n", "de 24 bits $\\mbox{IV}$ est généré, le CRC32 $\\operatorname{icv}(M)$ est\n", "concaténé au message $M$ et l’ensemble est masqué avec le flot RC4\n", "généré par la concaténation de $\\mbox{IV}$ et $K$ : $$\n", "C = (M \\cdot \\operatorname{icv}(M)) \\oplus \\operatorname{RC4}(\\mbox{IV} \\cdot K)\n", "$$ La paire $\\mbox{IV}\\cdot C$ est alors transmise sur le réseau sans\n", "fil.\n", "\n", "À la réception d’un message $\\mbox{IV}\\cdot C$ on calcule : $$\n", "M' \\cdot J = C \\oplus \\operatorname{RC4}(\\mbox{IV} \\cdot K)\n", "$$ Si $J = \\operatorname{icv}(M')$ alors le message $M'$ est accepté.\n", "Sinon le message est rejetté silencieusement (pas d’acquittement\n", "négatif).\n", "\n", "Ce protocole a de nombreux défauts et il est possible aujourd’hui de\n", "trouver la clé d’un réseau WEP en moins de 60s en utilisant des\n", "faiblesses statistiques de l’algorithme RC4. Nous allons nous intéresser\n", "ici à une attaque apparue à partir de 2004 et connue sous le nom\n", "*ChopChop*. Cette attaque utilise les propriétés de linéarité de CRC32\n", "pour s’en servir comme oracle pour déchiffrer un message (et donc\n", "obtenir la séquence $\\operatorname{RC4}(\\mbox{IV}\\cdot K)$ de longueur\n", "$|M|+4$).\n", "\n", "Le code ci-dessous met en œuvre le calcul d’$\\operatorname{icv}(M)$ :" ], "id": "0c1ad9d4-5559-4fec-9581-2e2190b304ae" }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "crc_tab = [0] * 256\n", "for i in range(256):\n", " r = i\n", " for j in range(8):\n", " if r & 1:\n", " r = (r >> 1) ^ 0xEDB88320\n", " else:\n", " r >>= 1\n", " crc_tab[i ^ 0xFF] = r ^ 0xFF000000\n", "\n", "\n", "def crc32(buf, crc=0):\n", " for k in buf:\n", " crc = (crc >> 8) ^ crc_tab[(crc & 0xFF) ^ k]\n", " return crc\n", "\n", "\n", "def lsb(x, k=4):\n", " r = []\n", " for i in range(k):\n", " r.append(x & 0xFF)\n", " x >>= 8\n", " return bytes(r)\n", "\n", "\n", "def icv(buf):\n", " return lsb(crc32(buf))" ], "id": "d0f6b491" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Nous allons reproduire la même attaque en remplaçant RC4 par\n", "AES-256-CTR, qui est aussi un chiffrement par flot. Le code ci-dessous\n", "met en œuvre ce protocole sous la forme de deux fonctions `alice` et\n", "`bob` et une fonction `oracle`." ], "id": "41a2293b-0f08-4838-8506-9321f85b64b1" }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "def nonce():\n", " return get_random_bytes(8)\n", "\n", "\n", "def alice(m):\n", " no = nonce()\n", " mc = m + icv(m)\n", " ci = AES.new(key, AES.MODE_CTR, nonce=no)\n", " return no + ci.encrypt(mc)\n", "\n", "\n", "def bob(c):\n", " no = c[:8]\n", " ci = AES.new(key, AES.MODE_CTR, nonce=no)\n", " mc = ci.decrypt(c[8:])\n", " ic = mc[-4:]\n", " m = mc[:-4]\n", " if icv(m) == ic:\n", " return m\n", " else:\n", " return None\n", "\n", "\n", "def oracle(c):\n", " return bob(c) is not None" ], "id": "5c1ededa" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Voici un exemple d’utilisation des fonctions `alice`, `bob` et `oracle`\n", ":" ], "id": "acee0ac1-cc86-4a2d-a2d9-25913ab82eca" }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "c = b'\"Y\\x83\\xe7\\x83\\xd4z\\x8e\\xca\\x83\\xdd\\xc6\\x0e\\xe8\\x9e\"\\x16\\xb3\\xe0\\x03,g7\\xda\\xc9\\xf0\\x80@\\xb7w*<\\xcf\\xb2\\xf9'\n", "oracle(c) = True\n", "bob(c) = b'Tranchez leur la tete !'\n", "oracle(d) = False\n", "bob(d) = None" ] } ], "source": [ "m = b\"Tranchez leur la tete !\"\n", "c = alice(m)\n", "print(\"c =\", c)\n", "print(\"oracle(c) =\", oracle(c))\n", "print(\"bob(c) =\", bob(c))\n", "d = strxor(c, b\"XXX\" + bytes(len(c) - 3))\n", "print(\"oracle(d) =\", oracle(d))\n", "print(\"bob(d) =\", bob(d))" ], "id": "4f916e23" }, { "cell_type": "markdown", "metadata": {}, "source": [ "L’attaque consiste à transformer le chiffrement\n", "$C = C_1 C_2 \\cdots C_{n+4}$ d’un message $M = M_1 M_2 \\cdots M_n$ en un\n", "chiffré valide $D = D_1 D_2 \\cdots D_{n+3}$ du message tronqué\n", "$M' = M_1 M_2 \\cdots M_{n-1}$ en utilisant l’oracle pour faire un choix\n", "parmi 256 (comme dans l’attaque de l’exercice précédent).\n", "\n", "Notons $K = K_1 K_2 \\cdots K_{n+4}$ le masque,\n", "$I = \\operatorname{icv}(M)$ et $J = \\operatorname{icv}(M')$. Alors on a\n", "les égalités suivantes : $$\n", "\\begin{array}{cccccccccc}\n", "& M_1 & M_2 & \\cdots & M_{n-1} & M_n & I_1 & I_2 & I_3 & I_4\\\\\n", "\\oplus & K_1 & K_2 & \\cdots & K_{n-1} & K_n & K_{n+1} & K_{n+2} & K_{n+3} & K_{n+4}\\\\\\hline\n", "& C_1 & C_2 & \\cdots & C_{n-1} & C_n & C_{n+1} & C_{n+2} & C_{n+3} & C_{n+4}\n", "\\end{array}\n", "$$ et $$\n", "\\begin{array}{ccccccccccc}\n", "& M_1 & M_2 & \\cdots & M_{n-1} & J_1 & J_2 & J_3 & J_4 & \\phantom{I_4}\\\\\n", "\\oplus & K_1 & K_2 & \\cdots & K_{n-1} & K_n & K_{n+1} & K_{n+2} & K_{n+3} & \\phantom{K_{n+4}}\\\\\\hline\n", "& D_1 & D_2 & \\cdots & D_{n-1} & D_n & D_{n+1} & D_{n+2} & D_{n+3} & \\phantom{D_{n+4}}\n", "\\end{array}\n", "$$\n", "\n", "Les $n-1$ premières valeurs de $D_i$ sont égales aux $C_i$. Notons $X$\n", "la modification à apporter à $C_n$ pour obtenir $D_n$, *i.e.*\n", "$X = C_n \\oplus D_n = M_n \\oplus J_1$.\n", "\n", "✏️✏️✏️ **Question 6.** En étudiant le code de CRC32, montrer comment\n", "calculer $D_{n+1}$, $D_{n+2}$, $D_{n+3}$ et $K_{n+4}$ à partir de $X$.\n", "On pourra commencer par chercher comment calculer $I$ à partir de $J$.\n", "\n", "✏️✏️✏️ **Question 7.** Écrire une fonction `chop(c)` qui à partir d’un\n", "message chiffré $C$ retourne une paire `(d,x)` où `d` est le chiffré du\n", "message tronqué $D$ et `k` le dernier octet du masque $K_{n+4}$." ], "id": "bb1ab3a3-a14e-45ae-aa02-f610058c1417" }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "None" ] } ], "source": [ "def chop(c):\n", " # TODO\n", " pass\n", "\n", "\n", "print(chop(c))" ], "id": "ca5d93e4" }, { "cell_type": "markdown", "metadata": {}, "source": [ "✏️✏️✏️ **Question 8.** En déduire une fonction `chopchop(c)` qui\n", "déchiffre un message chiffré généré par `alice(m)` sans utiliser la clé\n", "secrète mais en utilisant l’oracle." ], "id": "ada6a9cb-2bdf-45b5-b639-6a63d5ed9484" }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "None" ] } ], "source": [ "def chopchop(c):\n", " # TODO\n", " pass\n", "\n", "\n", "print(chopchop(c))" ], "id": "85692df2" } ], "nbformat": 4, "nbformat_minor": 5, "metadata": { "kernelspec": { "name": "python3", "display_name": "Python 3 (ipykernel)", "language": "python" } } }