notebooks/5-introduction-to-modern-symmetric-key-ciphers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch5: Introduction To Modern Symmetric Key Ciphers\n",
    "## 5.1 Permutation Box \n",
    "A Permutation Box is a transposition Cipher that takes in a permutation and reorders the bits or a block of data in as per the permutation. There can be 3 types of PBox's:\n",
    "\n",
    "1. Straigt P-Box (is invertible)\n",
    "2. Compression P-Box (is non-invertible)\n",
    "3. Expansion P-Box (is non-invertible)\n",
    "\n",
    "We define a class `PBox` and define the permutation mapping for all 3 types of P-Boxes using a python dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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) -> list:\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 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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In Degree: 3\n",
      "Out Degree: 2\n",
      "[10, 30]\n"
     ]
    }
   ],
   "source": [
    "# Compression P-Box\n",
    "compression_p_box = PBox({1: 1, 2: [], 3: 2})\n",
    "print('In Degree:', compression_p_box.in_degree)\n",
    "print('Out Degree:', compression_p_box.out_degree)\n",
    "print(compression_p_box.permutate([10, 20, 30]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# Compression boxes are non-invertible\n",
    "print(compression_p_box.is_invertible())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PBox{1: 1, 2: 2, 3: [3, 4]}\n",
      "In Degree: 3\n",
      "Out Degree: 4\n",
      "[10, 20, 30, 30]\n"
     ]
    }
   ],
   "source": [
    "# Expansion P Box\n",
    "expansion_p_box = PBox({1: 1, 2: 2, 3: [3, 4]})\n",
    "print(expansion_p_box)\n",
    "print('In Degree:', expansion_p_box.in_degree)\n",
    "print('Out Degree:', expansion_p_box.out_degree)\n",
    "print(expansion_p_box.permutate([10, 20, 30]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# Expansion P Boxes are non invertible\n",
    "print(expansion_p_box.is_invertible())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In Degree: 3\n",
      "Out Degree: 3\n",
      "[20, 30, 10]\n"
     ]
    }
   ],
   "source": [
    "# Straight P Boxes\n",
    "p_box = PBox({1: 3, 2: 1, 3: 2})\n",
    "print('In Degree:', p_box.in_degree)\n",
    "print('Out Degree:', p_box.out_degree)\n",
    "print(p_box.permutate([10, 20, 30]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "Inverse: PBox{3: 1, 1: 2, 2: 3}\n"
     ]
    }
   ],
   "source": [
    "# straight P boxes are invertible\n",
    "print(p_box.is_invertible())\n",
    "print('Inverse:', p_box.invert())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30]\n"
     ]
    }
   ],
   "source": [
    "# composition of pemutation and inverse leads in the identity permutations\n",
    "print(p_box.invert().permutate(p_box.permutate([10, 20, 30])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.2 Feistel Cipher\n",
    "The Feistel Cipher is a product cipher and uses many different coomponents, even non-invertible components in the cipher. The non-invertible part is called the __mixer__ and uses the _XOR_ function to encrypt and decrypt a number using a secret key (also a number)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FiestelMixerCipher:\n",
    "    def __init__(self, key: int):\n",
    "        self.key = key\n",
    "\n",
    "    def encrypt(self, number: int) -> int:\n",
    "        return number ^ self.key\n",
    "\n",
    "    def decrypt(self, number: int) -> int:\n",
    "        return self.encrypt(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "fiestel_mixer = FiestelMixerCipher(key=9)\n",
    "ciphertext = fiestel_mixer.encrypt(10)\n",
    "print(ciphertext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(fiestel_mixer.decrypt(ciphertext))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the Feistel cipher we can do many consecutive rounds of encryption wherin each encryption has a non-invertible function and also a swap operation. Below we define a single Instance of the `Round` class which will later on be used to compose a Feistel Cipher. \n",
    "\n",
    "A Fiestel Cipher with __n__ rounds is called a _n round Fiestel Cipher_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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",
    "class Round:\n",
    "    def __init__(self, key: int, func, block_size=8):\n",
    "        # key = int_to_bin(key)\n",
    "        self.key = key\n",
    "        self.func = func\n",
    "        self.block_size = block_size\n",
    "\n",
    "    def encrypt(self, plaintext_number: int) -> int:\n",
    "        l1, r1 = self.binary_fragments(plaintext_number, self.block_size // 2)\n",
    "        f1 = self.func(r1, self.key)\n",
    "        r2 = f1 ^ l1\n",
    "        l2 = r1\n",
    "        result = int_to_bin(l2, self.block_size // 2) + int_to_bin(r2, self.block_size // 2)\n",
    "        return int(result, base=2)\n",
    "\n",
    "    def decrypt(self, cipher_number: int) -> int:\n",
    "        l2, r2 = self.binary_fragments(cipher_number, self.block_size // 2)\n",
    "        f = self.func(r2, self.key)\n",
    "        l1 = r2 ^ f\n",
    "        r1 = l2\n",
    "        result = int_to_bin(l1, self.block_size // 2) + int_to_bin(r1, self.block_size // 2)\n",
    "        return int(result, base=2)\n",
    "\n",
    "    @staticmethod\n",
    "    def binary_fragments(number, block_size=4):\n",
    "        binary = int_to_bin(number, 2 * block_size)\n",
    "        l = binary[0: block_size]\n",
    "        r = binary[block_size:]\n",
    "        return int(l, base=2), int(r, base=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#We define a function that will be passed as an argument and the Round Cipher can be composed using the function\n",
    "def polynomial_mod(p1: int, p2: int) -> int:\n",
    "    return p1 % p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plaintext number: 25\n"
     ]
    }
   ],
   "source": [
    "round_cipher = Round(key=15, func=polynomial_mod, block_size=32)\n",
    "letter = 'z'\n",
    "plaintext_number = char_2_num(letter)\n",
    "print('plaintext number:', plaintext_number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ciphertext number: 1638410\n"
     ]
    }
   ],
   "source": [
    "# We now encrypt our data using a single instance of the Round Cipher\n",
    "ciphertext_number = round_cipher.encrypt(plaintext_number)\n",
    "print('ciphertext number:', ciphertext_number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "decrypted: 25\n"
     ]
    }
   ],
   "source": [
    "# We decrypt the number using the cipher\n",
    "decrypted = round_cipher.decrypt(ciphertext_number)\n",
    "print('decrypted:', decrypted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An implimentation of Fiestel Cipher with multiple Rounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FiestelCipher:\n",
    "    def __init__(self, rounds: list):\n",
    "        self.rounds = rounds\n",
    "\n",
    "    def encrypt(self, plain_number: int) -> list:\n",
    "        for round in self.rounds:\n",
    "            plain_number = round.encrypt(plain_number)\n",
    "        return plain_number\n",
    "\n",
    "    def decrypt(self, cipher_number):\n",
    "        for round in self.rounds[::-1]:\n",
    "            cipher_number = round.decrypt(cipher_number)\n",
    "        return cipher_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We create an instance of the Fiestel Cipher with 2 rounds\n",
    "def polynomial_mod(p1: int, p2: int) -> int:\n",
    "    return p1 % p2\n",
    "\n",
    "\n",
    "fiestel_cipher = FiestelCipher([\n",
    "    Round(key=3, func=polynomial_mod, block_size=32),\n",
    "    Round(key=7, func=polynomial_mod, block_size=128)\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29014219670751100192948230\n"
     ]
    }
   ],
   "source": [
    "# we encrypt our message using a 2-round fiestel cipher\n",
    "message = 24\n",
    "cipher_number = fiestel_cipher.encrypt(message)\n",
    "print(cipher_number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "# We decrypt using our Cipher\n",
    "decrypted = fiestel_cipher.decrypt(cipher_number)\n",
    "print(decrypted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.3 Modern Stream Ciphers\n",
    "Stream Ciphers work upon streams of characters/bits of the data and act on one letter/bit at a time rather than acting on a block of fixed size.\n",
    "\n",
    "### 5.3.1 Synchronous Stream Ciphers\n",
    "In a synchronous stream cipher, the key stream is independent of the plaintext or ciphertext stream. Some examples of a synchronous stream ciphers are:\n",
    "\n",
    "1. Vignere Cipher\n",
    "1. One Time Pad Cipher \n",
    "\n",
    "### 5.3.2 Asynchronous Stream Ciphers"
   ]
  }
 ],
 "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
}