RSA-Toolbox-Code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RSA (cryptosystem) Toolbox"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mohammed Alsailani\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr />\n",
    "\n",
    "# Table of Contents\n",
    "\n",
    "### 1. Introduction\n",
    "\n",
    "### 2. RSA Code Package \n",
    "###### &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 2.1 Basic tool set\n",
    "###### &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 2.2 First tool set\n",
    "###### &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 2.3 Second tool set\n",
    "\n",
    "### 3. RSA More Code\n",
    "\n",
    "###### &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;  Encode\n",
    "###### &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;  Decode\n",
    "\n",
    "### 4. Demo\n",
    "\n",
    "### 5. How to break codes \n",
    "\n",
    "### 6. Multithreading code breaking code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### 1. Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we provide step by step how to build an RSA package for encrypting and decrypting messages. \n",
    "\n",
    "RSA is considered asymmetric encryption, where we have public and private keys. The private keys are used to decrypt messages while public keys are used to encrypt messages. RSA was called after its inventors  (Rivest–Shamir–Adleman).\n",
    "\n",
    "You can share with others your public RSA key if it is secure enough. They can encrypt any messages for you, and you can use your private key to decrypt messages.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1\n",
    "#### Basic tool set\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q.E.D\n"
     ]
    }
   ],
   "source": [
    "def Convert_Text(_string):\n",
    "    #define empty list then convert every character in the input to ascii and append it to integer_list \n",
    "    #then retun the ascii list\n",
    "    integer_list = []\n",
    "    for i in _string: \n",
    "        integer_list.append(ord(i))\n",
    "    return integer_list\n",
    "#test code\n",
    "assert Convert_Text(\"hello\")==[104, 101, 108, 108, 111], 'Incorrect result' \n",
    "print(\"Q.E.D\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q.E.D\n"
     ]
    }
   ],
   "source": [
    "def Convert_Num(_list):\n",
    "    #define empty string \n",
    "    #convert every ascii integer in the input to string and add it the end of the sting\n",
    "    #then return the text string.\n",
    "    _string = ''\n",
    "    for i in _list: \n",
    "        _string += chr(i)\n",
    "    return _string\n",
    "\n",
    "\n",
    "#test code\n",
    "assert Convert_Num([104, 101, 108, 108, 111]) == 'hello', 'Incorrect result'\n",
    "print(\"Q.E.D\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q.E.D\n"
     ]
    }
   ],
   "source": [
    "def Convert_Binary_String(_int):\n",
    "\n",
    "    bits=\"\" #empty sting to store results\n",
    "    \n",
    "    #while int >  0, add the remainder to results string and update the input by doing integer division by two\n",
    "    while (_int > 0):  \n",
    "        sigDig = _int % 2\n",
    "        _int=_int // 2\n",
    "        \n",
    "        bits=bits+str(sigDig)\n",
    "        \n",
    "    \n",
    "    bits = bits[::-1] # flip order of list\n",
    "    \n",
    "    return bits\n",
    "\n",
    "#test code\n",
    "assert Convert_Binary_String(345) == \"101011001\", 'Incorrect result'\n",
    "print(\"Q.E.D\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 \n",
    "#### First tool set.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q.E.D\n"
     ]
    }
   ],
   "source": [
    "def FME(b, n, m):\n",
    "\n",
    "    \n",
    "    #initialize the result to 1 and start with b then repeatdly square\n",
    "    result = 1 \n",
    "    square=b \n",
    "        \n",
    "    while (n>0): #loop to convert to binary, stop when quotient is 0,get the least sig. bit in order and update the quotient\n",
    "        k = n % 2 \n",
    "        n= n//2 \n",
    "        if k == 1:  #if bit is 1, update results\n",
    "            result = (result * square) % m\n",
    "        square = (square * square) % m #repeatedly square b and find remainder\n",
    "        \n",
    "    return result\n",
    "\n",
    "\n",
    "\n",
    "assert FME(4,13,497) == 445, 'Incorrect result'\n",
    "print(\"Q.E.D\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q.E.D\n"
     ]
    }
   ],
   "source": [
    "def Euclidean_Alg(a, b):\n",
    "\n",
    "    while (b>0): # continue while the divisor is not zero.\n",
    "    \n",
    "        #Get quotient and remainder\n",
    "        k = a % b\n",
    "        q = a//b\n",
    "        \n",
    "        #update number a to divisor and b to remainder.\n",
    "        a=b\n",
    "        b=k\n",
    "        \n",
    "    return a #return GCD, a when b is zero\n",
    "\n",
    "\n",
    "#check\n",
    "assert Euclidean_Alg(26,91) == 13, 'Incorrect result'\n",
    "print(\"Q.E.D\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3\n",
    "#### Second tool set\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "def Find_Public_Key_e(p, q):\n",
    "    \n",
    "    #get n\n",
    "    n = p * q\n",
    "    \n",
    "    #warning if n is smaller than 150\n",
    "    if n<150:\n",
    "        print(\"Warning, n is smaller than 150, can't convert all ascii\")\n",
    "    \n",
    "    #fine e\n",
    "    #try max 1000 times until you find e\n",
    "    # e is relativeley prime to (p-1)*(q-1) but not equal to p or q\n",
    "    #keep seeding random e from 11 to 1500\n",
    "    #if the condition found return e\n",
    "    \n",
    "    for i in range(1000):\n",
    "        e=random.randrange(11, n)\n",
    "        if ( (Euclidean_Alg(e, (p-1)*(q-1) ) == 1) and not(e==p or e==q) ):\n",
    "            return(e,n)\n",
    "    print(\"key can't be found after 1000 tries\")\n",
    "\n",
    "#unfortunetly, can't create assert to check the code against a case because it create random e    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q.E.D\n"
     ]
    }
   ],
   "source": [
    "def extended_gcd(m,n):\n",
    "    \n",
    "    (s1,t1)=(1,0) #initalize Bezout Coefficents \n",
    "    (s2,t2)=(0,1)\n",
    "    \n",
    "    while (n>0): # continue while the divisor is not zero.\n",
    "    \n",
    "        #Update GCM\n",
    "        k = m % n\n",
    "        q = m//n\n",
    "        \n",
    "        m=n\n",
    "        n=k\n",
    "        \n",
    "        #update Bezout Coefficents \n",
    "        (s1_hat,t1_hat)=(s2,t2)\n",
    "        (s2_hat,t2_hat)=(s1-q*s2,t1-q*t2)\n",
    "         \n",
    "        \n",
    "        (s1,t1)=(s1_hat,t1_hat)\n",
    "        (s2,t2)= (s2_hat,t2_hat)\n",
    "        \n",
    "    return m, s1, t1 #return GCD and Bezout Coefficents\n",
    "\n",
    "\n",
    "#check\n",
    "assert extended_gcd(26,91) == (13,-3,1), 'Incorrect result'\n",
    "print(\"Q.E.D\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Find_Private_Key_d(e, p, q):\n",
    "\n",
    "    \n",
    "    #calculate n\n",
    "    n=p*q\n",
    "    \n",
    "    \n",
    "    #get the inverse which the Bezouts coefficents s1.\n",
    "    d=extended_gcd(e,(p-1)*(q-1))[1]\n",
    "    \n",
    "    #if inverse is negative add (p-1)*(q-1) until it becomes posotive\n",
    "    while d < 0:\n",
    "        d = d + ( (p-1)*(q-1) )\n",
    "        \n",
    "    \n",
    "    return (d,n)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.\n",
    "#### Putting things all together.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q.E.D\n"
     ]
    }
   ],
   "source": [
    "def Encode(n, e, message):\n",
    "\n",
    "    \n",
    "    #convert message to ascii\n",
    "    message_bin=Convert_Text(message)\n",
    "\n",
    "    #initialize empty list for the cipher text\n",
    "    cipher_text = []\n",
    "    \n",
    "    #for every bin in message encrypt using mapping\n",
    "    for i in message_bin:\n",
    "        cipher_text.append(FME(i,e,n))\n",
    "    \n",
    "    #return cipher text\n",
    "    return cipher_text\n",
    "\n",
    "\n",
    "#check code\n",
    "assert Encode(5251, 3, \"Hello Earth\")==[427, 1105, 4723, 4723, 2371, 1262, 2947, 4250, 762, 1349, 1150], \"Incorrect results\"\n",
    "print(\"Q.E.D\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q.E.D\n"
     ]
    }
   ],
   "source": [
    "def Decode(n, d, cipher_text):\n",
    "    \n",
    "    message = ''\n",
    "    \n",
    "    message_num=[]\n",
    "    \n",
    "    #mapping use the fast modular exponentiation algorithm to decrypt\n",
    "    for i in cipher_text:\n",
    "        message_num.append(FME(i,d,n))\n",
    "    \n",
    "    #convert from ascii to english letter\n",
    "    message=Convert_Num(message_num)\n",
    "    \n",
    "    return message\n",
    "\n",
    "#check code\n",
    "assert Decode(5251, 3403, [427, 1105, 4723, 4723, 2371, 1262, 2947, 4250, 762, 1349, 1150])=='Hello Earth', \"Incorrect\"\n",
    "print(\"Q.E.D\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### 4.  Demo \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Generatign keys\n",
    "\n",
    "The process of generating keys start first by finding p and q that are prime. In addition, the multipicaltion of p and q should be greater 150 to avoid issues with ASCII.\n",
    "\n",
    "The Find_Public_Key_e(p,q) and Find_Private_Key_d(e, p, q) function will generate the keys for you. Be carefull that the private key functions uses the e output from the public key function.\n",
    "\n",
    "In the example below p=43 and q=59.\n",
    "it returns public key (e, n) \n",
    "and the private key (d, n) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Public key\n",
      "e: 433\n",
      "n: 2537 \n",
      "\n",
      "Private key\n",
      "d: 1609\n",
      "n: 2537\n"
     ]
    }
   ],
   "source": [
    "#provide prime p and q that are prime\n",
    "p=43\n",
    "q=59\n",
    "\n",
    "#generate public key\n",
    "e,n = Find_Public_Key_e(p, q)\n",
    "\n",
    "#print public key\n",
    "print(\"Public key\")\n",
    "print(\"e:\", e)\n",
    "print(\"n:\", n,\"\\n\")\n",
    "\n",
    "#generate private key\n",
    "d,n= Find_Private_Key_d(e, p, q)\n",
    "\n",
    "#print private key\n",
    "print(\"Private key\")\n",
    "print(\"d:\", d)\n",
    "print(\"n:\", n)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Encode and decode the same message\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Public key\n",
      "e: 1243\n",
      "n: 2537 \n",
      "\n",
      "Private key\n",
      "d: 2095\n",
      "n: 2537 \n",
      "\n",
      "Origianl message: Hello World \n",
      "\n",
      "Encoded message: [2348, 1906, 352, 352, 2206, 925, 2409, 2206, 115, 352, 1479] \n",
      "\n",
      "Decoded message: Hello World \n",
      "\n",
      "Q.E.D.\n"
     ]
    }
   ],
   "source": [
    "#define p and q that are ptime\n",
    "p=43\n",
    "q=59\n",
    "\n",
    "#generate public key\n",
    "e,n = Find_Public_Key_e(p, q)\n",
    "\n",
    "#print public key\n",
    "print(\"Public key\")\n",
    "print(\"e:\", e)\n",
    "print(\"n:\", n, \"\\n\")\n",
    "\n",
    "#generate private key\n",
    "d,n= Find_Private_Key_d(e, p, q)\n",
    "\n",
    "#print private key\n",
    "print(\"Private key\")\n",
    "print(\"d:\", d)\n",
    "print(\"n:\", n, \"\\n\")\n",
    "\n",
    "# message we want to encrypt\n",
    "Message= \"Hello World\" \n",
    "\n",
    "#print oginal message\n",
    "print(\"Origianl message:\", Message, \"\\n\")\n",
    "\n",
    "\n",
    "#Encoded message and print it:\n",
    "cipher_text=Encode(n,e,Message)\n",
    "print(\"Encoded message:\", cipher_text, \"\\n\")  \n",
    "\n",
    "\n",
    "# decode message back and print it\n",
    "decoded_massage= Decode(n,d,cipher_text) \n",
    "print(\"Decoded message:\", decoded_massage, \"\\n\")\n",
    "\n",
    "\n",
    "\n",
    "#double check decoded_massage is the same as the orignal  message\n",
    "assert decoded_massage == Message\n",
    "\n",
    "print(\"Q.E.D.\") #Q.E.D.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### 5. How to Break Code. \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#build a brute force factorization function to break codes based on the Pseudocode provided above\n",
    "\n",
    "import time\n",
    "\n",
    "def factorize(n):\n",
    "\n",
    "    st = time.time() #set start time\n",
    "\n",
    "    # n is a number, return the smallest factor of n\n",
    "    for i in range(2,n): #search factors from 2 to n\n",
    "        if n % i==0: #if factor is found\n",
    "            et = time.time() #end time\n",
    "            elapsed_time = et - st\n",
    "            return (i,n//i,elapsed_time) #if factor is found return p, q, and computational time\n",
    "        \n",
    "    \n",
    "    #if factor is not found\n",
    "    et = time.time() #end time\n",
    "    elapsed_time = et - st\n",
    "    return (False,elapsed_time) #if prime and can't find a factor return false.\n",
    "\n",
    "\n",
    "assert ( (factorize(4)[0] == 2) and (factorize(4)[1] == 2) ), \"something wrong\" # making sure nothing silly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### 6. Multi threading brute force algorithm for breaking code##\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "#import libraries\n",
    "import time\n",
    "import random\n",
    "import math\n",
    "import threading\n",
    "import matplotlib.pyplot as plt    \n",
    "\n",
    "\n",
    "#brute force algorithm, no threading\n",
    "#modified from the Pseudocode provided above\n",
    "def bf_factorize(n):\n",
    "    \"\"\"\n",
    "    Brute force factorization method\n",
    "    The input is an integer, n.\n",
    "    If n is not prime, it will return factors of n and elapsed time to calculate n. \n",
    "    If n is prime, it will return false, and elapased time to figure n is prime.\n",
    "    \n",
    "    \"\"\"\n",
    "    st = time.time() #set start time\n",
    "\n",
    "    # n is a number, return the smallest factor of n\n",
    "    #search factors from 2 to n\n",
    "    for i in range(2,n): \n",
    "        if n % i==0: #if factor is found\n",
    "            et = time.time() #end time\n",
    "            elapsed_time = et - st\n",
    "            return (i,n//i,elapsed_time) #if factor is found return p, q, and computational time\n",
    "        \n",
    "    \n",
    "    #if factor is not found\n",
    "    et = time.time() #end time\n",
    "    elapsed_time = et - st\n",
    "    return (False,elapsed_time) #if prime and can't find a factor return false.\n",
    "\n",
    "\n",
    "\n",
    "#reuse FME function we built above as it is needed for the PollardRho function\n",
    "def FME(b, n, m):\n",
    "    #initialize the result to 1 and start with b then repeatdly square\n",
    "    result = 1 \n",
    "    square=b \n",
    "        \n",
    "    while (n>0): #loop to convert to binary, stop when quotient is 0,get the least sig. bit in order and update the quotient\n",
    "        k = n % 2 \n",
    "        n= n//2 \n",
    "        if k == 1:  #if bit is 1, update results\n",
    "            result = (result * square) % m\n",
    "        square = (square * square) % m #repeatedly square b and find remainder \n",
    "    return result\n",
    " \n",
    "    \n",
    "# Polland Rho Function modified from geeksforgeeks\n",
    "#https://www.geeksforgeeks.org/pollards-rho-algorithm-prime-factorization/\n",
    "#Note, I am only analyzing the code here for fun.\n",
    "#I added small time function inside\n",
    "def PollardRho( n):\n",
    "    st = time.time() #set start time\n",
    "\n",
    " \n",
    "    # no prime divisor for 1\n",
    "    if (n == 1):\n",
    "        et = time.time() #end time\n",
    "        elapsed_time = et - st   \n",
    "        return n,elapsed_time\n",
    " \n",
    "    # even number means one of the divisors is 2\n",
    "    if (n % 2 == 0):\n",
    "        et = time.time() #end time\n",
    "        elapsed_time = et - st   \n",
    "        return 2,elapsed_time\n",
    " \n",
    "    # we will pick from the range [2, N)\n",
    "    x = (random.randint(0, 2) % (n - 2))\n",
    "    y = x\n",
    " \n",
    "    # the constant in f(x).\n",
    "    # Algorithm can be re-run with a different c\n",
    "    # if it throws failure for a composite.\n",
    "    c = (random.randint(0, 1) % (n - 1))\n",
    " \n",
    "    # Initialize candidate divisor (or result)\n",
    "    d = 1\n",
    " \n",
    "    # until the prime factor isn't obtained.\n",
    "    # If n is prime, return n\n",
    "    while (d == 1):\n",
    "     \n",
    "        # Tortoise Move: x(i+1) = f(x(i))\n",
    "        x = (FME(x, 2, n) + c + n)%n\n",
    " \n",
    "        # Hare Move: y(i+1) = f(f(y(i)))\n",
    "        y = (FME(y, 2, n) + c + n)%n\n",
    "        y = (FME(y, 2, n) + c + n)%n\n",
    " \n",
    "        # check gcd of |x-y| and n\n",
    "        d = math.gcd(abs(x - y), n)\n",
    " \n",
    "        # retry if the algorithm fails to find prime factor\n",
    "        # with chosen x and c\n",
    "        if (d == n):\n",
    "            return PollardRho(n)\n",
    "    \n",
    "    et = time.time() #end time\n",
    "    elapsed_time = et - st    \n",
    "     \n",
    "    return d,elapsed_time\n",
    "\n",
    "\n",
    "#brute force function used my the multi threading function\n",
    "def bf_plus_factorize(n,start,end):\n",
    "    \"\"\"\n",
    "    This is a brute force factorization function\n",
    "    It search for factor within the start and end range you provide\n",
    "    \n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    n : int\n",
    "        number you want to factorize.\n",
    "    start : int\n",
    "        start of seach.\n",
    "    end : int\n",
    "        end of search.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    None. This function only update the global variable listOfFactors and factor_found if needed\n",
    "\n",
    "    \"\"\"\n",
    "    global factor_found #global variable, if factor is found, true if found, false if now\n",
    "    global listOfFactors #stores factors in this global list\n",
    "    \n",
    "    #don't start search with zero or 1, because they are always factors. So correct search start if needed\n",
    "    if (start==0 or start==2):  \n",
    "        start=2\n",
    "        \n",
    "        \n",
    "    # n is a number, return the smallest factor of n\n",
    "    #search factors from start to end (inclusive)\n",
    "    for i in range(start,end+1): \n",
    "        \n",
    "        if factor_found==True:  #if factor is found in any of the threads stop.\n",
    "            return;   \n",
    "            \n",
    "         #if factor is found, append it to the gloabl variable listOfFactors, \n",
    "         #update factor_found to True to stop all other threads\n",
    "         #return the function\n",
    "        if n % i==0:\n",
    "            listOfFactors.append(i)\n",
    "            listOfFactors.append(n//i)\n",
    "            factor_found=True\n",
    "            return\n",
    "        \n",
    "\n",
    "#here comes the fun part.\n",
    "#all code below is written by myself.\n",
    "#I have not looked at any threading function for facorization online. So no idea what is online.\n",
    "\n",
    "def bf_threading_factorize(n,no_threads):\n",
    "    \"\"\"\n",
    "    This is multi threading factorization function.\n",
    "    It split the number you want to factorize into different search segments. Then run brute force algorithm for every search segment\n",
    "    \n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    n : int\n",
    "        integer you want to factorize.\n",
    "    no_threads : int\n",
    "        number of threads you like to perform.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    listOfFactors : List\n",
    "        List contains two factors.\n",
    "    elapsed_time : float\n",
    "        compuational time for the code.\n",
    "\n",
    "    \"\"\"\n",
    "    \n",
    "    st = time.time() #set start time\n",
    "    \n",
    "    global factor_found #global variable to store status if factor is found, true or false\n",
    "    global listOfFactors #lobal variable to store factors\n",
    "    \n",
    "    listOfFactors=[] #list of factors\n",
    "    factor_found=False #initialize factor_found to false. If true stop running the code.\n",
    "\n",
    "\n",
    "    threads=[] #list stores every thread job needed for the join method so we don't return our function early\n",
    "    \n",
    "    sqrt_n=math.ceil(n**(0.5))+1 # we only need to search up to sqrt(n), theorem 2 in the book.\n",
    "\n",
    "    step_size=math.ceil(sqrt_n/no_threads) #step size for seach segments.\n",
    "    \n",
    "    \n",
    "    #create segments or parition for searching for factors using bf_plus_factorize function.\n",
    "    #nunber of partaiton is equal to number of threads\n",
    "    for thread in range(no_threads):\n",
    "        t=threading.Thread(target=bf_plus_factorize, args=((n,int(thread*step_size), int(thread*step_size + step_size-1))) )\n",
    "        t.start()\n",
    "        threads.append(t)\n",
    "    \n",
    "    #don't exit this for loop until you complete running all threads    \n",
    "    for thread in threads:\n",
    "        thread.join()\n",
    "    \n",
    "    #calculate computational time    \n",
    "    et = time.time() #end time\n",
    "    elapsed_time = et - st\n",
    "    \n",
    "    \n",
    "    return (listOfFactors,elapsed_time)\n",
    "        \n",
    "\n",
    "\n",
    "# main function\n",
    "if __name__ == \"__main__\":\n",
    " \n",
    "    #lets start the fun part here!\n",
    "    \n",
    "    #We will analyze the brute force, mutli threading brute force, and Pollard Rho method for factoring numbers. \n",
    "    \n",
    "    #random random modulo numbers with increasing significant digits from Piazza, last one I added it.\n",
    "    modulo_numbers=[323, 667, 1957, 2537, 712031, 19307227, 36904181, 39455893, 8099370991, 999478010521, 999962000357, 13751264097121,4415945413502687]\n",
    "    \n",
    "    \n",
    "    #we fist analyze the number of threads vs computational time fo the mutli threading brute force function\n",
    "    \n",
    "    #store computational time of the different methods in lists\n",
    "    zero_threads_time=[]\n",
    "    one_threads_time=[]\n",
    "    two_threads_time=[]\n",
    "    four_threads_time=[]\n",
    "    eight_threads_time=[]\n",
    "    PollardRho_threads_time=[]\n",
    "    \n",
    "    \n",
    "    #store smallest factor of the different methods in lists\n",
    "    zero_threads_s_factor=[]\n",
    "    one_threads_s_factor=[]\n",
    "    two_threads_s_factor=[]\n",
    "    four_threads_s_factor=[]\n",
    "    eight_threads_s_factor=[]\n",
    "    PollardRho_threads_s_factor=[]\n",
    "    \n",
    "    \n",
    "    #run every method for every number in the modulo numbers list, store the computational time and smallest factor\n",
    "    for mod in modulo_numbers:\n",
    "        zero=bf_factorize(mod)\n",
    "        zero_threads_time.append(zero[2]) #store computatioanl time\n",
    "        zero_threads_s_factor.append(min(zero[0],zero[1])) #store smallest factor\n",
    "        \n",
    "        one=bf_threading_factorize(mod,1)\n",
    "        one_threads_time.append(one[1])\n",
    "        one_threads_s_factor.append(min(one[0][0],one[0][1]))\n",
    "        \n",
    "        two=bf_threading_factorize(mod,2)        \n",
    "        two_threads_time.append(two[1])\n",
    "        two_threads_s_factor.append(min(two[0][0],two[0][1]))\n",
    "    \n",
    "        four=bf_threading_factorize(mod,4) \n",
    "        four_threads_time.append(four[1])\n",
    "        four_threads_s_factor.append(min(four[0][0],two[0][1]))\n",
    "        \n",
    "        \n",
    "        eight=bf_threading_factorize(mod,8) \n",
    "        eight_threads_time.append(eight[1])\n",
    "        eight_threads_s_factor.append(min(eight[0][0],eight[0][1]))\n",
    "\n",
    "        Pollard=PollardRho(mod)\n",
    "        PollardRho_threads_time.append(Pollard[1])\n",
    "        PollardRho_threads_s_factor.append(min(Pollard[0],mod//Pollard[0]))\n",
    "\n",
    "   \n",
    "    #plot computational time results\n",
    "    plt.figure(figsize=(6, 3))\n",
    "    plt.plot(modulo_numbers,zero_threads_time,\"--o\",label=\"BF: No threading\")\n",
    "    plt.plot(modulo_numbers,one_threads_time,\"-o\",label=\"BF: 1 Threads\")\n",
    "    plt.plot(modulo_numbers,two_threads_time,\"-o\",label=\"BF: 2 Threads\")\n",
    "    plt.plot(modulo_numbers,four_threads_time,\"-o\",label=\"BF: 4 Threads\")\n",
    "    plt.plot(modulo_numbers,eight_threads_time,\"-o\",label=\"BF: 8 Threads\")\n",
    "    plt.plot(modulo_numbers,PollardRho_threads_time,\"--o\",label=\"Pollard Rho\")\n",
    "    plt.xscale(\"log\")\n",
    "    plt.legend()\n",
    "    plt.xlabel('Modulus, n')\n",
    "    plt.title(\"Time to break public key\")\n",
    "    plt.ylabel('Code Clock Time [s]')\n",
    "    plt.show()     \n",
    "    \n",
    "    #plot smallest factor found results\n",
    "    plt.figure(figsize=(6, 3))\n",
    "    plt.plot(modulo_numbers,zero_threads_s_factor,\"--o\",label=\"BF: No threading\")\n",
    "    plt.plot(modulo_numbers,one_threads_s_factor,\"-o\",label=\"BF: 1 Threads\")\n",
    "    plt.plot(modulo_numbers,two_threads_s_factor,\"-o\",label=\"BF: 2 Threads\")\n",
    "    plt.plot(modulo_numbers,four_threads_s_factor,\"-o\",label=\"BF: 4 Threads\")\n",
    "    plt.plot(modulo_numbers,eight_threads_s_factor,\"-o\",label=\"BF: 8 Threads\")\n",
    "    plt.plot(modulo_numbers,PollardRho_threads_s_factor,\"--o\",label=\"Pollard Rho\")\n",
    "    plt.xscale(\"log\")\n",
    "    plt.yscale(\"log\")\n",
    "    plt.legend()\n",
    "    plt.xlabel('Modulus, n')\n",
    "    plt.title(\"Smallest factor using different methods\")\n",
    "    plt.ylabel('Smallest factor')\n",
    "    plt.show()     \n"
   ]
  }
 ],
 "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}