1-out-of-2 Oblivious Transfer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('p : ', 1565135459)\n",
      "('q : ', 507035423)\n",
      "Alice's message m0 is : 86256102\n",
      "Alice's message m1 is : 1773138425\n",
      "Bob's bit (0 or 1) b is : 1\n",
      "Bob could learn the value of m_b as : 1773138425\n",
      "Protocol Finished Correctly!\n"
     ]
    }
   ],
   "source": [
    "# Implementation of 1-out-of-2 OT\n",
    "# Alice has 2 messages and Bob wants to know one of those messages with Alice now knowing which message Bob learns and Bob not knowing the second of the two messages\n",
    "\n",
    "import time\n",
    "seed = int(round(time.time() * 10))\n",
    "\n",
    "# Generator for random number generation\n",
    "def gen_random_mod(k, modulus):\n",
    "    num = 0\n",
    "    while(num < k):\n",
    "        a = mod(gp.random(), modulus).lift()\n",
    "        while(gcd(a, modulus) != 1):\n",
    "            a = mod(gp.random(), modulus).lift()\n",
    "        yield a\n",
    "        num += 1\n",
    "\n",
    "class Alice:\n",
    "    \n",
    "    def __init__(self, modbits, seed):\n",
    "        set_random_seed(seed)\n",
    "        current_randstate().set_seed_gp()\n",
    "        # use gp.random() to get prng random number\n",
    "    \n",
    "        self.p = next_prime(2^modbits + gp.random())\n",
    "        print(\"p : \", self.p)\n",
    "        self.q = next_prime(2^modbits + gp.random())\n",
    "        print(\"q : \", self.q)\n",
    "        if self.p == self.q:\n",
    "            print(\"Primes are same, please run again\")\n",
    "        self.n = self.p*self.q\n",
    "        self.phi_n = (self.p-1)*(self.q-1)\n",
    "        # Lifting is necessary here, in order for inverse_mod to work correctly\n",
    "        self.e = mod(gp.random(), self.phi_n).lift()\n",
    "        while gcd(self.e, self.phi_n)!=1:\n",
    "            self.e = mod(gp.random(), self.phi_n).lift()\n",
    "        self.d = inverse_mod(self.e, self.phi_n)\n",
    "        \n",
    "        # Alice generates m0 and m1 here.\n",
    "        self.mlist = list(gen_random_mod(2, self.n))\n",
    "        self.m0 = self.mlist[0]\n",
    "        self.m1 = self.mlist[1]\n",
    "        print(\"Alice's message m0 is : \" + str(self.m0))\n",
    "        print(\"Alice's message m1 is : \" + str(self.m1))\n",
    "        \n",
    "        # Alice generates x0 and x1 here.\n",
    "        self.xlist = list(gen_random_mod(2, self.n))\n",
    "        \n",
    "    def compute_kx(self, v):\n",
    "        klist = []\n",
    "        for i in range(2):\n",
    "            klist.append(mod((v-self.xlist[i]), self.n).lift().powermod(self.d, self.n))\n",
    "        #print(klist)\n",
    "        mprimelist = []\n",
    "        mprimelist.append(mod(self.m0 + klist[0], self.n).lift())\n",
    "        mprimelist.append(mod(self.m1 + klist[1], self.n).lift())\n",
    "        return mprimelist\n",
    "        \n",
    "        \n",
    "class Bob:\n",
    "    \n",
    "    def __init__(self, xlist, n, e):\n",
    "        self.x0 = xlist[0]\n",
    "        self.x1 = xlist[1]\n",
    "        self.xlist = xlist\n",
    "        self.n = n\n",
    "        self.e = e\n",
    "        temp = [i-1 for i in list(gen_random_mod(1, 3))]\n",
    "        self.b = temp[0]\n",
    "        temp = list(gen_random_mod(1, self.n))\n",
    "        self.k = temp[0]\n",
    "        #print(self.k)\n",
    "        self.v = mod(xlist[self.b], self.n)\n",
    "        self.v = self.v + self.k.powermod(self.e, self.n)\n",
    "        self.v = self.v.lift()\n",
    "        \n",
    "    def revelation(self, mprimelist):\n",
    "        self.m = mprimelist[self.b] - self.k\n",
    "        print(\"Bob's bit (0 or 1) b is : \"+str(self.b))\n",
    "        print(\"Bob could learn the value of m_b as : \"+str(self.m))\n",
    "        \n",
    "        \n",
    "class OT_Protocol:\n",
    "    \n",
    "    def __init__(self, modbits, seed):\n",
    "        alice = Alice(modbits, seed)\n",
    "        bob = Bob(alice.xlist, alice.n, alice.e)\n",
    "        mprimelist = alice.compute_kx(bob.v)\n",
    "        bob.revelation(mprimelist)\n",
    "        if bob.m == alice.mlist[bob.b]:\n",
    "            print(\"Protocol Finished Correctly!\")\n",
    "        else:\n",
    "            print(\"Error in protocol resuts. Aborted.\")\n",
    "        \n",
    "modbits = 12\n",
    "ot = OT_Protocol(modbits, seed)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 8.1",
   "language": "",
   "name": "sagemath"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}