notebooks/3-symmetric-key-ciphers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch3: Traditional Symmetric Key Ciphers\n",
    "## 3. 1 Monoalphabetic Ciphers\n",
    "### 3.1.1 Caesar Shift Cipher (Additive Cipher)\n",
    "In the Caeser shift cipher the plaintext character $x$ is transformed into `(x - 'a' + m) % 26 + 'a'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def caeser_shift(plaintext, shift=0):\n",
    "    return ''.join([chr((ord(letter) - ord('a') + shift) % 26 + 97) for letter in plaintext])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wtaad\n"
     ]
    }
   ],
   "source": [
    "ciphertext = caeser_shift('hello', 15)\n",
    "print(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print(caeser_shift(ciphertext, -15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "def get_frequencies(ciphertext):\n",
    "    return Counter(ciphertext)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.2 Performing Statistical Analysis on Additive Ciphers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'a': 2, 'w': 1, 't': 1, 'd': 1})\n"
     ]
    }
   ],
   "source": [
    "print(get_frequencies(ciphertext))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.3 Multiplicative Cipher\n",
    "The Ciphertext $C = (P * k) \\% 26$ where k is the key and for decrytping it is $P = (C * k^{-1}) \\% 26$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiplicative_cipher_encrypt(plaintext, key):\n",
    "    return ''.join([chr(((ord(letter) - ord('a')) * key) % 26 + ord('a')) for letter in plaintext.lower()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gcd(a, b):\n",
    "    return gcd(b, a % b) if b != 0 else a\n",
    "\n",
    "\n",
    "def extended_gcd(a, b):\n",
    "    s, old_s = 1, 0\n",
    "    t, old_t = 0, 1\n",
    "\n",
    "    while b != 0:\n",
    "        q = a // b\n",
    "        a, b = b, a % b\n",
    "        s, old_s = old_s, s - q * old_s\n",
    "        t, old_t = old_t, t - q * old_t\n",
    "    return a, s, t\n",
    "\n",
    "\n",
    "def multiplicative_inverse_exists(a, n):\n",
    "    return gcd(a, n) == 1\n",
    "\n",
    "\n",
    "def multiplicative_inverse(b, n):\n",
    "    if multiplicative_inverse_exists(b, n):\n",
    "        return (extended_gcd(n, b)[2] + n) % n\n",
    "    \n",
    "\n",
    "def multiplicative_cipher_decrypt(ciphertext, key):\n",
    "    return ''.join(\n",
    "        [chr(((ord(letter) - ord('a')) * multiplicative_inverse(key, 26)) % 26 + ord('a')) for letter in ciphertext.lower()]\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xczzu\n"
     ]
    }
   ],
   "source": [
    "print(multiplicative_cipher_encrypt('hello', 7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print(multiplicative_cipher_decrypt('xczzu', 7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.3 Affine Ciphers\n",
    "The affine cipher takes in 2 keys $k_1$ and $k_2$ and encrypte the plaintext code $P$ as follows $C = (P * k_1 + k_2) \\% 26$. It decrpyts the ciphertext as follows: $P = ((C - k_2) * k_1^{-1}) \\% 26$. Let us create a class AffineCipher that will offer teh user with 2 methods to encrypt and decrpyt data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AffineCipher:\n",
    "    def __init__(self, k_1, k_2):\n",
    "        self.k_1 = k_1\n",
    "        self.k_2 = k_2\n",
    "        \n",
    "    def char_to_num(self, letter):\n",
    "        letter = letter.lower()\n",
    "        return ord(letter) - ord('a')\n",
    "        \n",
    "    def encrypt(self, plaintext):\n",
    "        return ''.join([chr((self.char_to_num(letter) * self.k_1 + self.k_2) % 26 + ord('A')) for letter in plaintext.lower()])\n",
    "    \n",
    "    def decrypt(self, ciphertext):\n",
    "        return ''.join(\n",
    "            [chr(((self.char_to_num(letter) - self.k_2) * multiplicative_inverse(self.k_1, 26)) % 26 + ord('a'))\n",
    "             for letter in ciphertext.lower()]\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'CVUUB'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cipher = AffineCipher(11, 3)\n",
    "cipher.encrypt('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cipher.decrypt('CVUUB')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 Polyalphabetic Ciphers\n",
    "### 3.2.1 Autokey Cipher\n",
    "In the autokey cipher the initial key $k$ is given and all subsequent keys are generated using the plaintext characters hence the keys become $(k, P_1, P_2, P_3 \\cdots)$.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AutoKeyCipher:\n",
    "    def __init__(self, k):\n",
    "        self.k = k\n",
    "        \n",
    "    def encrypt(self, plaintext):\n",
    "        key = self.k\n",
    "        ciphertext = ''\n",
    "        for letter in plaintext.lower():\n",
    "            ciphertext += chr((ord(letter) - ord('a') + key) % 26 + ord('A'))\n",
    "            key = ord(letter) - ord('a')\n",
    "        return ciphertext\n",
    "    \n",
    "    def decrypt(self, ciphertext):\n",
    "        key = self.k\n",
    "        plaintext = ''\n",
    "        for letter in ciphertext.lower():\n",
    "            key = (ord(letter) - ord('a') - key) % 26\n",
    "            plaintext += chr(key + ord('a'))\n",
    "        return plaintext"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MTMTCMSALHRDY'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "auto_key_cipher = AutoKeyCipher(12)\n",
    "auto_key_cipher.encrypt('attackistoday')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'attackistoday'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "auto_key_cipher.decrypt('MTMTCMSALHRDY')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.2 Playfair Cipher\n",
    "The Playfair Cipher takes in an initial 5x5 matrix where __i__ and __j__ share the same spot and the encryption follows the following rules:\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix}\n",
    "L & G & D & B & A \\\\\n",
    "Q & M & H & E & C \\\\\n",
    "U & R & N & I/J & F \\\\\n",
    "X & V & S & O & K \\\\\n",
    "Z & Y & W & T & P \\\\\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "1. Add an extra character when consecutive letters are the same.\n",
    "1. Pad an extra character at the end if the length of the plaintext is odd.\n",
    "1. Take pairs at a time and\n",
    "    1. If the pairs belong to the same row then the enncrypted character is in the same row just shifted +1 to the right (with wrapping in the same row).\n",
    "    1. If the pairs belong to the same column then the enncrypted character is in the same column just shifted +1 to the bottom (with wrapping in the same column).\n",
    "    1. If the pairs are in different rows and columns then take character from first letter's row and second letter's column and then vica versa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PlayFairCipher:\n",
    "    def __init__(self, key):\n",
    "        self.key = key\n",
    "        self.letter2index = self.get_letter_2_index_map()\n",
    "\n",
    "    def get_letter_2_index_map(self):\n",
    "        index_map = {}\n",
    "        for row in range(len(self.key)):\n",
    "            for column in range(len(self.key[row])):\n",
    "                letter = self.key[row][column]\n",
    "                if letter == 'i':\n",
    "                    index_map['j'] = (row, column)\n",
    "                index_map[letter] = (row, column)\n",
    "        return index_map\n",
    "\n",
    "    def encrypt(self, plaintext):\n",
    "        plaintext = self.pad_extra(self.remove_consecutive_same_chars(plaintext.lower()))\n",
    "        # print('plaintext:', plaintext)\n",
    "        ciphertext = ''\n",
    "        for index in range(0, len(plaintext), 2):\n",
    "            pair = plaintext[index: index + 2]\n",
    "            ciphertext += self.encipher(pair)\n",
    "        return ciphertext.upper()\n",
    "\n",
    "    def decrypt(self, ciphertext):\n",
    "        plaintext = ''\n",
    "        for index in range(0, len(ciphertext), 2):\n",
    "            pair = ciphertext[index: index + 2].lower()\n",
    "            plaintext += self.decipher(pair)\n",
    "        return plaintext\n",
    "\n",
    "    def decipher(self, pair):\n",
    "        row1, column1 = self.letter2index[pair[0]]\n",
    "        row2, column2 = self.letter2index[pair[1]]\n",
    "        if row1 == row2:\n",
    "            return self.key[row1][(column1 - 1) % 5] + self.key[row1][(column2 - 1) % 5]\n",
    "        elif column1 == column2:\n",
    "            return self.key[(row1 - 1) % 5][column1] + self.key[(row2 - 1) % 5][column2]\n",
    "        return self.key[row1][column2] + self.key[row2][column1]\n",
    "\n",
    "    def encipher(self, pair):\n",
    "        row1, column1 = self.letter2index[pair[0]]\n",
    "        row2, column2 = self.letter2index[pair[1]]\n",
    "        if row1 == row2:\n",
    "            return self.key[row1][(column1 + 1) % 5] + self.key[row1][(column2 + 1) % 5]\n",
    "        elif column1 == column2:\n",
    "            return self.key[(row1 + 1) % 5][column1] + self.key[(row2 + 1) % 5][column2]\n",
    "        return self.key[row1][column2] + self.key[row2][column1]\n",
    "\n",
    "    @staticmethod\n",
    "    def pad_extra(plaintext):\n",
    "        return plaintext + chr((ord(plaintext[len(plaintext) - 1]) - ord('a') + 1) % 26 +ord('a')) \\\n",
    "            if len(plaintext) % 2 == 1 else plaintext\n",
    "\n",
    "    @staticmethod\n",
    "    def remove_consecutive_same_chars(plaintext):\n",
    "        for index in range(len(plaintext) - 1):\n",
    "            if plaintext[index] == plaintext[index + 1]:\n",
    "                plaintext = plaintext[: index + 1] + chr((ord(plaintext[index]) - ord('a') + 1) % 26 + ord('a')) \\\n",
    "                            + plaintext[index + 1:]\n",
    "        return plaintext"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NTUBQGBPIZCFOPVEVIVNST\n"
     ]
    }
   ],
   "source": [
    "playfair_cipher = PlayFairCipher(\n",
    "    [['l', 'g', 'd', 'b', 'a'],\n",
    "     ['q', 'm', 'h', 'e', 'c'],\n",
    "     ['u', 'r', 'n', 'i', 'f'],\n",
    "     ['x', 'v', 's', 'o', 'k'],\n",
    "     ['z', 'y', 'w', 't', 'p']]\n",
    ")\n",
    "\n",
    "ciphertext = playfair_cipher.encrypt('iwillattacktomorrow')\n",
    "print(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iwilmlatutacktomorsrow\n"
     ]
    }
   ],
   "source": [
    "plaintext = playfair_cipher.decrypt('NTUBQGBPIZCFOPVEVIVNST')\n",
    "print(plaintext)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.3 Vignere Cipher\n",
    "The vignere cipher takes in a string as a key and uses individual letters of the keys at different positions (indices) to encrypt the data. $C = (P_i + K_i) \\% 26$ and $P = (C_i - K_i) \\% 26$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class VignereCipher:\n",
    "    def __init__(self, key: str):\n",
    "        self.key = key\n",
    "\n",
    "    def encrypt(self, plaintext: str) -> str:\n",
    "        ciphertext = ''\n",
    "        for index, letter in enumerate(plaintext.lower()):\n",
    "            ciphertext += chr((self.char_2_num(letter) + self.char_2_num(self.key[index % len(self.key)])) % 26 + ord('a'))\n",
    "        return ciphertext.upper()\n",
    "\n",
    "    def decrypt(self, ciphertext: str) -> str:\n",
    "        plaintext = ''\n",
    "        for index, letter in enumerate(ciphertext.lower()):\n",
    "            plaintext += chr(\n",
    "                (self.char_2_num(letter) - self.char_2_num(self.key[index % len(self.key)])) % 26 + ord('a'))\n",
    "        return plaintext.lower()\n",
    "\n",
    "    @staticmethod\n",
    "    def char_2_num(character: str) -> int:\n",
    "        return ord(character.lower()) - ord('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HHWKSWXSLGNTCG\n"
     ]
    }
   ],
   "source": [
    "vignere_cipher = VignereCipher('pascal')\n",
    "ciphertext = vignere_cipher.encrypt('sheislistening')\n",
    "print(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sheislistening\n"
     ]
    }
   ],
   "source": [
    "print(vignere_cipher.decrypt(ciphertext))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.4 Hill Cipher\n",
    "In the Hill Cipher we are given a matrix of size __m X m__ which is our key in this instance and we divide the plaintext we get into __l__ blocks of size __m__. So we get a __l x m__ matric from the input plaintext. The Ciphertext __C__ from Plaintext __P__ can be extracted as $C = (P * K) % 26$ and similarly can be decrypted as $P = (C * K^{-1}) %26$.\n",
    "\n",
    "> Note: The Key $K$ must have a modular inverse in $Z_{26}$ otherswise the message won't be decryptable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy import linalg\n",
    "\n",
    "# Defining a few helper utility functions\n",
    "def modMatInv(A, p):  # Finds the inverse of matrix A mod p\n",
    "    n = len(A)\n",
    "    adj = np.zeros(shape=(n, n))\n",
    "    for i in range(0, n):\n",
    "        for j in range(0, n):\n",
    "            adj[i][j] = ((-1) ** (i + j) * int(round(linalg.det(minor(A, j, i))))) % p\n",
    "    return (modInv(int(round(linalg.det(A))), p) * adj) % p\n",
    "\n",
    "def modInv(a, p):  # Finds the inverse of a mod p, if it exists\n",
    "    for i in range(1, p):\n",
    "        if (i * a) % p == 1:\n",
    "            return i\n",
    "    raise ValueError(str(a) + \" has no inverse mod \" + str(p))\n",
    "\n",
    "\n",
    "def minor(A, i, j):  # Return matrix A with the ith row and jth column deleted\n",
    "    A = np.array(A)\n",
    "    sub_matrix = np.zeros(shape=(len(A) - 1, len(A) - 1))\n",
    "    p = 0\n",
    "    for s in range(0, len(sub_matrix)):\n",
    "        if p == i:\n",
    "            p = p + 1\n",
    "        q = 0\n",
    "        for t in range(0, len(sub_matrix)):\n",
    "            if q == j:\n",
    "                q = q + 1\n",
    "            sub_matrix[s][t] = A[p][q]\n",
    "            q = q + 1\n",
    "        p = p + 1\n",
    "    return sub_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "class HillCipher:\n",
    "    def __init__(self, key):\n",
    "        self.key = key\n",
    "        self.block_size = len(key)\n",
    "        self.key_inv = modMatInv(self.key, 26)\n",
    "\n",
    "    def encrypt(self, plaintext: str) -> str:\n",
    "        P = self.text_2_mat(plaintext)\n",
    "        C = P.dot(self.key) % 26\n",
    "        return self.mat_2_text(C).upper()\n",
    "\n",
    "    def decrypt(self, ciphertext: str) -> str:\n",
    "        C = self.text_2_mat(ciphertext)\n",
    "        P = C.dot(self.key_inv) % 26\n",
    "        return self.mat_2_text(P).lower()\n",
    "\n",
    "    def text_2_mat(self, text: str):\n",
    "        text = self.pad_chars(text.lower()).lower()\n",
    "        l = len(text) // self.block_size\n",
    "        return np.reshape(list(map(self.char_2_num, text)), (l, self.block_size))\n",
    "\n",
    "    def mat_2_text(self, matrix) -> str:\n",
    "        return ''.join(list(map(self.num_2_char, list(matrix.ravel()))))\n",
    "\n",
    "    @staticmethod\n",
    "    def char_2_num(character: str) -> int:\n",
    "        character = character.lower()\n",
    "        return ord(character) - ord('a')\n",
    "\n",
    "    @staticmethod\n",
    "    def num_2_char(number: int) -> str:\n",
    "        return chr(int(number) + ord('A'))\n",
    "\n",
    "    def pad_chars(self, plaintext: str) -> str:\n",
    "        padding = (- (len(plaintext) % self.block_size)) % self.block_size\n",
    "        return plaintext + 'z' * padding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OHKNIHGHFISS\n"
     ]
    }
   ],
   "source": [
    "hill_cipher = HillCipher([\n",
    "    [9, 7, 11, 13],\n",
    "    [4, 7, 5, 6],\n",
    "    [2, 21, 14, 9],\n",
    "    [3, 23, 21, 8]\n",
    "])\n",
    "\n",
    "ciphertext = hill_cipher.encrypt('codeisready')\n",
    "print(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "codeisreadyz\n"
     ]
    }
   ],
   "source": [
    "print(hill_cipher.decrypt(ciphertext))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.5 One Time Pad\n",
    "In the one time pad cipher a random key will be generated everytime of the same length as the plaintext message and only this one message can be encrypted with it and then decrypted using the one time pad. After this message has been exncrypted and created. No new messages can be created from that pad and the pad needs to be discarded and a new pad needs to be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "class OneTimePadCipher:\n",
    "    def __init__(self):\n",
    "        self.key = ''\n",
    "        self.pad_used = False\n",
    "        self.cipher = None\n",
    "\n",
    "    def encrypt(self, plaintext: str):\n",
    "        if not self.pad_used:\n",
    "            self.pad_used = True\n",
    "            self.generate_random_key(plaintext)\n",
    "            self.cipher = VignereCipher(self.key)\n",
    "            return self.cipher.encrypt(plaintext)\n",
    "        else:\n",
    "            return None\n",
    "\n",
    "    def decrypt(self, ciphertext: str):\n",
    "        if not self.pad_used:\n",
    "            return None\n",
    "        else:\n",
    "            return self.cipher.decrypt(ciphertext)\n",
    "\n",
    "    def generate_random_key(self, plaintext: str) -> None:\n",
    "        self.key = ''.join(list(map(self.num_2_char, np.random.randint(0, 25, len(plaintext)))))\n",
    "\n",
    "    @staticmethod\n",
    "    def num_2_char(number: int) -> str:\n",
    "        return chr(number + ord('a'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KBCSSFLYJJ\n"
     ]
    }
   ],
   "source": [
    "# using a one time pad to encrypt data\n",
    "cipher = OneTimePadCipher()\n",
    "ciphertext = cipher.encrypt('helloworld')\n",
    "print(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "# can't use this pad to encrypt anything ever again\n",
    "print(cipher.encrypt('newdata'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "qkrlejdmgmq\n"
     ]
    }
   ],
   "source": [
    "# we can try to decrypt as many strings as we want using this pad, but only our correct ciphertext wil give the desired output\n",
    "print(cipher.decrypt('thisisatest'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "helloworld\n"
     ]
    }
   ],
   "source": [
    "print(cipher.decrypt('KBCSSFLYJJ'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 Transposition Ciphers\n",
    "### 3.3.1 KeyLess Transposition Ciphers\n",
    "#### 3.3.1.1 Column Transposition Cipher\n",
    "In the column transposition cipher the plain text is written column wise over $r$ rows and then the ciphertext is simply the text taken over the rows. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from math import ceil\n",
    "\n",
    "\n",
    "class ColumnTranspositionCipher:\n",
    "    def __init__(self, rows):\n",
    "        self.rows = rows\n",
    "\n",
    "    def encrypt(self, plaintext: str) -> str:\n",
    "        ciphertext = ''\n",
    "        for i in range(self.rows):\n",
    "            for j in range(i, len(plaintext), self.rows):\n",
    "                ciphertext += plaintext[j]\n",
    "        return ciphertext.upper()\n",
    "\n",
    "    def decrypt(self, ciphertext: str) -> str:\n",
    "        columns = ceil(len(ciphertext) / self.rows)\n",
    "        padding = len(ciphertext) % self.rows\n",
    "        ciphertext += 'z' * padding\n",
    "        C = np.reshape(list(ciphertext), (self.rows, columns))\n",
    "        return ''.join(C.T.ravel())[: len(ciphertext) - padding].lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MEMATEAKETETHPR\n"
     ]
    }
   ],
   "source": [
    "column_transpose_cipher = ColumnTranspositionCipher(2)\n",
    "ciphertext = column_transpose_cipher.encrypt('meetmeatthepark')\n",
    "print(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "meetmeatthepark\n"
     ]
    }
   ],
   "source": [
    "print(column_transpose_cipher.decrypt('MEMATEAKETETHPR'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.1.2 Rail Fence Transposition Cipher\n",
    "This is a special case of the column Transposition Cipher and here the number of rows is predefined as 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RailFenceCipher:\n",
    "    def __init__(self):\n",
    "        self.cipher = ColumnTranspositionCipher(rows=2)\n",
    "\n",
    "    def encrypt(self, plaintext: str) -> str:\n",
    "        return self.cipher.encrypt(plaintext)\n",
    "\n",
    "    def decrypt(self, ciphertext: str) -> str:\n",
    "        return self.cipher.decrypt(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MEMATEAKETETHPR\n"
     ]
    }
   ],
   "source": [
    "rail_fence_cipher = RailFenceCipher()\n",
    "ciphertext = rail_fence_cipher.encrypt('meetmeatthepark')\n",
    "print(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "meetmeatthepark\n"
     ]
    }
   ],
   "source": [
    "print(rail_fence_cipher.decrypt('MEMATEAKETETHPR'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.1.3 Row Transposition Cipher\n",
    "The Row transposition takes in a number of columns and wraps the text around columsn and returns rows. This is inherently equivalent to the Column Transposition Cipher."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RowTranspositionCipher:\n",
    "    def __init__(self, columns):\n",
    "        self.cipher = ColumnTranspositionCipher(rows=columns)\n",
    "\n",
    "    def encrypt(self, plaintext: str) -> str:\n",
    "        return self.cipher.encrypt(plaintext)\n",
    "\n",
    "    def decrypt(self, ciphertext: str) -> str:\n",
    "        return self.cipher.decrypt(ciphertext)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.2 Key Based Transposition Cipher\n",
    "#### 3.3.2.1 Keyed Transposition Cipher\n",
    "Takes in a key that gives the order for a block to be re-arranged. Divides the original message with padding and rearranges each block with permutation based key.\n",
    "\n",
    "$$\n",
    "\\begin{pmatrix}\n",
    "3 & 1 & 4 & 5 & 2 \\\\\n",
    "1 & 2 & 3 & 4 & 5\n",
    "\\end{pmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "class KeyedTranspositionCipher:\n",
    "    def __init__(self, key):\n",
    "        self.key = key\n",
    "        self.decryption_permutation = self.get_decryption_permutation()\n",
    "\n",
    "    def encrypt(self, plaintext: str) -> str:\n",
    "        padding = (- (len(plaintext) % len(self.key))) % len(self.key)\n",
    "        plaintext = plaintext.lower() + 'z' * padding\n",
    "        ciphertext = ''\n",
    "        for index in range(0, len(plaintext), len(self.key)):\n",
    "            block = plaintext[index: index + len(self.key)]\n",
    "            ciphertext += self.encipher(block)\n",
    "        return ciphertext.upper()\n",
    "\n",
    "    def decrypt(self, ciphertext: str) -> str:\n",
    "        plaintext = ''\n",
    "        for index in range(0, len(ciphertext), len(self.key)):\n",
    "            block = ciphertext[index: index + len(self.key)].lower()\n",
    "            plaintext += self.decipher(block)\n",
    "        return plaintext\n",
    "\n",
    "    def decipher(self, block: str) -> str:\n",
    "        return self.crypt(block, key=self.decryption_permutation)\n",
    "\n",
    "    def encipher(self, block: str) -> str:\n",
    "        return self.crypt(block, key=self.key)\n",
    "\n",
    "    def crypt(self, block: str, key):\n",
    "        encrypted = ['a'] * len(self.key)\n",
    "        for index, letter in enumerate(block):\n",
    "            encrypted[key[index]] = letter\n",
    "        return ''.join(encrypted)\n",
    "\n",
    "    def get_decryption_permutation(self):\n",
    "        permutation = [0] * len(self.key)\n",
    "        for index, value in enumerate(self.key):\n",
    "            permutation[value] = index\n",
    "        return permutation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EEMYNTAACTTKONSHITZG\n"
     ]
    }
   ],
   "source": [
    "key_transposition_cipher = KeyedTranspositionCipher(key=[1, 4, 0, 2, 3])\n",
    "ciphertext = key_transposition_cipher.encrypt('enemyattackstonight')\n",
    "print(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enemyattackstonightz\n"
     ]
    }
   ],
   "source": [
    "print(key_transposition_cipher.decrypt(ciphertext))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.2.2 Columnar Transposition Cipher\n",
    "We encrypt a given Plaintext $P$ using first a keyless transposition cipher, then key based permutation cipher then row based unrolling. We get initial plaintext __enemy attacks tonight__. We also have permutation key $K$ as:\n",
    "\n",
    "$$\n",
    "\\begin{pmatrix}\n",
    "3 & 1 & 4 & 5 & 2 \\\\\n",
    "1 & 2 & 3 & 4 & 5\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "We first wrap around the plaintext in a matrix with with $c$ columns where $c = |K|$\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix}\n",
    "e & n & e & m & y \\\\\n",
    "a & t & t & a & c \\\\\n",
    "k & s & t & o & n \\\\\n",
    "i & g & h & t & z\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "We then use the key $K$ to permutate the columns\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix}\n",
    "E & E & M & Y & N \\\\\n",
    "T & A & A & C & T \\\\\n",
    "T & K & O & N & S \\\\\n",
    "H & I & T & Z & G \n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "We then create the ciphertext by reading columns 1-by-one and a simlar pipeline is followed in reverse to obtain plaintext from the ciphertext.\n",
    "\n",
    "$C = ETTHEAKIMAOTYCNZNTSG$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "class ColumnarTranspositionCipher:\n",
    "    def __init__(self, key: list):\n",
    "        self.key = key\n",
    "        self.key_inv = self.inv(key)\n",
    "\n",
    "    def encrypt(self, plaintext: str) -> str:\n",
    "        A = self.str_2_mat(plaintext)\n",
    "        A = A[:, self.key]\n",
    "        return self.mat_2_str(A.T).upper()\n",
    "\n",
    "    def decrypt(self, ciphertext: str) -> str:\n",
    "        C = self.str_2_mat_column_wise(ciphertext)\n",
    "        C = C[:, self.key_inv]\n",
    "        return self.mat_2_str(C).lower()\n",
    "\n",
    "    def str_2_mat_column_wise(self, text: str):\n",
    "        rows, columns = len(self.key), len(text) // len(self.key)\n",
    "        return np.reshape(list(text), (rows, columns)).T\n",
    "\n",
    "    def str_2_mat(self, text: str):\n",
    "        padding = (- (len(text) % len(self.key))) % len(self.key)\n",
    "        text = text + 'z' * padding\n",
    "        rows, columns = len(text) // len(self.key), len(self.key)\n",
    "        return np.reshape(list(text), (rows, columns))\n",
    "\n",
    "    @staticmethod\n",
    "    def inv(key: list) -> list:\n",
    "        inv_key = [0] * len(key)\n",
    "        for index, value in enumerate(key):\n",
    "            inv_key[value] = index\n",
    "        return inv_key\n",
    "\n",
    "    @staticmethod\n",
    "    def mat_2_str(matrix) -> str:\n",
    "        return ''.join(matrix.ravel())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ETTHEAKIMAOTYCNZNTSG\n"
     ]
    }
   ],
   "source": [
    "key_transposition_cipher = ColumnarTranspositionCipher(key=[2, 0, 3, 4, 1])\n",
    "ciphertext = key_transposition_cipher.encrypt('enemyattackstonight')\n",
    "print(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enemyattackstonightz\n"
     ]
    }
   ],
   "source": [
    "print(key_transposition_cipher.decrypt(ciphertext))"
   ]
  }
 ],
 "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}