3. Symmetric Encryption.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modern Cryptography\n",
    "\n",
    "Generally speaking there are two *kinds* of encryptions. Symmetric and Asymmetric.\n",
    "\n",
    "In the symmetric encryption the parties involved share the ***same*** key.\n",
    "\n",
    "In the asymmetric encryption schemes the parties use ***different*** keys, that are mathematically ***related*** to each other.\n",
    "\n",
    "<img src=\"include/sym_vs_asym.png\" width=\"750\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Symmetric Encryption\n",
    "\n",
    "In the following we look at the symmetric encryption algorithms. In symmetric crypto, we use the same key for encryption and decryption. **Therefore, the two parties needs to establish a secret key between them.** Symmetric encryption can be up to 1000 times faster than asymmetric encryption. Given the support of some crypto algorithm in the CPU and at hardware level, even faster."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    "\n",
    " - How should we share this secret key? securely, of course!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Advanced Encryption Algorithm (AES)\n",
    "\n",
    "AES is based on Rijndael encryption algorithm, designed by Joan Daemen and Vincent Rijmen. It was one of the algorithms submitted to U.S. National Institute of Standards and Technology (NIST) to replace DES and 3DES. It was published in 1998 and accepted and standardized in 2001.\n",
    "\n",
    " * AES supports key sizes of 128/192/256 bits\n",
    " * Block size: 128 bit\n",
    " * It's iterative rather than Feistel cipher\n",
    " * Treats data in 4 groups of 4 bytes\n",
    " * Operates on an entire block in every round\n",
    " * Resistant against known attacks\n",
    " * Speed and code compactness on many CPUs\n",
    " * Rijndael block and key size vary between 128, 192, 256\n",
    " * However, in AES block size in 128\n",
    " * Number of rounds a function of key size\n",
    "  * 128 bits     10 rounds\n",
    "  * 192 bits     12 rounds\n",
    "  * 256 bits     14 rounds\n",
    "\n",
    " * Today most implementations use the CPU support (Intel AES-NI)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Block cipher mode of operation\n",
    "\n",
    "To encrypt messages of arbitrary size with block ciphers, we use the following algorithms, called the modes of operation. They define how to encrypt each block of the plaintext to produce the corresponding cipher text block. Some of these are completely insecure (ECB) and should not be used.\n",
    "\n",
    " * Electronic Codebook (ECB)\n",
    " * Cipher Block Chaining (CBC)\n",
    " * Counter (CTR)\n",
    " \n",
    " \n",
    "### Electronic Codebook (ECB)\n",
    "\n",
    "<img src=\"include/ECB_enc.png\">\n",
    "<img src=\"include/ECB_dec.png\">\n",
    "\n",
    "\n",
    "\n",
    "### Cipher Block Chaining (CBC)\n",
    "\n",
    "<img src=\"include/CBC_enc.png\">\n",
    "<img src=\"include/CBC_dec.png\">\n",
    "\n",
    "\n",
    "\n",
    "### Counter (CTR)\n",
    "\n",
    "<img src=\"include/CTR_enc.png\">\n",
    "<img src=\"include/CTR_dec.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes\n",
    "from cryptography.hazmat.backends import default_backend\n",
    "key = os.urandom(16) # in bytes, 128 bits\n",
    "iv = os.urandom(16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# ECB Mode, we only need a key\n",
    "### *** DO NOT USE ECB. IT IS INSECURE *** ###\n",
    "\n",
    "cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend())\n",
    "encryptor = cipher.encryptor()\n",
    "# note that we don't need padding here, since len(\"PyCon 2017 Cypto\") = 16\n",
    "cipher_text = encryptor.update(b\"PyCon 2017 Cypto\") + encryptor.finalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cipher_text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print (len(cipher_text))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "decryptor = cipher.decryptor()\n",
    "decryptor.update(cipher_text) + decryptor.finalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# CBC Mode, we also need an IV\n",
    "cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())\n",
    "encryptor = cipher.encryptor()\n",
    "# note that we don't need padding here, since len(\"PyCon 2017 Cypto\") = 16\n",
    "cipher_text = encryptor.update(b\"PyCon 2017 Cypto\") + encryptor.finalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cipher_text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "decryptor = cipher.decryptor()\n",
    "decryptor.update(cipher_text) + decryptor.finalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# CTR Mode, we don't need padding in CTR mode. In transforms a block cipher into a stream cipher\n",
    "# we only need to introduce the nonce\n",
    "cipher = Cipher(algorithms.AES(key), modes.CTR(os.urandom(16)), backend=default_backend())\n",
    "encryptor = cipher.encryptor()\n",
    "cipher_text = encryptor.update(b\"PyCon 2017 Cypto\") + encryptor.finalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    "\n",
    " - Encrypt the file following text using the ECB, and CBC or CTR mode and compare the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plain_text = b\"PyCon is great!!\" * 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_text(text, b64=False):\n",
    "    for i in range(0, 128, 16):\n",
    "        if b64:\n",
    "            pt = base64.b64encode(text[i:i+16])\n",
    "        else:\n",
    "            pt = text[i:i+16]\n",
    "        print (pt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## IMPLEMENTATION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print_text(ecb_ct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print_text(cbc_ct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print_text(ctr_ct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Extra Activity</font>*\n",
    "\n",
    "Encrypt the file \"include/tux.png\" using the ECB, and CBC or CTR mode and compare the results.\n",
    " - **You need to install the [pillow](https://python-pillow.org/) library**\n",
    "     - read the image file and get all the pixel values\n",
    "     - encrypt the pixel values\n",
    "     - create a new image with new (encrypted) pixel values\n",
    "     - write your newly crafted image to disk\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "The origianl image from Wikipedia. <img src=\"include/tux.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "ECB Encryption of the image with two different keys. The results (colors) are different, because we are using two different keys. However, the patterns inside the data (image) is not hidden.\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "<img src=\"include/ECB1.png\" width=\"200\" align=\"left\" > <img src=\"include/ECB2.png\", width=\"200\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "As compared to when we are using the CBC (or CTR) mode. Because we introduce the randomness at the beginning (IV), and we carry this randomness (noise) throughout the encryption the patterns are diminished.\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "<img src=\"include/CBC1.png\" width = 200>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encryption alone is not good enough\n",
    "\n",
    "Encrypting you data alone will not protect you from data tampering. Meaning an adversary can change the results of your decryption without having access to the key. All, without you noticing. That's when are HMACs from previously become handy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bit flipping attack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the IV is sent in clear we can change the IV value and change the corresponding plaintext, when using CBC mode.\n",
    "\n",
    "***Encryption***\n",
    "\n",
    " - $C_{i}=E_{K}(P_{i}\\oplus C_{i-1})$\n",
    " - $ C_{0}=IV$\n",
    "\n",
    "***Decryption***\n",
    " - $P_{i}=D_{K}(C_{i})\\oplus C_{i-1}$\n",
    " - $C_{0}=IV$\n",
    " \n",
    " \n",
    "Therefore to change the plaintext value we just need to xor the old plaintext(p), and the new value (t), with the IV:\n",
    "\n",
    "$IV = IV \\oplus p \\oplus t$\n",
    "\n",
    "Meaning if the first 4 bytes of the plaint text are: \"1234\" and we want to change it to \"6789\" all we have to do is\n",
    "\n",
    "$IV[0:4] = IV[0:4] \\oplus 1234 \\oplus 6789$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    "\n",
    " - Imagine the message is only 16 bytes, \"PyCon2017 Cyrpto\". Change the year from 2017 to 1991."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def xor(s1, s2):\n",
    "    return bytes([a ^ b for a,b in zip(s1,s2)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "iv = os.urandom(16)\n",
    "cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())\n",
    "encryptor = cipher.encryptor()\n",
    "cipher_text = encryptor.update(b\"PyCon2017 Cyrpto\") + encryptor.finalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'PyCon2017 Cyrpto'"
      ]
     },
     "execution_count": 322,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())\n",
    "decryptor = cipher.decryptor()\n",
    "decryptor.update(cipher_text) + decryptor.finalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## IMPLEMENTATION"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Authenticated Encryption with Associated Data (AEAD)\n",
    "\n",
    "AEAD provides confidentiality, integrity, and authenticity at once. Such schemes help to mitigate against the bit flipping attacks that we just did. The Galois/Counter Mode (GCM) mode of operation is the recommended schemes to be used. Fortunately, the *cryptography* library already has it implemented."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# GCM Mode, we also need an IV\n",
    "cipher = Cipher(algorithms.AES(key), modes.GCM(iv), backend=default_backend())\n",
    "encryptor = cipher.encryptor()\n",
    "# note that we don't need padding here, since len(\"PyCon2017 Crypto\") = 16\n",
    "encryptor.authenticate_additional_data(b\"SOME ADDITIONAL DATA\")\n",
    "cipher_text = encryptor.update(b\"PyCon2017 Crypto\") + encryptor.finalize()\n",
    "tag = encryptor.tag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'PyCon2017 Crypto'"
      ]
     },
     "execution_count": 329,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decryptor = Cipher(algorithms.AES(key), modes.GCM(iv,tag), backend=default_backend()).decryptor()\n",
    "decryptor.authenticate_additional_data(b\"SOME ADDITIONAL DATA\")\n",
    "decryptor.update(cipher_text) + decryptor.finalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Padding\n",
    "\n",
    "With some block cipher mode of operations (e.g., CBC) we need to pad the data to the block size. Otherwise, if would throw exception."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes\n",
    "from cryptography.hazmat.backends import default_backend\n",
    "key = os.urandom(16) # in bytes, 128 bits\n",
    "\n",
    "#CTR\n",
    "cipher = Cipher(algorithms.AES(key), modes.CTR(os.urandom(16)), backend=default_backend())\n",
    "encryptor = cipher.encryptor()\n",
    "# len(\"PyCon 2017 Cryptography\") = 23, but we don't need padding in CTR\n",
    "ctr_ct = encryptor.update(b\"PyCon 2017 Cryptography\") + encryptor.finalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#CBC\n",
    "cipher = Cipher(algorithms.AES(key), modes.CBC(os.urandom(16)), backend=default_backend())\n",
    "encryptor = cipher.encryptor()\n",
    "# len(\"PyCon 2017 Cryptography\") = 23, throws an exception\n",
    "cbc_ct = encryptor.update(b\"PyCon 2017 Cryptography\") + encryptor.finalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Public-Key Cryptography Standards (PKCS)\n",
    "\n",
    "PKCS7 padding is described in RFC 5652. The number of missing bytes (n) to the whole block size is repeated n times.\n",
    "\n",
    " - For example if the block size is 16,\n",
    "   - The data is of size 13, the data is padding with 3, 3 times. 03 03 03.\n",
    "   - The data is of size 14, the data is padded with 2, 2 times. 02 02\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    "\n",
    " - Implement PKCS7 padding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## IMPLEMENTATION\n",
    "def pkcs7_pad(text):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Test our implementation of PKCS7 padding\n",
    "\n",
    "from cryptography.hazmat.primitives import padding\n",
    "\n",
    "for i in range(16):\n",
    "    msg = b'A'*i\n",
    "    padder = padding.PKCS7(128).padder()\n",
    "    padded_data = padder.update(msg)\n",
    "    padded_data += padder.finalize()\n",
    "    assert padded_data == pkcs7_pad(msg)"
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}