Python/cryptography/playfire.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f06af5bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.container{width:100%}</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%HTML\n",
    "<style>.container{width:100%}</style>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b73906e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PlayFire:\n",
    "    \"\"\"\n",
    "    PlayFire class implements the Playfair \n",
    "    cipher for encryption and decryption of messages.\n",
    "\n",
    "    The Playfair cipher is a digraph substitution \n",
    "    cipher that encrypts pairs of letters. It requires a key, which\n",
    "    is used to create a 6x6 matrix of letters and \n",
    "    digits, and processes the message in pairs.\n",
    "\n",
    "    Attributes:\n",
    "    key (str): The key used to generate the matrix.\n",
    "    key_matrix (list): The 6x6 matrix used for \n",
    "    encryption and decryption.extra (str): The extra character \n",
    "    used to pad the message if the length is odd (default is 'x').\n",
    "\n",
    "    Methods:\n",
    "    __verify_key(key): Verifies that the key is \n",
    "        valid (contains unique characters).\n",
    "    __make_matrix(): Creates a 6x6 matrix using \n",
    "        the key and the remaining letters/digits.\n",
    "    find_idx(pair): Finds the positions (row and column indices) \n",
    "        of the pair of characters in the matrix.\n",
    "    encrypt(msg): Encrypts the given message using \n",
    "        the Playfair cipher.\n",
    "    decrypt(msg): Decrypts the given encrypted \n",
    "        message using the Playfair cipher.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, key, extra=\"x\"):\n",
    "        \"\"\"\n",
    "        Initializes the PlayFire cipher with a key and \n",
    "            an optional extra character for padding.\n",
    "\n",
    "        Parameters:\n",
    "        key (str): The key to generate the cipher matrix.\n",
    "        extra (str, optional): The character used for \n",
    "            padding the message if its length is odd. Defaults to 'x'.\n",
    "        \"\"\"\n",
    "        self.key = self.__verify_key(key)\n",
    "        self.key_matrix = self.__make_matrix()\n",
    "        self.extra = extra\n",
    "\n",
    "    def __verify_key(self, key):\n",
    "        \"\"\"\n",
    "        Verifies that the provided key contains unique characters.\n",
    "\n",
    "        Parameters:\n",
    "        key (str): The key to verify.\n",
    "\n",
    "        Returns:\n",
    "        str: The valid key if it contains only unique \n",
    "            characters, else prints an error.\n",
    "        \"\"\"\n",
    "        keyy = []\n",
    "        for i in key:\n",
    "            if i not in keyy:\n",
    "                keyy.append(i)\n",
    "        if len(set(key)) == len(key):\n",
    "            return key\n",
    "        else:\n",
    "            print(\"key Error\")\n",
    "\n",
    "    def __make_matrix(self):\n",
    "        \"\"\"\n",
    "        Creates a 6x6 matrix from the key by filling \n",
    "            in remaining characters of the alphabet and digits.\n",
    "\n",
    "        Returns:\n",
    "        list: A 6x6 matrix for encryption and decryption.\n",
    "        \"\"\"\n",
    "        alphanum = list(\"abcdefghijklmnopqrstuvwxyz0123456789\")\n",
    "        key = list(self.key)\n",
    "        xx = key + [i for i in alphanum if i not in key]\n",
    "        mtrx = []\n",
    "        idx = 0\n",
    "        for i in range(6):\n",
    "            t1 = xx[idx : idx + 6]\n",
    "            mtrx.append(t1)\n",
    "            idx = idx + 6\n",
    "        return mtrx\n",
    "\n",
    "    def find_idx(self, pair):\n",
    "        \"\"\"\n",
    "        Finds the row and column indices of the \n",
    "            characters in the matrix.\n",
    "\n",
    "        Parameters:\n",
    "        pair (list): A pair of characters whose \n",
    "            positions are to be found in the matrix.\n",
    "\n",
    "        Returns:\n",
    "        list: A list containing the row and column \n",
    "            indices of both characters in the matrix.\n",
    "        \"\"\"\n",
    "        idxs = [6, 6]\n",
    "        for i in range(6):\n",
    "            for j in range(6):\n",
    "                if i == 5:\n",
    "                    i = -1\n",
    "                if j == 5:\n",
    "                    j = -1\n",
    "                if pair[0] == self.key_matrix[i][j]:\n",
    "                    idxs[0] = [i, j]\n",
    "                if pair[1] == self.key_matrix[i][j]:\n",
    "                    idxs[1] = [i, j]\n",
    "        return idxs\n",
    "\n",
    "    def encrypt(self, msg: str):\n",
    "        \"\"\"\n",
    "        Encrypts the given message using the Playfair cipher.\n",
    "\n",
    "        Parameters:\n",
    "        msg (str): The plaintext message to encrypt.\n",
    "\n",
    "        Returns:\n",
    "        str: The encrypted message.\n",
    "        \"\"\"\n",
    "        msg = list(msg.lower())\n",
    "        if len(msg) % 2 == 1:\n",
    "            msg.append(self.extra)\n",
    "        pairs = []\n",
    "        for i in range(0, len(msg), 2):\n",
    "            pairs.append(msg[i : i + 2])\n",
    "        en_msg = \"\"\n",
    "        for i in pairs:\n",
    "            idxs = self.find_idx(i)\n",
    "            if idxs[0][0] == idxs[1][0]:\n",
    "                en_m = (\n",
    "                    self.key_matrix[idxs[0][0]][idxs[0][1] + 1]\n",
    "                    + self.key_matrix[idxs[0][0]][idxs[1][1] + 1]\n",
    "                )\n",
    "            elif idxs[0][1] == idxs[1][1]:\n",
    "                en_m = (\n",
    "                    self.key_matrix[idxs[0][0] + 1][idxs[0][1]]\n",
    "                    + self.key_matrix[idxs[1][0] + 1][idxs[1][1]]\n",
    "                )\n",
    "            else:\n",
    "                en_m = (\n",
    "                    self.key_matrix[idxs[0][0]][idxs[1][1]]\n",
    "                    + self.key_matrix[idxs[1][0]][idxs[0][1]]\n",
    "                )\n",
    "            en_msg += en_m\n",
    "        return en_msg\n",
    "\n",
    "    def decrypt(self, msg):\n",
    "        \"\"\"\n",
    "        Decrypts the given encrypted message using the Playfair cipher.\n",
    "\n",
    "        Parameters:\n",
    "        msg (str): The encrypted message to decrypt.\n",
    "\n",
    "        Returns:\n",
    "        str: The decrypted plaintext message.\n",
    "        \"\"\"\n",
    "        msg = list(msg.lower())\n",
    "        if len(msg) % 2 == 1:\n",
    "            msg.append(self.extra)\n",
    "        pairs = []\n",
    "        for i in range(0, len(msg), 2):\n",
    "            pairs.append(msg[i : i + 2])\n",
    "        en_msg = \"\"\n",
    "        for i in pairs:\n",
    "            idxs = self.find_idx(i)\n",
    "            if idxs[0][0] == idxs[1][0]:\n",
    "                en_m = (\n",
    "                    self.key_matrix[idxs[0][0]][idxs[0][1] - 1]\n",
    "                    + self.key_matrix[idxs[0][0]][idxs[1][1] - 1]\n",
    "                )\n",
    "            elif idxs[0][1] == idxs[1][1]:\n",
    "                en_m = (\n",
    "                    self.key_matrix[idxs[0][0] - 1][idxs[0][1]]\n",
    "                    + self.key_matrix[idxs[1][0] - 1][idxs[1][1]]\n",
    "                )\n",
    "            else:\n",
    "                en_m = (\n",
    "                    self.key_matrix[idxs[0][0]][idxs[1][1]]\n",
    "                    + self.key_matrix[idxs[1][0]][idxs[0][1]]\n",
    "                )\n",
    "            en_msg += en_m\n",
    "        return en_msg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4b861600",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['m', 'o', 'n', 'a', 'r', 'c'],\n",
       " ['h', 'y', '1', '2', '3', 'b'],\n",
       " ['d', 'e', 'f', 'g', 'i', 'j'],\n",
       " ['k', 'l', 'p', 'q', 's', 't'],\n",
       " ['u', 'v', 'w', 'x', 'z', '0'],\n",
       " ['4', '5', '6', '7', '8', '9']]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pf = PlayFire(key=\"monarchy123\")\n",
    "pf.key_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7c4e1caa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ydppny3b7u'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "msg = \"hello1234\"\n",
    "enc = pf.encrypt(msg)\n",
    "enc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "48c8a847",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello1234x'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pf.decrypt(enc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "62806ee1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'thismy1stdayofcollegeilearntabouteverythingandmetmyfriends'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pf.decrypt(pf.encrypt(\"thismy1stdayofcollegeilearntabouteverythingandmetmyfriends\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a7a9907b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'rx'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pf.decrypt(pf.encrypt(\"r\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fe9dad9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}