{
 "metadata": {
  "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.7.3-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python37364bit201329ed7ee849b4a43ad7bb610f5989",
   "display_name": "Python 3.7.3 64-bit"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# SÉCURISATION DES COMMUNICATIONS \n",
    "\n",
    "# Un exemple de chiffrement symétrique : le chiffrement XOR\n",
    "\n",
    "On souhaite chiffrer le message suivant par la technique du OU Exclusif :\n",
    "\n",
    "\"La cigale ayant chanté tout l'été se trouva fort dépourvue quand la bise fut venue...\"\n",
    "\n",
    "## 1- Rappel sur le OU Exclusif (XOR) :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 1 : Etude du OU Exclusif\n",
    "# en Python le OU Exclusif se note : ^\n",
    "# Compléter le code pour afficher la table de vérité du OU Exclusif :\n",
    "print(\"0 ^ 0 = \", 0 ^ 0)\n",
    "???\n",
    "???\n",
    "???\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 2 : OU Exclusif entre deux octets \n",
    "# Afficher en binaire le résultat du OU Exclusif entre 11010001 et 01101001 :\n",
    "???"
   ]
  },
  {
   "source": [
    "## 2- Chifrement / Déchiffrement d'un message d'un octet par une clé d'un octet\n",
    "\n",
    "### 2.1- Une fonction de chiffrement :\n",
    "\n",
    "Ecrire le code d'une fonction **chiffrer(oct_msg, oct_cle)** qui renvoie le chiffrement par le OU Exclusif de *oct_msg* par la clé *oct_cle* :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 3 : Chiffrement EXOR \n",
    "def chiffrer(oct_msg, oct_cle):\n",
    "    \"\"\" fonction qui renvoie le chiffrement d'oct_mess par oct_cle selon la méthode du OU Exclusif\n",
    "    :param oct_msg: (int) un entier sur 1 octet (le message à chiffrer)\n",
    "    :param oct_cle: (int) un entier sur 1 octet (la clé de chiffrement)\n",
    "    :return: (int) le résultat oct_mess ^oct_cle\n",
    "    :CU: oct_msg et oct_cle compris entre 0 et 255\n",
    "    \"\"\"\n",
    "    return ???\n",
    "\n",
    "# test de la fonction avec entrées et affichage du résultat en binaire :\n",
    "???\n",
    "\n",
    "# test de la fonction avec entrées et affichage du résultat en décimal :\n",
    "???\n"
   ]
  },
  {
   "source": [
    "### 2.2- La fonction de déchiffrement :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 4 : Déchiffrement EXOR \n",
    "def dechiffrer(oct_msg, oct_cle):\n",
    "    \"\"\" fonction qui renvoie le dechiffrement d'oct_mess par oct_cle selon la méthode du OU Exclusif\n",
    "    :param oct_msg: (int) un entier sur 1 octet (le message à chiffrer)\n",
    "    :param oct_cle: (int) un entier sur 1 octet (la clé de chiffrement)\n",
    "    :return: (int) le résultat oct_mess ^oct_cle\n",
    "    :CU: oct_msg et oct_cle compris entre 0 et 255\n",
    "    \"\"\"\n",
    "    return ???\n",
    "\n",
    "# Test de la fonction de déchiffrement :\n",
    "???\n",
    "\n",
    "# Test : montrer que les fonctions chiffrer() et déchiffrer(), bien qu'identiques sont inverses l'une de l'autre :\n",
    "???\n"
   ]
  },
  {
   "source": [
    "## 3- Chiffrement / déchiffrement de texte par la méthode XOR :\n",
    "\n",
    "On souhaite maintenant chiffrer (puis ensuite déchiffrer) une lettre par une clé (qui sera elle même une lettre )\n",
    "\n",
    "### 3.1- Test de la fonction chiffrer() précédente :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 5 : On veut essayer la fonction chiffrer() en prenant une lettre pour le message (par exemple 'M') et une lettre pour la clé (par exemple 'C')\n",
    "\n",
    "print(chiffrer('M', 'C'))\n",
    "\n",
    "# Pourquoi obtient-on une erreur ?"
   ]
  },
  {
   "source": [
    "### 3.2- Retour sur le code ASCII :\n",
    "\n",
    "On rappelle ci-dessous les 128 caractères de base de la table ASCII, suivis de la table des caractères étendus :\n",
    "\n",
    "![title](images/asciifull.gif)\n",
    "![title](images/ascii_etendu.gif)\n",
    "\n",
    "Cela nous rappelle que tous ces caractères simples sont codés sur un octet\n",
    "\n",
    "En Python on dispose de deux instructions pour réaliser les conversions *caractère* <-> * point de code Unicode* :\n",
    " - chr()\n",
    " - ord()\n",
    "\n",
    "### 3.3- Une fonction de chiffrement de lettre :\n",
    "\n",
    "Ecrire une fonction **chiffrer_lettre(lettre, cle)** comme définie dans la docstring ci-dessous :\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 6 :\n",
    "def chiffrer_lettre(let_msg, let_cle):\n",
    "    \"\"\" fonction qui renvoie sous la forme d'un caractère ASCII le chiffrement \n",
    "    du caractère *let_msg* par le caractère *let_cle*\n",
    "    :param let_msg: (str) une lettre à chiffrer\n",
    "    :param let_cle: (str) la lettre servant de clé de chiffrement\n",
    "    :return: (str) le caractère représentant le chiffrement de let_msg\n",
    "    :CU: let_msg et let_cle sont des caractères de la table ASCII complète\n",
    "    \"\"\"\n",
    "    return ???\n",
    "\n",
    "# test de la fonction :\n",
    "print(chiffrer_lettre('M', 'C'))\n",
    "\n"
   ]
  },
  {
   "source": [
    "### 3.4- La fonction de déchiffrement :\n",
    "\n",
    "Ecrire la fonction de déchiffrement d'une lettre par la lettre clé. \n",
    "\n",
    "On vérifiera que le déchiffrement :\n",
    " - redonne la même lettre qu'avant chiffrement si la clé est la même pour les deux opérations\n",
    " - que le déchiffrement est erroné si la clé utlisée lors du déchiffrement n'est pas la bonne"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 7 :\n",
    "def dechiffrer_lettre(let_msg, let_cle):\n",
    "    \"\"\" fonction qui déchiffre par la méthode XOR la lettre reçue let_msg par la letre clé let_cle\n",
    "    :param let_msg: (str) une lettre à déchiffrer\n",
    "    :param let_cle: (str) la lettre servant de clé de chiffrement\n",
    "    :return: (str) le caractère représentant le chiffrement de let_msg\n",
    "    :CU: let_msg et let_cle sont des caractères de la table ASCII complète\n",
    "    \"\"\"\n",
    "    return ???\n",
    "\n",
    "# tests de la fonction (voir texte ci-dessus) :\n",
    "\n",
    "\n"
   ]
  },
  {
   "source": [
    "## 4- Chiffrement / Déchiffrement d'un texte \n",
    "\n",
    "On souhaite chiffrer le message suivant par la technique du OU Exclusif :\n",
    "\n",
    "\"La cigale ayant chanté tout l'été se trouva fort dépourvue quand la bise fut venue...\"\n",
    "\n",
    "Il nous faut donc une clé.\n",
    "Chiffrer un texte avec une clé constituée d'un seul caractère n'est pas très sécurisé... Si la lettre est prise dans l'alphabet il suffirait de quelques tentatives par **force brute** pour récupérer le texte décrypté !\n",
    "\n",
    "On va donc prendre une clé de plusieurs caractères. Prenons \"Fontaine\" :\n",
    "\n",
    "La cigale ayant chanté tout l'été se trouva fort dépourvue quand la bise fut venue...\n",
    "Fontaine\n",
    "\n",
    "Le F va servir à chiffrer le L, le o à chiffrer le a, ... le e à chiffrer le l \n",
    "\n",
    "Pour pouvoir chiffrer tout le texte, il va falloir reporter autant de fois que nécessaire le clé choisie pour avoir une lettre clé en vis-à-vis de chaque lettre du message...mais comme on le voit ci-dessous le dernier report de la clé devra être parfois tronqué :\n",
    "\n",
    "La cigale ayant chanté tout l'été se trouva fort dépourvue quand la bise fut venue...\n",
    "FontaineFontaineFontaineFontaineFontaineFontaineFontaineFontaineFontaineFontaineFonta\n",
    "\n",
    "... A vous de jouer  : il s'agit d'écrire une fonction **chiffrer_texte(msg, cle)** ainsi que la fonction **dechiffrer_texte(msg, cle)** : répondant à la docstring donnée :\n",
    "\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CELLULE 8 :\n",
    "def chiffrer_texte(msg, cle):\n",
    "    \"\"\" fonction qui réalise le chiffrement à l'aide du XOR d'un texte complet par une clé de taille plus petite que le texte.\n",
    "    :param msg: (str) le message à chiffrer\n",
    "    :param cle: (str) la clé de chiffrement\n",
    "    :return: (str) le message chiffré\n",
    "    \"\"\"\n",
    "    msg_chiffre = \"\"\n",
    "\n",
    "    ???\n",
    "    ...\n",
    "    ???\n",
    "\n",
    "    return msg_chiffre\n",
    "\n",
    "def dechiffrer_texte(msg, cle):\n",
    "    ???\n",
    "    ...\n",
    "    ???\n",
    "    return ???\n",
    "\n",
    "\n",
    "# Test des fonctions :\n",
    "fable = \"La cigale ayant chanté tout l'été se trouva fort dépourvue quand la bise fut venue...\"\n",
    "cle = \"Fontaine\"\n",
    "\n",
    "fable_chiffree = chiffrer_texte(fable, cle)\n",
    "print('fable_chifrée = \\n', fable_chiffree)\n",
    "print('fable_déchiffrée = \\n', dechiffrer_texte(fable_chiffree, cle))"
   ]
  }
 ]
}