notebooks/6-data-encryption-standard-des.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch6: Data Encryption Standard (DES)\n",
    "The Data Encryption Standard (DES) is a symmetric-key algorithm for the encryption of digital data. Although its short key length of 56 bits makes it too insecure for applications, it has been highly influential in the advancement of cryptography.\n",
    "\n",
    "It takes in a 64 bit data message and a 64 bit key which is then converted into a 48 bit key and new keys are created from the 64 bit key in each iteration of size 48 bit. There are 16 iterations or 16 individual rounds of the Fiestel Cipher in the DES Encryption Algorithm and each iteration uses a different 48 bit key derived from the original 64 bit key.\n",
    "\n",
    "Each iteration used both a Mixer and a Swapper, wheras the last iteration; the 16th iteration uses only the Mixer.\n",
    "\n",
    "We define a few utility functions that will be used throughout for converting the integer data to binary strings of fixed block sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def int_to_bin(number: int, block_size=8) -> str:\n",
    "    binary = bin(number)[2:]\n",
    "    return '0' * (block_size - len(binary)) + binary\n",
    "\n",
    "\n",
    "def char_2_num(letter: str) -> int:\n",
    "    return ord(letter) - ord('a')\n",
    "\n",
    "\n",
    "def num_2_char(number: int) -> str:\n",
    "    return chr(ord('a') + number)\n",
    "\n",
    "\n",
    "def mod(a, b):\n",
    "    return a % b\n",
    "\n",
    "\n",
    "def left_circ_shift(binary: str, shift: int) -> str:\n",
    "    shift = shift % len(binary)\n",
    "    return binary[shift:] + binary[0: shift]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.1 P-Box \n",
    "We Now define a Permutation Box that is used heavily in the DES alorithm. The P-Boxes are of 3 types:\n",
    "\n",
    "1. Straight P-Box\n",
    "1. Expansion P-Box\n",
    "1. Compression P-Box\n",
    "\n",
    "It will contain the `permutate()` metod that takes a binary string and will return a transposed output, other _static_ methods define the standard P-Boxes used in the DES Algorithm  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PBox:\n",
    "    def __init__(self, key: dict):\n",
    "        self.key = key\n",
    "        self.in_degree = len(key)\n",
    "        self.out_degree = sum(len(value) if isinstance(value, list) else 1 for value in key.values())\n",
    "\n",
    "    def __repr__(self) -> str:\n",
    "        return 'PBox' + str(self.key)\n",
    "\n",
    "    def permutate(self, sequence: list) -> str:\n",
    "        result = [0] * self.out_degree\n",
    "        for index, value in enumerate(sequence):\n",
    "            if (index + 1) in self.key:\n",
    "                indices = self.key.get(index + 1, [])\n",
    "                indices = indices if isinstance(indices, list) else [indices]\n",
    "                for i in indices:\n",
    "                    result[i - 1] = value\n",
    "        return ''.join(map(str, result))\n",
    "\n",
    "    def is_invertible(self) -> bool:\n",
    "        return self.in_degree == self.out_degree\n",
    "\n",
    "    def invert(self):\n",
    "        if self.is_invertible():\n",
    "            result = {}\n",
    "            for index, mapping in self.key.items():\n",
    "                result[mapping] = index\n",
    "            return PBox(result)\n",
    "\n",
    "    @staticmethod\n",
    "    def identity(block_size=64):\n",
    "        return PBox({index: index for index in range(1, block_size + 1)})\n",
    "\n",
    "    @staticmethod\n",
    "    def from_list(permutation: list):\n",
    "        mapping = {}\n",
    "        for index, value in enumerate(permutation):\n",
    "            indices = mapping.get(value, [])\n",
    "            indices.append(index + 1)\n",
    "            mapping[value] = indices\n",
    "        return PBox(mapping)\n",
    "\n",
    "    @staticmethod\n",
    "    def des_initial_permutation():\n",
    "        return PBox.from_list(\n",
    "            [58, 50, 42, 34, 26, 18, 10, 2,\n",
    "             60, 52, 44, 36, 28, 20, 12, 4,\n",
    "             62, 54, 46, 38, 30, 22, 14, 6,\n",
    "             64, 56, 48, 40, 32, 24, 16, 8,\n",
    "             57, 49, 41, 33, 25, 17, 9, 1,\n",
    "             59, 51, 43, 35, 27, 19, 11, 3,\n",
    "             61, 53, 45, 37, 29, 21, 13, 5,\n",
    "             63, 55, 47, 39, 31, 23, 15, 7]\n",
    "        )\n",
    "\n",
    "    @staticmethod\n",
    "    def des_final_permutation():\n",
    "        return PBox.from_list(\n",
    "            [40, 8, 48, 16, 56, 24, 64, 32,\n",
    "             39, 7, 47, 15, 55, 23, 63, 31,\n",
    "             38, 6, 46, 14, 54, 22, 62, 30,\n",
    "             37, 5, 45, 13, 53, 21, 61, 29,\n",
    "             36, 4, 44, 12, 52, 20, 60, 28,\n",
    "             35, 3, 43, 11, 51, 19, 59, 27,\n",
    "             34, 2, 42, 10, 50, 18, 58, 26,\n",
    "             33, 1, 41, 9, 49, 17, 57, 25]\n",
    "        )\n",
    "\n",
    "    @staticmethod\n",
    "    def des_single_round_expansion():\n",
    "        \"\"\"This is the Permutation made on the right half of the block to convert 32 bit --> 42 bits in DES Mixer\"\"\"\n",
    "        return PBox.from_list(\n",
    "            [32, 1, 2, 3, 4, 5,\n",
    "             4, 5, 6, 7, 8, 9,\n",
    "             8, 9, 10, 11, 12, 13,\n",
    "             12, 13, 14, 15, 16, 17,\n",
    "             16, 17, 18, 19, 20, 21,\n",
    "             20, 21, 22, 23, 24, 25,\n",
    "             24, 25, 26, 27, 28, 29,\n",
    "             28, 29, 30, 31, 32, 1]\n",
    "        )\n",
    "\n",
    "    @staticmethod\n",
    "    def des_single_round_final():\n",
    "        \"\"\"This is the permutation made after the substitution happens in each round\"\"\"\n",
    "        return PBox.from_list(\n",
    "            [16, 7, 20, 21, 29, 12, 28, 17,\n",
    "             1, 15, 23, 26, 5, 18, 31, 10,\n",
    "             2, 8, 24, 14, 32, 27, 3, 9,\n",
    "             19, 13, 30, 6, 22, 11, 4, 25]\n",
    "        )\n",
    "\n",
    "    @staticmethod\n",
    "    def des_key_initial_permutation():\n",
    "        return PBox.from_list(\n",
    "            [57, 49, 41, 33, 25, 17, 9,\n",
    "             1, 58, 50, 42, 34, 26, 18,\n",
    "             10, 2, 59, 51, 43, 35, 27,\n",
    "             19, 11, 3, 60, 52, 44, 36,\n",
    "             63, 55, 47, 39, 31, 23, 15,\n",
    "             7, 62, 54, 46, 38, 30, 22,\n",
    "             14, 6, 61, 53, 45, 37, 29,\n",
    "             21, 13, 5, 28, 20, 12, 4]\n",
    "        )\n",
    "\n",
    "    @staticmethod\n",
    "    def des_shifted_key_permutation():\n",
    "        \"\"\"PC2 Matrix for compression PBox 56 bit --> 48 bit\"\"\"\n",
    "        return PBox.from_list(\n",
    "            [14, 17, 11, 24, 1, 5, 3, 28,\n",
    "             15, 6, 21, 10, 23, 19, 12, 4,\n",
    "             26, 8, 16, 7, 27, 20, 13, 2,\n",
    "             41, 52, 31, 37, 47, 55, 30, 40,\n",
    "             51, 45, 33, 48, 44, 49, 39, 56,\n",
    "             34, 53, 46, 42, 50, 36, 29, 32]\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Permutation: 000000000000000000000000000000001001011010100100\n",
      "Output Length: 48\n"
     ]
    }
   ],
   "source": [
    "# We can create an expansion box that will expand 32 Bits --> 48 Bits\n",
    "expansion_p_box = PBox.des_single_round_expansion()\n",
    "permutation = expansion_p_box.permutate(int_to_bin(1234, block_size=32))\n",
    "print('Permutation:', permutation)\n",
    "print('Output Length:', len(permutation))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "phle\n"
     ]
    }
   ],
   "source": [
    "# We can create a straight P-Box\n",
    "straight_p_box = PBox.from_list([4, 1, 3, 2])\n",
    "p = straight_p_box.permutate('help')\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vvol\n"
     ]
    }
   ],
   "source": [
    "# we can also create compression P-Boxes\n",
    "compression_box = PBox.from_list([3, 3, 2, 1])\n",
    "p = compression_box.permutate('love')\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.2 S-Box\n",
    "Substitution Boxes use a table to compare __row__ and __column__ that is derived from a given binary string using a function that will return a tuple (__row__, __column__). The output is also a binary string.\n",
    "\n",
    "We define in our SBox our substitution table and the function that divides input into __row__ and __column__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SBox:\n",
    "    def __init__(self, table: dict, block_size=4, func=lambda binary: (binary[0] + binary[5], binary[1:5])):\n",
    "        self.table = table\n",
    "        self.block_size = block_size\n",
    "        self.func = func\n",
    "\n",
    "    def __call__(self, binary: str) -> str:\n",
    "        a, b = self.func(binary)\n",
    "        a, b = int(a, base=2), int(b, base=2)\n",
    "        if (a, b) in self.table:\n",
    "            return int_to_bin(self.table[(a, b)], block_size=self.block_size)\n",
    "        else:\n",
    "            return binary\n",
    "\n",
    "    @staticmethod\n",
    "    def des_single_round_substitutions():\n",
    "        return [SBox.forDESSubstitution(block) for block in range(1, 9)]\n",
    "\n",
    "    @staticmethod\n",
    "    def identity():\n",
    "        return SBox(func=lambda binary: ('0', '0'), table={})\n",
    "\n",
    "    @staticmethod\n",
    "    def forDESSubstitution(block):\n",
    "        if block == 1: return SBox.des_s_box1()\n",
    "        if block == 2: return SBox.des_s_box2()\n",
    "        if block == 3: return SBox.des_s_box3()\n",
    "        if block == 4: return SBox.des_s_box4()\n",
    "        if block == 5: return SBox.des_s_box5()\n",
    "        if block == 6: return SBox.des_s_box6()\n",
    "        if block == 7: return SBox.des_s_box7()\n",
    "        if block == 8: return SBox.des_s_box8()\n",
    "\n",
    "    @staticmethod\n",
    "    def des_confusion(binary: str) -> tuple:\n",
    "        \"\"\"\"Takes a 6-bit binary string as input and returns a 4-bit binary string as output\"\"\"\n",
    "        return binary[0] + binary[5], binary[1: 5]\n",
    "\n",
    "    @staticmethod\n",
    "    def from_list(sequence: list):\n",
    "        mapping = {}\n",
    "        for row in range(len(sequence)):\n",
    "            for column in range(len(sequence[0])):\n",
    "                mapping[(row, column)] = sequence[row][column]\n",
    "        return SBox(table=mapping)\n",
    "\n",
    "    @staticmethod\n",
    "    def des_s_box1():\n",
    "        return SBox.from_list(\n",
    "            [[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],\n",
    "             [0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],\n",
    "             [4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],\n",
    "             [15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]]\n",
    "        )\n",
    "\n",
    "    @staticmethod\n",
    "    def des_s_box2():\n",
    "        return SBox.from_list(\n",
    "            [[15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],\n",
    "             [3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],\n",
    "             [0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],\n",
    "             [13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]]\n",
    "        )\n",
    "\n",
    "    @staticmethod\n",
    "    def des_s_box3():\n",
    "        return SBox.from_list(\n",
    "            [[10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],\n",
    "             [13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],\n",
    "             [13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],\n",
    "             [1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]]\n",
    "        )\n",
    "\n",
    "    @staticmethod\n",
    "    def des_s_box4():\n",
    "        return SBox.from_list(\n",
    "            [[7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],\n",
    "             [13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9],\n",
    "             [10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],\n",
    "             [3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]]\n",
    "        )\n",
    "\n",
    "    @staticmethod\n",
    "    def des_s_box5():\n",
    "        return SBox.from_list(\n",
    "            [[2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],\n",
    "             [14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],\n",
    "             [4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],\n",
    "             [11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]]\n",
    "        )\n",
    "\n",
    "    @staticmethod\n",
    "    def des_s_box6():\n",
    "        return SBox.from_list(\n",
    "            [[12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],\n",
    "             [10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],\n",
    "             [9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],\n",
    "             [4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]]\n",
    "        )\n",
    "\n",
    "    @staticmethod\n",
    "    def des_s_box7():\n",
    "        return SBox.from_list(\n",
    "            [[4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],\n",
    "             [13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],\n",
    "             [1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],\n",
    "             [6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]]\n",
    "        )\n",
    "\n",
    "    @staticmethod\n",
    "    def des_s_box8():\n",
    "        return SBox.from_list(\n",
    "            [[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],\n",
    "             [1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],\n",
    "             [7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],\n",
    "             [2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]]\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "101\n",
      "110\n",
      "1000\n",
      "111\n"
     ]
    }
   ],
   "source": [
    "# We craete a custom SBox with our own function\n",
    "s_box = SBox(block_size=2, table={\n",
    "    (0, 0): 5,\n",
    "    (0, 1): 6,\n",
    "    (1, 0): 8,\n",
    "    (1, 1): 7\n",
    "}, func=lambda x: (x[0], x[1]))\n",
    "\n",
    "print(s_box('00'))\n",
    "print(s_box('01'))\n",
    "print(s_box('10'))\n",
    "print(s_box('11'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1101\n"
     ]
    }
   ],
   "source": [
    "# We can use inbuilt des 1st substitution SBox to compress 6 bit --> 4 bit binary strings\n",
    "s_box2 = SBox.des_s_box1()\n",
    "binary = '000100'\n",
    "print(s_box2(binary))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.3 Swapper\n",
    "We now define a swapper which will take in a binary string. Divide the string into 2 parts and returns a swapped binary string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Swapper:\n",
    "    def __init__(self, block_size=64):\n",
    "        self.block_size = block_size\n",
    "\n",
    "    def encrypt(self, binary: str) -> str:\n",
    "        l, r = binary[0: self.block_size // 2], binary[self.block_size // 2:]\n",
    "        return r + l\n",
    "\n",
    "    def decrypt(self, binary: str) -> str:\n",
    "        return self.encrypt(binary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00001111\n"
     ]
    }
   ],
   "source": [
    "swapper = Swapper(block_size=8)\n",
    "ciphertext = swapper.encrypt('11110000')\n",
    "print(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11110000\n"
     ]
    }
   ],
   "source": [
    "# We can also decrypt this encrypted binary string\n",
    "print(swapper.decrypt(ciphertext))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0000000000000000000000000110010000000000000000000000000000000000\n"
     ]
    }
   ],
   "source": [
    "# We can create a 64 bit swapper that is used extensively in the DES algorithm\n",
    "swapper_64_bit = Swapper()\n",
    "ciphertext = swapper_64_bit.encrypt(int_to_bin(100, block_size=64))\n",
    "print(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We now decrypt it\n",
    "int(swapper_64_bit.decrypt(ciphertext), base=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.4 Null Swapper\n",
    "The Null Swapper isn't a cryptographical object but rather an Object we have created to have the same API as the `Swapper` so that we can plug in the `NoneSwapper` in place of the `Swapper` class when we wish to create a cipher that doesn't swap bit blocks.\n",
    "\n",
    "> It serves no purpose in the algorithm. It simple provides us a mechanism to create a Fiestel Round wihout swapping which we shall see later on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NoneSwapper:\n",
    "    def encrypt(self, binary: str) -> str:\n",
    "        return binary\n",
    "\n",
    "    def decrypt(self, binary: str) -> str:\n",
    "        return binary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1001'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# It doesn't change the binary block during encryption or decryption\n",
    "swapper = NoneSwapper()\n",
    "swapper.encrypt('1001')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1001'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "swapper.decrypt('1001')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.5 Mixer\n",
    "The Mixer takes in a binary block of fixed length and divides in into 2 parts. The right part is then combined with the key and  a non-invertible function is performed on the right part and key. The result is then XORed (^) with the left part.\n",
    "\n",
    "The end results are\n",
    "```text\n",
    "l = l ^ f(r, K)\n",
    "r = r\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mixer:\n",
    "    def __init__(self, key: int, func=lambda a, b: a % b, block_size=64,\n",
    "                 initial_permutation=None, final_permutation=None,\n",
    "                 substitutions: list = None, substitution_block_size=6):\n",
    "        self.func = func\n",
    "        self.block_size = block_size\n",
    "        self.initial_permutation = PBox.identity(block_size // 2) if initial_permutation is None else initial_permutation\n",
    "        self.final_permutation = PBox.identity(block_size // 2) if final_permutation is None else final_permutation\n",
    "        self.substitutions = SBox.des_single_round_substitutions() if substitutions is None else substitutions\n",
    "        self.substitution_block_size = substitution_block_size\n",
    "        self.key = key\n",
    "\n",
    "    def encrypt(self, binary: str) -> str:\n",
    "        l, r = binary[0: self.block_size // 2], binary[self.block_size // 2:]\n",
    "        # expansion PBox\n",
    "        r1: str = self.initial_permutation.permutate(r)\n",
    "\n",
    "        # applying function\n",
    "        r2: str = int_to_bin(self.func(int(r1, base=2), self.key), block_size=self.initial_permutation.out_degree)\n",
    "\n",
    "        # applying the substitution matrices\n",
    "        r3: str = ''\n",
    "        for i in range(len(self.substitutions)):\n",
    "            block: str = r2[i * self.substitution_block_size: (i + 1) * self.substitution_block_size]\n",
    "            r3 += self.substitutions[i](block)\n",
    "\n",
    "        # applying final permutation\n",
    "        r3: str = self.final_permutation.permutate(r3)\n",
    "\n",
    "        # applying xor\n",
    "        l = int_to_bin(int(l, base=2) ^ int(r3, base=2), block_size=self.block_size // 2)\n",
    "        return l + r\n",
    "\n",
    "    def decrypt(self, binary:str) -> str:\n",
    "        return self.encrypt(binary)\n",
    "\n",
    "    @staticmethod\n",
    "    def des_mixer(key: int):\n",
    "        return Mixer(\n",
    "          key=key,\n",
    "          initial_permutation=PBox.des_single_round_expansion(),\n",
    "          final_permutation=PBox.des_single_round_final(),\n",
    "          func=lambda a, b: a % b\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plaintext: 0000000000000000000000000000000000000000000000000000010011010010\n"
     ]
    }
   ],
   "source": [
    "# We craete a DES specific mixer. That means that the block_size will be 64 and DES specific PBoxes and SBoxes will be used.\n",
    "# Also we use the mod function when performing a non-invertible operation over r ad Key hence f = r % Key\n",
    "mixer = Mixer.des_mixer(key=3)\n",
    "number = 1234\n",
    "binary = int_to_bin(number, block_size=64)\n",
    "print('Plaintext:', binary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ciphrtext: 1101000011011010110100111001110000000000000000000000010011010010\n"
     ]
    }
   ],
   "source": [
    "ciphertext = mixer.encrypt(binary)\n",
    "print('Ciphrtext:', ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decrypted: 0000000000000000000000000000000000000000000000000000010011010010\n"
     ]
    }
   ],
   "source": [
    "# decrypting using the Mixer\n",
    "decrypted = mixer.decrypt(ciphertext)\n",
    "print('Decrypted:', decrypted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1234\n"
     ]
    }
   ],
   "source": [
    "# printing the integer based output\n",
    "print(int(decrypted, base=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.6 Round\n",
    "A Sigle Fiestel Round employs both the Mixer and the Swapper Cipher. Both ciphers are performed in succession (one after the other) __Mixer__ --> __Swapper__ and the inverse during decryption.\n",
    "\n",
    "We can also have a Fiestel Round with just the Mixer and no swapping, which will be equivalent to just one Mixer. We define 2 factory methods:\n",
    "\n",
    "1. `with_swapper`: That returns a Fiestel Round Cipher object that uses both a Mixer and a Swapper to encrypt and decrypt data.\n",
    "1. `without_swapper`: That returns a Fiestel Round Cipher object that usesonly  a Mixer to encrypt and decrypt data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Round:\n",
    "    def __init__(self, mixer):\n",
    "        self.mixer = mixer\n",
    "        self.swapper = NoneSwapper()\n",
    "\n",
    "    @staticmethod\n",
    "    def with_swapper(mixer: Mixer):\n",
    "        temp = Round(mixer)\n",
    "        temp.swapper = Swapper(block_size=mixer.block_size)\n",
    "        return temp\n",
    "\n",
    "    @staticmethod\n",
    "    def without_swapper(mixer: Mixer):\n",
    "        return Round(mixer)\n",
    "\n",
    "    def encrypt(self, binary: str) -> str:\n",
    "        binary = self.mixer.encrypt(binary)\n",
    "        return self.swapper.encrypt(binary)\n",
    "\n",
    "    def decrypt(self, binary: str) -> str:\n",
    "        binary = self.swapper.decrypt(binary)\n",
    "        return self.mixer.decrypt(binary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ciphertext: 1101000011011000110100111011110000000000000000000011000000111001\n"
     ]
    }
   ],
   "source": [
    "number = 12345\n",
    "binary = int_to_bin(number, block_size=64)\n",
    "round1 = Round.without_swapper(Mixer.des_mixer(key=17))\n",
    "ciphertext = round1.encrypt(binary)\n",
    "print('Ciphertext:', ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decrypted Number: 12345\n"
     ]
    }
   ],
   "source": [
    "print('Decrypted Number:', int(round1.decrypt(ciphertext), base=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ciphertext: 0000000000000000001100000011100111010000110110001101001110111100\n"
     ]
    }
   ],
   "source": [
    "# We can also create a Fiestel Round with swapping\n",
    "number = 12345\n",
    "binary = int_to_bin(number, block_size=64)\n",
    "round1 = Round.with_swapper(Mixer.des_mixer(key=17))\n",
    "ciphertext = round1.encrypt(binary)\n",
    "print('Ciphertext:', ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decrypted Number: 12345\n"
     ]
    }
   ],
   "source": [
    "print('Decrypted Number:', int(round1.decrypt(ciphertext), base=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.6 DES\n",
    "We now impliment the DES algorithm which consists of 16 Fiestel rounds. We use the predefined `SBox` and `PBox` classes and also the `Round` cipher class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DES:\n",
    "    def __init__(self, key: int):\n",
    "        self.key = int_to_bin(key, block_size=64)\n",
    "        self.PC_1 = PBox.des_key_initial_permutation()\n",
    "        self.PC_2 = PBox.des_shifted_key_permutation()\n",
    "        self.single_shift = {1, 2, 9, 16}\n",
    "        self.rounds = self.generate_rounds()\n",
    "\n",
    "    def encrypt(self, binary: str) -> str:\n",
    "        for round in self.rounds:\n",
    "            binary = round.encrypt(binary)\n",
    "        return binary\n",
    "\n",
    "    def decrypt(self, binary: str) -> str:\n",
    "        for round in self.rounds[::-1]:\n",
    "            binary = round.decrypt(binary)\n",
    "        return binary\n",
    "\n",
    "    def encrypt_message(self, plaintext: str) -> list:\n",
    "        result = [0] * len(plaintext)\n",
    "        for index, letter in enumerate(plaintext.lower()):\n",
    "            result[index] = int(self.encrypt(int_to_bin(ord(letter), block_size=64)), base=2)\n",
    "        return result\n",
    "\n",
    "    def decrypt_message(self, ciphertext_stream: list) -> str:\n",
    "        return ''.join(map(chr, self.plaintext_stream(ciphertext_stream)))\n",
    "\n",
    "    def plaintext_stream(self, ciphertext_stream: list) -> list:\n",
    "        return [int(self.decrypt(int_to_bin(number, block_size=64)), base=2) for number in ciphertext_stream]\n",
    "\n",
    "    def generate_rounds(self) -> list:\n",
    "        rounds = []\n",
    "        self.key = self.PC_1.permutate(self.key)\n",
    "        l, r = self.key[0: 32], self.key[32:]\n",
    "        for i in range(1, 17):\n",
    "            shift = 1 if i in self.single_shift else 2\n",
    "            l, r = left_circ_shift(l, shift), left_circ_shift(r, shift)\n",
    "            key = int(self.PC_2.permutate(l + r), base=2)\n",
    "            mixer = Mixer.des_mixer(key)\n",
    "            cipher = Round.with_swapper(mixer) if i != 16 else Round.without_swapper(mixer)\n",
    "            rounds.append(cipher)\n",
    "        return rounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plaintext: 0000000000000000000000000000000000000000000000000011000000111001\n",
      "Ciphertext: 0111100100111011001111010010010100101001101110001101101010100110\n"
     ]
    }
   ],
   "source": [
    "# We create an instance of DES with a key and use it to enciphr and decipher 64 bit binary data\n",
    "number = 12345\n",
    "binary = int_to_bin(number, block_size=64)\n",
    "des = DES(key=78)\n",
    "ciphertext = des.encrypt(binary)\n",
    "print('Plaintext:', binary)\n",
    "print('Ciphertext:', ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decrypted: 0000000000000000000000000000000000000000000000000011000000111001\n"
     ]
    }
   ],
   "source": [
    "# We now decipher the ciphertext\n",
    "decrypted = des.decrypt(ciphertext)\n",
    "print('Decrypted:', decrypted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value: 12345\n"
     ]
    }
   ],
   "source": [
    "# Checking value of decrypted\n",
    "print('Value:', int(decrypted, base=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plaintext: hello world 😀\n",
      "Ciphertext: [9253891819891440400, 14118313512560970, 3982981733458429922, 3982981733458429922, 16835800272982933939, 16367344448200892497, 14303274998317469877, 16835800272982933939, 10048292260086069323, 3982981733458429922, 5262255425266249560, 16367344448200892497, 4133802428460097780]\n"
     ]
    }
   ],
   "source": [
    "# We can also use the encrypt_message API to encrypt and decrypt string messages\n",
    "message = 'hello world 😀'\n",
    "ciphertext = des.encrypt_message(message)\n",
    "print('Plaintext:', message)\n",
    "print('Ciphertext:', ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decrypted: hello world 😀\n"
     ]
    }
   ],
   "source": [
    "# We see that teh ciphertext we get above is a stream of 64 bit integer numbers. We can also decrypt our message\n",
    "decrypted = des.decrypt_message(ciphertext)\n",
    "print('Decrypted:', decrypted)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}