IUT/2A/Cryptographie/tp/tp3/.ipynb_checkpoints/Untitled-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e4a99103-1fbd-43a9-9464-bb220e226097",
   "metadata": {},
   "source": [
    "# TP 3 : Chiffrement asymétrique El Gamal\n",
    "## Chiffrement d’El Gamal\n",
    "Le chiffrement d’El Gamal est un protocole de cryptographie asymétrique inventé par Taher El Gamal\n",
    "en 1984 et qui repose sur le problème du logarithme discret.\n",
    "## Génération des clefs.\n",
    "La première étape du schéma de chiffrement consiste à produire une paire de clefs : la clef publique,\n",
    "et la clef secrète (ou clé privée). La première servira à chiffrer les messages et la deuxième à les\n",
    "déchiffrer.\n",
    "Pour générer sa paire de clefs, il faut d’abord choisir un nombre premier p et un générateur g pour\n",
    "Z/pZ.\n",
    "Ensuite il faut choisir un élément s de Z/pZ qui constituera la clef privée, et calculer h = g\n",
    "s mod p.\n",
    "Pour terminer, la clé publique est (p, g, h).\n",
    "## Chiffrement\n",
    "Pour chiffrer un message M encodé comme un entier de Z/pZ avec la clé publique (p, g, h), il faut\n",
    "tirer au hasard un aléa r dans Z/pZ et calculer C1 = g\n",
    "r mod p et C2 = (M ·(h\n",
    "r mod p)) mod p.\n",
    "Ainsi le chiffré C est composé de ces deux nombres : C = (C1, C2).\n",
    "## Déchiffrement\n",
    "Ayant accès à C = (C1, C2) et à la clé privée s, pour déchiffrer il suffit de calculer :\n",
    "\u0010\n",
    "C2 × ((C1)\n",
    "s mod p)\n",
    "−1 mod p\n",
    "\u0011\n",
    "mod p\n",
    "pour retrouver le message M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "c5b14247-bb01-4d53-bfe9-a6794e1d083a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import randprime\n",
    "from sympy import mod_inverse\n",
    "from random import randint"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da5acb5b-c88f-4cf8-b77f-5730a2fb8b8b",
   "metadata": {},
   "source": [
    "# Exercice 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb40eddd-9d83-4866-a2fb-596c936b6c96",
   "metadata": {},
   "source": [
    "## (Génération des clefs). \n",
    "Écrivez une fonction Python3 Clefs(k) qui permet de générer\n",
    "une paire de clefs El Gamal, avec un module compris entre 2k et 2k+1 − 1.\n",
    "La taille compte ! Plus vos clés seront de grands nombres, plus elles seront sûres. Le « paramètre de\n",
    "sécurité » est donc le nombre de bits du module p, autrement dit son logarithme binaire k.\n",
    "Vous aurez peut-être l’usage de la fonction randprime de la bibliothèque sympy (éventuellement à\n",
    "installer en tapant pip install sympy dans un terminal) et de la fonction randint de la bibliothèque random. Pour calculer x\n",
    "n mod p vous devrez utiliser pow(x, n, mod=p) car (x**n)%p ne\n",
    "marche pas pour les grands nombres. Attention, ce n’est pas une fonction de la bibliothèque math ! !\n",
    "### 1. Choisissez comme module un nombre premier p au hasard compris entre 2k et 2k+1 − 1.\n",
    "### 2. Choisissez comme générateur un nombre g au hasard compris entre 2 et p − 1.\n",
    "Remarque : Votre « générateur » n’en est peut-être pas un. Pour gagner du temps, on ne\n",
    "vous demande pas de le vérifier : la procédure de chiffrement/déchiffrement marche encore,\n",
    "mais votre clé sera plus facile à casser, car il y aura plusieurs valeurs possibles pour s, en plus\n",
    "de celle qui sera vraiment votre clé secrète.\n",
    "### 3. Choisissez comme secret un nombre s au hasard compris entre 2 et p − 1.\n",
    "### 4. Calculez h."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "fc076bdc-53b4-4c7a-947e-93545a63cb81",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Clef(k):\n",
    "    p = randprime(2**k, 2**(k+1) - 1)\n",
    "    g = randint(2, p)\n",
    "    s = randint(2, p)\n",
    "    h = pow(g, s, mod=p)\n",
    "    return (p, g, h), s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "ccddb73a-53f9-45dc-9d0f-12ea0b7bc880",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((59, 59, 0), 2)\n"
     ]
    }
   ],
   "source": [
    "print(Clef(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dca8a06b-a782-42ef-ac24-bb7b448b2d39",
   "metadata": {},
   "source": [
    "# Exercice 2. \n",
    "## Écrivez une fonction Python3 Chiffrer(...) qui permet de chiffrer un nombre M avec le chiffrement d’El Gamal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "9bcdf40f-6aa0-47f3-aee7-efcd5b6bf1a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Chiffrer(M, p, g, h):\n",
    "    r = randint(0, p)\n",
    "    C1 = pow(g, r, mod=p)\n",
    "    C2 = (M * pow(h, r, mod=p))%p\n",
    "    return C1, C2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "e5abbe34-905f-4651-8744-952376af16b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Génération de clef : \n",
      "Clef public :  (1871, 1240, 1473)\n",
      "Clef privé :  1063\n",
      "Chiffrement de  1200 Soit un chiffré c =  (973, 292)\n"
     ]
    }
   ],
   "source": [
    "print(\"Génération de clef : \")\n",
    "public, prive = Clef(10)\n",
    "print(\"Clef public : \", public)\n",
    "print(\"Clef privé : \",  prive)\n",
    "M = 1200\n",
    "C = Chiffrer(M, public[0], public[1], public[2])\n",
    "print(\"Chiffrement de \", M, \"Soit un chiffré c = \", C)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "606ffacb-eb0d-4023-8c5f-86a885f5fc3f",
   "metadata": {},
   "source": [
    "# Exercice 3. \n",
    "## Écrivez une fonction Python3 Dechiffrer(...) qui permet de déchiffrer un chiffré (C1, C2) avec le chiffrement d’El Gamal.\n",
    "Vous pouvez calculer l’inverse de x modulo p (s’il existe) par pow(x, -1, p)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "1827a062-4875-411e-820b-6c040bd42a9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Dechiffrer(C1, C2, s, p):\n",
    "    M = (C2 * mod_inverse(pow(C1, s, mod=p), p))%p\n",
    "    return M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "9d49814a-be2f-4875-815d-296d08e74a1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Message à déchiffrer :  (973, 292)\n",
      "Resultat après déchiffrement :  1200\n"
     ]
    }
   ],
   "source": [
    "print(\"Message à déchiffrer : \", C)\n",
    "Md = Dechiffrer(C[0], C[1], prive, public[0])\n",
    "print(\"Resultat après déchiffrement : \", Md)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca4ddadd-1181-4b1d-a6a8-f50f4c53dc84",
   "metadata": {},
   "source": [
    "# Exercice 4. \n",
    "Fondamentalement, le chiffrement d’El Gamal s’applique à des nombres. Mais très souvent, les messages qu’on souhaite chiffrer sont plutôt des textes ! Pour chiffrer des textes, il faut donc passer par une étape préalable de numérisation des caractères qui le composent.\n",
    "### 1. Écrivez une fonction Python3 Encode(texte) qui convertit une chaîne de caractères texte en un nombre entier. Il y a plusieurs manières de faire cela, voici celle que nous proposons ici :\n",
    "(a) Chaque caractère est encodé par son code ASCII décimal, composé de 1, 2 ou 3 chiffres. Étant donné un caractère c, le code ASCII correspondant est obtenu par ord(c).  \n",
    "(b) Les codes ASCII des caractères sont transformés en str, puis ramenés sur 3 chiffres en ajoutant si nécessaire des 0 à gauche.   \n",
    "(c) Les chaînes représentant les codes ASCII sur 3 chiffres sont concaténées les unes à la suite des autres pour obtenir une seule (grande) chaîne, ensuite transformée en int.  \n",
    "### 2. Écrivez une fonction Python3 Decode(nombre) effectuant l’opération réciproque : étant donné un nombre entier nombre, retrouver la chaîne de caractères texte qu’il représente.\n",
    "Pour cela, utilisez la fonction chr. Étant un code ASCII donné num, le caractère associé est\n",
    "obtenu par chr(num).\n",
    "Pour récupérer les codes ASCII des différents caractères, vous voudrez peut-être utiliser le\n",
    "reste (%) et le quotient (//) de la division par 1000.\n",
    "### 3. Testez vos fonctions d’encodage/décodage. On doit avoir, pour tout message M :\n",
    "M=Decode(Encode(M))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "bcbf166a-3b1f-4610-91ad-f34c4489e53f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Encode(texte):\n",
    "    newTexte = \"\"\n",
    "    for i in range(len(texte)):\n",
    "        newTexte = newTexte + str(ord(texte[i])).zfill(3)\n",
    "    intTexte = int(newTexte)\n",
    "    return intTexte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "6aac494a-7bae-4bff-a054-9e8832bde008",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "69115115097105"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Encode(\"Essai\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "4986d5be-89c1-441c-8cfc-87e265998d16",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Decode(nb):\n",
    "    res = \"\"\n",
    "    while nb > 0 :\n",
    "        res = chr(nb % 1000) + res\n",
    "        nb = nb // 1000\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "30aa336c-5959-49d6-90b1-b57b5ed9fa92",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Essai'"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Decode(69115115097105)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "9f2678f3-8180-46c9-aba0-f9a975775a12",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1443295143187065358570471830895, 895427499536852088675129942696)"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Chiffrer(Encode(\"Yoloyolo boys\"), 2300342751692871968900072455807, 1945803074531676481815246424499, 150618869292435473863944805702)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e02cb23c-4b07-4d2f-a086-693fa11c5245",
   "metadata": {},
   "source": [
    "# Exercice 7 \n",
    "(Exponentielle).\n",
    "### 1. Écrire une fonction exp_basique(x,n,p) qui, pour trois entiers positifs x, n, p donnés en entrée, calcule de manière basique (sans utiliser la bibliothèque math) l’exponentielle modulaire x n mod p\n",
    "### 2. L’algorithme d’exponentielle rapide permet également de calculer le nombre x n mod p mais en utilisant l’algorithme récursif suivant :\n",
    "puissance(x, n) =\n",
    "\n",
    "\n",
    "\n",
    "x, si n = 1\n",
    "puissance(x\n",
    "2\n",
    ", n/2), si n est pair\n",
    "x × puissance(x\n",
    "2\n",
    ", (n − 1)/2), si n est impair  \n",
    "Écrire une fonction exp_rapide(x,n,p) implémentant cet algorithme.\n",
    "### 3. Calculer le nombre suivant, avec les deux méthodes :\n",
    "123456789123456789 (mod 987654321) = 598987215\n",
    "Que constatez-vous ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "5e226a8c-c067-4f5e-8ab6-3e698d540a7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def exp_basique(x, n, p):\n",
    "    return (x**n)%p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "7bf34597-1e83-4ba2-9a79-5d0b95aac962",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(exp_basique(973, 2, 1871))\n",
    "print(pow(973, 2, 1871))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74960463-b5c5-4bc2-951e-4f4de37a93a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def exp_rapide(x, n, p):\n",
    "    if(n = 1):\n",
    "        return x\n",
    "    if(n%2 = 0):\n",
    "        return puissance(x, n, p)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}