Cuaderno_P6_Seguridad.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ad501398",
   "metadata": {},
   "source": [
    "# Encriptación Simétrica"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4163da6",
   "metadata": {},
   "source": [
    "Con este cuaderno se pretende exponer los conceptos claves de la encriptación simétrica, la cual debemos de saber que consiste en aquella en la que encriptamos el mensaje mediante una clave secreta la cual deberá de ser compartida por el emisor y el receptor del mensaje.\n",
    "![None](https://media.discordapp.net/attachments/886925237990617119/908806236894552074/EncriptacionSimetrica.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1554820e",
   "metadata": {},
   "source": [
    "A la hora de trabajar con encriptación simétrica existen dos tipos de algoritmos aquellos en los cuales vamos cifrando el mensaje, generando bloques los cuales serán transmitidos y que para poder desencriptar el mensaje necesario descencriptar cada uno de los bloques transmitidos. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5871513b",
   "metadata": {},
   "source": [
    "En el otro caso, tenemos los **Stream Ciphers**, en los cuales se realizará la encriptación bit a bit.\n",
    "\n",
    "Para trabajar con este cuaderno será necesario tener instalado el paquete **[PyCryptodome](https://www.pycryptodome.org/en/latest/)** de Python, por ello en caso de no tenerlo instálelo de la siguiente manera:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "2cba3ad0",
   "metadata": {},
   "source": [
    "pip install pycryptodome"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8addf31",
   "metadata": {},
   "source": [
    "Una vez realizado esto podremos importa las funciones necesarias para realizar la encriptación simétrica de bloques."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5aee908",
   "metadata": {},
   "source": [
    "## Modos clásicos de operación para encriptación simétrica de bloque"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5193e13d",
   "metadata": {},
   "source": [
    "A la hora de trabajar con los modos clásicos se nos propone utilizar el algoritmo \\textbf{AES}, para comprender el funcionamiento de la encriptación. \n",
    "\n",
    "Para ello, lo primero que haremos será importar la clase AES, y así poder trabajar con una instancia de esta clase. A esta clase le deberemos de pasar en el constructor la ```clave'' y el método de encriptación a emplear. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "417b5f99",
   "metadata": {},
   "outputs": [],
   "source": [
    "from base64 import b64encode, b64decode\n",
    "from Crypto.Cipher import AES\n",
    "from Crypto.Util.Padding import pad, unpad\n",
    "from Crypto.Random import get_random_bytes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e329002",
   "metadata": {},
   "source": [
    "Deberemos de indicar cual es el mensaje que deseamos encriptar, además de generar una clave de forma aleatoria:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54335793",
   "metadata": {},
   "outputs": [],
   "source": [
    "mensaje = \"Hola mundo\"\n",
    "mensajeBinario = mensaje.encode()\n",
    "clave = get_random_bytes(16)\n",
    "cipher = AES.new(clave, AES.MODE_CBC)\n",
    "ct_bytes = cipher.encrypt(pad(mensajeBinario,AES.block_size))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0089b02",
   "metadata": {},
   "source": [
    "De esta forma en ct_bytes tendremos el texto cifrado en binario, para poder obtener el texto en un formato  UTF-8, podemos utilizar **b64encode**, para obtener ese valor en codificación **utf-8**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b6391af",
   "metadata": {},
   "outputs": [],
   "source": [
    "iv = b64encode(cipher.iv).decode('utf-8')\n",
    "ct = b64encode(ct_bytes).decode('utf-8')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06b18cf2",
   "metadata": {},
   "source": [
    "Si mostramos ambas variables podemos ver tanto el vector de inicialización como el texto encriptado.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd020a56",
   "metadata": {},
   "outputs": [],
   "source": [
    "    print (f\"{iv=}\")\n",
    "    print (f\"{ct=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "500629a3",
   "metadata": {},
   "source": [
    "### Desencriptación"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e704c36",
   "metadata": {},
   "source": [
    "Para desencriptar lo que deberemos de hacer será en primer lugar, decodificar el mensaje y el vector de inicialización, ya que lo tenemos en formato **Base64**. Para ello usaremos ***b64decode***.\n",
    "\n",
    "Tras esto lo que haremos será crear nuestro objeto de la clase AES, el cual utilizaremos para desencriptar el mensaje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81bfc396",
   "metadata": {},
   "outputs": [],
   "source": [
    "ivCifrado = iv\n",
    "cvCifrado = ct\n",
    "iv = b64decode(iv)\n",
    "ct = b64decode(ct)\n",
    "cipher = AES.new(clave, AES.MODE_CBC, iv)\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d712e5d3",
   "metadata": {},
   "source": [
    "Una vez creado el objeto, utilizaremos la función **decrypt**, a la cual le pasaremos el mensaje, y mediante la función **unpad**, descomprimiremos el block de AES. De esta forma el mensaje se encontrará guardado en la variable pt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7816a24",
   "metadata": {},
   "outputs": [],
   "source": [
    "pt = unpad(cipher.decrypt(ct), AES.block_size)\n",
    "print(\"Mensaje desencriptado: \", pt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89c76aff",
   "metadata": {},
   "source": [
    "Una vez hecho esto ya tendríamos el texto descifrado. En caso de error nos saltaría la excepción de **KeyError**.\n",
    "\n",
    "Si deseamos ejecutar todo este fragmento en conjunto sería:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3fb8cb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    iv = b64decode(ivCifrado)\n",
    "    ct = b64decode(ctCifrado)\n",
    "    cipher = AES.new(key, AES.MODE_CBC, iv)\n",
    "    pt = unpad(cipher.decrypt(ct), AES.block_size)\n",
    "    print(\"The message was: \", pt)\n",
    "except (ValueError, KeyError):\n",
    "    print(\"Incorrect decryption\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11f68408",
   "metadata": {},
   "source": [
    "### Encriptación de un fichero"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af177847",
   "metadata": {},
   "source": [
    "Si deseamos encriptar un fichero, como sabemos deberemos de ir leyendo línea a línea del fichero e ir encriptando el contenido de dicha línea. \n",
    "\n",
    "En este caso se nos propone conocer el funcionamiento de los modos de encriptación \\textbf{CBC y CTR}, los cuales podemos diferenciar con la siguiente explicación:\n",
    "\n",
    "- El modo **CBC**, consiste en una encriptación por bloques, en la cual se tendrá que utilizar un IV aleatorio, cada vez que se encripte un mensaje. En este caso se necesitará rellenar los bloques a transmitir con un tamaño fijo para todos. \n",
    "- El modo **CTR**, consiste en un modo de cifrado de flujo, en este caso lo que hace es mediante una secuencia pseudoaleatoria, independiente del texto, se obtendrán los diferentes IV para encriptar. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ef86371",
   "metadata": {},
   "source": [
    "Una vez entendidos podemos trabajar con ellos, en primer lugar deberemos de importar los mismos módulos utilizados anteriormente. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b7136fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "    CBCActivo = True\n",
    "    CTRActivo = False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7248a54e",
   "metadata": {},
   "source": [
    "Estas variables las utilizaremos para determinar que modo deseamos utilizar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e9e6772",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    fichero = open (nombreFicheroEntrada,'r')\n",
    "    ficheroEncriptado = open (nombreFicheroDestino,'w')\n",
    "    if CBCActivo is True:\n",
    "        cipher = AES.new(key, AES.MODE_CBC)   \n",
    "    elif CTRActivo is True:\n",
    "        cipher = AES.new(key, AES.MODE_CTR)\n",
    "    for linea in fichero:\n",
    "        linea = linea[:linea.find('\\\\')]\n",
    "        #Encriptamos el dato\n",
    "    \n",
    "        if CBCActivo is True:\n",
    "            lineaEncriptadaBytes = cipher.encrypt(pad(linea, AES.block_size))            \n",
    "        elif CTRActivo is True:\n",
    "            lineaEncriptadaBytes = cipher.encrypt(linea)\n",
    "            \n",
    "        lineaEncriptada = b64encode(lineaEncriptadaBytes).decode('utf-8')\n",
    "        ficheroEncriptado.write(lineaEncriptada)\n",
    "            \n",
    "finally:\n",
    "    fichero.close()\n",
    "    ficheroEncriptado.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41db2ea0",
   "metadata": {},
   "source": [
    "En primer lugar deberemos de abrir los ficheros, tanto el que deseamos encriptar como en el cual deseamos guardar. Posteriormente crearemos nuestro objeto AES, con el cual realizaremos la encriptación.\n",
    "\n",
    "Posteriormente recorreremos el fichero, eliminando a cada línea el ''\\n'', posteriormente, encriptaremos el dato, dependiendo del modo Activo. Para el caso del \\textbackslash{CBC} deberemos de utilizar **pad**, para especificar el contenido con el tamaño de bloque.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ce7b76f",
   "metadata": {},
   "source": [
    "Cosa que no ocurre con **CTR**.\n",
    "\n",
    "Posteriormente codificaremos el mensaje encrptado en formato **utf-8**. Y escribiendo en el fichero destino.\n",
    "\n",
    "Si deseamos desencriptar el fichero en primer lugar necesitaremos el IV utilizado y la clave. Para ello podemos mostrarlos por pantalla o guardarlos en un fichero json."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c942917b",
   "metadata": {},
   "outputs": [],
   "source": [
    "iv = b64encode(cipher.iv).decode('utf-8')\n",
    "key = key.hex()\n",
    "result = {}\n",
    "result[\"iv\"] = iv\n",
    "result[\"key\"] = key\n",
    "print (iv)\n",
    "print (key)\n",
    "    \n",
    "with open('data.json', 'w') as outfile:\n",
    "    json.dump(result, outfile)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1de1349e",
   "metadata": {},
   "source": [
    "#### Desencriptación de un fichero"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4639a6e",
   "metadata": {},
   "source": [
    "A la hora de desencriptar deberemos de conocer cual fue el modo utilizado para encriptar. Además de utilizar la clave y el IV, el cual cargaremos del fichero json."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca09ce51",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    with open(\"data.json\") as json_data:\n",
    "        b64 = json.load(json_data)\n",
    "        print(b64)\n",
    "    iv = b64decode(b64['iv'])\n",
    "    cipher = AES.new(key, AES.MODE_CBC, iv)\n",
    "    try:\n",
    "        fichero = open (nombreFicheroEntrada,'r')\n",
    "        ficheroEncriptado = open (nombreFicheroDestino,'w')\n",
    "        if CBCActivo is True:\n",
    "            cipher = AES.new(key, AES.MODE_CBC)   \n",
    "        elif CTRActivo is True:\n",
    "            cipher = AES.new(key, AES.MODE_CTR)\n",
    "        for linea in fichero:\n",
    "            linea = linea[:linea.find('\\\\')]\n",
    "            #Encriptamos el dato    \n",
    "            linea = b64decode(linea)\n",
    "            if CBCActivo is True:\n",
    "                lineaDesencriptadaBytes = cipher.decrypt(unpad(linea, AES.block_size))            \n",
    "            elif CTRActivo is True:\n",
    "                lineaDesencriptadaBytes = cipher.decrypt(linea)\n",
    "                \n",
    "            ficheroEncriptado.write(lineaDesencriptada)\n",
    "                \n",
    "    finally:\n",
    "        fichero.close()\n",
    "        ficheroEncriptado.close()\n",
    "    \n",
    "    \n",
    "    print(\"The message was: \", pt)\n",
    "except (ValueError, KeyError):\n",
    "    print(\"Incorrect decryption\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06c0686a",
   "metadata": {},
   "source": [
    "Como podemos ver se utiliza la función **decrypt** para desencriptar la información. Anteriormente debemos de decodificar el mensaje.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11ef0055",
   "metadata": {},
   "source": [
    "### Encriptación Autentificada con Datos Asociados"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc0d807d",
   "metadata": {},
   "source": [
    "En esta parte opcional se pretende exponer el modo **EAX** del algoritmo AES, el cual nos permitirá esta forma de encriptación. Para ello será necesario cambiar el modo que le pasamos a la hora de crear la instancia\n",
    "del objeto AES. Y posteriormente utilizar la función de encrypt_and_digest, para obtener el texto\n",
    "cifrado.\n",
    "\n",
    "Para descifrar utilizaremos la función decrypt_and_verify."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52c81062",
   "metadata": {},
   "source": [
    "El siguiente trozo de código nos permite encriptar el mensaje, para ello crearemos una clave de forma aleatoria, y a partir de ella crearemos la instancia del objeto AES con el modo EAX. Posteriormente utilizaremos la función **encrypt_and_digest**, como ya hemos indicado y finalmente lo que haremos será volcar la información al fichero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa1053ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "key = get_random_bytes(16)\n",
    "data=\"Hola mundo\".encode(\"utf-8\")\n",
    "cipher = AES.new(key, AES.MODE_EAX)\n",
    "ciphertext, tag = cipher.encrypt_and_digest(data)\n",
    "file_out = open(\"encrypted.bin\", \"wb\")\n",
    "[ file_out.write(x) for x in (cipher.nonce, tag, ciphertext) ]\n",
    "print(key.hex())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54c152c9",
   "metadata": {},
   "source": [
    "Para el caso de desencriptar sería de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4a2e551",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = key.hex() #Para poder coger la clave correcta \n",
    "key= bytes.fromhex(i)\n",
    "file_in = open(\"encrypted.bin\", \"rb\")\n",
    "nonce, tag, ciphertext = [ file_in.read(x) for x in (16, 16, -1) ]\n",
    "# let's assume that the key is somehow available again\n",
    "cipher = AES.new(key, AES.MODE_EAX, nonce)\n",
    "data = cipher.decrypt_and_verify(ciphertext, tag)\n",
    "print(data.decode())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "065073ec",
   "metadata": {},
   "source": [
    "Una vez visto todo esto ya podemos trabajar con la encriptación de un fichero completo. Para ello como siempre leeremos el fichero e iremos utilizando el objeto AES, para encriptar o desencriptar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ad6ea56",
   "metadata": {},
   "outputs": [],
   "source": [
    "nombreFicheroEntrada = \"hola.txt\"\n",
    "\n",
    "nombreFicheroDestino = \"hola.bin\"\n",
    "    \n",
    "key = get_random_bytes(16)\n",
    "    \n",
    "cipher = AES.new(key, AES.MODE_EAX)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f2bdca3",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = \"\"\n",
    "try:\n",
    "    fichero = open (nombreFicheroEntrada,'r')\n",
    "    ficheroEncriptado = open( nombreFicheroDestino + \".bin\", \"wb\")\n",
    "    \n",
    "    for linea in fichero:\n",
    "        #Encriptamos el dato\n",
    "        data+=linea\n",
    "    \n",
    "    ciphertext, tag = cipher.encrypt_and_digest(data.encode())\n",
    "    [ ficheroEncriptado.write(x) for x in (cipher.nonce, tag, ciphertext) ]\n",
    "    \n",
    "    print(key.hex())        \n",
    "finally:\n",
    "    fichero.close()\n",
    "    ficheroEncriptado.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "393f3b03",
   "metadata": {},
   "source": [
    "Para el caso de desencriptación sería de la misma forma: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b36ad1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "nombreFicheroEntrada = \"hola.bin\"\n",
    "    \n",
    "nombreFicheroDestino = \"holaDesencriptado.txt\"\n",
    "    \n",
    "i = key.hex()\n",
    "key= bytes.fromhex(i)\n",
    "    \n",
    "cipher = AES.new(key, AES.MODE_EAX)\n",
    "     \n",
    "#Debemos de leer todo el contenido del fichero y guardarlo en la variable ciphertext\n",
    "data = \"\"\n",
    "try:\n",
    "    fichero = open (nombreFicheroEntrada,'rb')\n",
    "    ficheroDesencriptado = open( nombreFicheroDestino, \"w\")\n",
    "        \n",
    "    nonce, tag, ciphertext = [ fichero.read(x) for x in (16, 16, -1) ]\n",
    "    \n",
    "    cipher = AES.new(key, AES.MODE_EAX, nonce)\n",
    "    data = cipher.decrypt_and_verify(ciphertext, tag)\n",
    "    print(data.decode())\n",
    "    ficheroDesencriptado.write(data.decode())\n",
    "            \n",
    "finally:\n",
    "    fichero.close()\n",
    "    ficheroDesencriptado.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9d5ce8c",
   "metadata": {},
   "source": [
    "Como podemos ver para encriptar los ficheros hemos recorrido los ficheros y almacenado el contenido en una variable y posteriormente encriptado este contenido. Esto podría dar problemas a la hora de que necesitaríamos almacenar toda la información del fichero en memoria para realizar este proceso. Siendo muy costoso a nivel de memoria."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}