Assignment 2 of Network Security ，taught by Dr.Hussein Abdel-Wahab

a2_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python implementation for 1st round of DES\n",
    "\n",
    "The following code notation follows:\n",
    "1.\n",
    "Dr.Wahab 's lectures and\n",
    "\n",
    "2.\n",
    "\"The DES Algorithm Illustrated\n",
    "by J. Orlin Grabbe \n",
    "http://page.math.tu-berlin.de/~kant/teaching/hess/krypto-ws2006/des.htm\n",
    "\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 559,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01010001\n",
      "64\n",
      "0001111100011111000111110001111100001111000011110000111100001111\n",
      "0101010100000000000000000000000000000000000000000000000001010101\n"
     ]
    }
   ],
   "source": [
    "import binascii\n",
    "def hextobin( hexval):\n",
    "        '''\n",
    "        Takes a string representation of hex data with\n",
    "        arbitrary length and converts to string representation\n",
    "        of binary.  Includes padding 0s\n",
    "        '''\n",
    "        thelen = len(hexval)*4\n",
    "        binval = bin(int(hexval, 16))[2:]\n",
    "        while ((len(binval)) < thelen):\n",
    "            binval = '0' + binval\n",
    "        return binval\n",
    "    \n",
    "# test hextobin()\n",
    "print hextobin('51')\n",
    "\n",
    "# # INPUT AND KEY for a2 in CS772 FALL 2015\n",
    "input='5500 0000 0000 0055'.replace(\" \", \"\")\n",
    "key='1F1F 1F1F 0F0F 0F0F'.replace(\" \", \"\")\n",
    "\n",
    "# # INPUT AND KEY for a2 in CS772 FALL 2014\n",
    "# input=' AAAA AAAA AAAA AAAA'.replace(\" \", \"\")\n",
    "# key='E0E0 E0E0 F0F0 F0F0'.replace(\" \", \"\")\n",
    "\n",
    "input=hextobin(input)\n",
    "key64=hextobin(key)\n",
    "print len(key64)\n",
    "\n",
    "print key64\n",
    "print input\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Step 1: Create 16 subkeys, each of which is 48-bits long."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 560,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "56\n",
      "0001111100011111000111110001111100001111000011110000111100001111\n"
     ]
    }
   ],
   "source": [
    "\n",
    "pc_1=[ 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",
    "print len(pc_1)\n",
    "print key64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 561,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "key56=[]\n",
    "for i in range(len(pc_1)):\n",
    "    key56.append( key64[pc_1[i]-1] )\n",
    "# test the key56    \n",
    "# print key56\n",
    "# print pc_1[2]\n",
    "# print key64[41]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 562,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "c0=key56[0:len(key56)/2]\n",
    "d0=key56[len(key56)/2:]\n",
    "# print c0\n",
    "# print d0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 563,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "c1=[]\n",
    "d1=[]\n",
    "for i in range(1,len(c0)):\n",
    "#     print i\n",
    "    c1.append(c0[i])\n",
    "    d1.append(d0[i])\n",
    "c1.append(c0[0])\n",
    "d1.append(d0[0])\n",
    "# compare th\n",
    "# print c1\n",
    "# print d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 564,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pc_2=[\n",
    "14,17,11,24, 1,5\n",
    ", 3,28,15, 6,21,10\n",
    ",23,19,12, 4,26,8\n",
    ",16, 7,27,20,13,2\n",
    ",41,52,31,37,47,55\n",
    ",30,40,51,45,33,48\n",
    ",44,49,39,56,34,53\n",
    ",46,42,50,36,29,32\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 565,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "k1=c1+d1\n",
    "# print k1\n",
    "# len(k1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 566,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "key48=[]\n",
    "for i in range(len(pc_2)):\n",
    "    key48.append( k1[pc_2[i]-1] )\n",
    "# print key48\n",
    "# len(key48)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Step 2: Encode each 64-bit block of data.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 567,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ip=[\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",
    "# len(ip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 568,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# # test case for ip\n",
    "# input='0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111'.replace(\" \", \"\")\n",
    "# print input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 569,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "inputAfterIP=[]\n",
    "for i in range(len(ip)):\n",
    "    inputAfterIP.append(input[ip[i]-1])\n",
    "# print inputAfterIP\n",
    "# len(inputAfterIP)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 570,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "l0=inputAfterIP[:len(inputAfterIP)/2]\n",
    "r0=inputAfterIP[len(inputAfterIP)/2:]\n",
    "# print l0\n",
    "# print r0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 571,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "l1=r0\n",
    "bst=[\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",
    "# len(bst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 572,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "E_r0=[]\n",
    "for i in range(len(bst)):\n",
    "    E_r0.append(r0[bst[i]-1])\n",
    "# print E_r0\n",
    "# len(E_r0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 573,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "k1pE_r0=[]\n",
    "for i in range(len(key48)):\n",
    "    k1pE_r0.append( int(key48[i]!=E_r0[i])  )  \n",
    "# print k1pE_r0\n",
    "# len(k1pE_r0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 574,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "3\n",
      "13\n",
      "13\n",
      "14\n",
      "10\n",
      "13\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# s1 = np.matrix('14  4  13  1 2 15  11  8   3 10   6 12   5  9   0  7;0 15   7  4  14  2  13  1  10  6  12 11   9  5   3  8;4  1  14  8  13  6   2 11  15 12   9  7   3 10   5  0;15 12   8  2   4  9   1  7   5 11   3 14  10  0   6 13')\n",
    "# print s1.item((1,0))\n",
    "s1=np.matrix([\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",
    "print s1.item((1,0))\n",
    "\n",
    "s2=np.matrix([\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",
    "print s2.item((1,0))\n",
    "\n",
    "s3=np.matrix([\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",
    "print s3.item((1,0))\n",
    "\n",
    "s4=np.matrix([\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",
    "print s4.item((1,0))\n",
    "\n",
    "s5=np.matrix([\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",
    "print s5.item((1,0))\n",
    "\n",
    "\n",
    "s6=np.matrix([\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",
    "print s6.item((1,0))\n",
    "\n",
    "s7=np.matrix([\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",
    "print s7.item((1,0))\n",
    "\n",
    "s8=np.matrix([\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",
    "])\n",
    "print s8.item((1,0))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 575,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48\n"
     ]
    }
   ],
   "source": [
    "print len(k1pE_r0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 576,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "B=[]\n",
    "for i in range(8):\n",
    "    B.append(k1pE_r0[6*i:6*i+6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 577,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 0, 0]\n",
      "[0, 0, 0, 0, 0, 0]\n",
      "[0, 0, 0, 0, 0, 0]\n",
      "[0, 0, 0, 0, 0, 0]\n",
      "[1, 1, 1, 1, 1, 1]\n",
      "[1, 1, 1, 1, 1, 1]\n",
      "[1, 1, 1, 1, 1, 1]\n",
      "[1, 1, 1, 1, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "for i in range(8):\n",
    "    print B[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 578,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sBox=[]\n",
    "sBox.append(s1)\n",
    "sBox.append(s2)\n",
    "sBox.append(s3)\n",
    "sBox.append(s4)\n",
    "sBox.append(s5)\n",
    "sBox.append(s6)\n",
    "sBox.append(s7)\n",
    "sBox.append(s8)\n",
    "# print sBox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 579,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "0 0\n",
      "0 0\n",
      "0 0\n",
      "0 0\n",
      "3 15\n",
      "3 15\n",
      "3 15\n",
      "3 15\n"
     ]
    }
   ],
   "source": [
    "result32=''\n",
    "print len(B)\n",
    "for i in range(len(B)):\n",
    "    row=int(str(B[i][0])+str(B[i][-1]), 2)\n",
    "    column=int(str(B[i][1])+str(B[i][2])+str(B[i][3])+str(B[i][4]), 2)\n",
    "    print row,column\n",
    "    temp=sBox[i].item((row,column))\n",
    "    result32+=(\"{0:04b}\".format(temp))\n",
    "# print result32\n",
    "# len(result32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 580,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "p=[16,7,20,21\n",
    ",29,12,28,17\n",
    ", 1,15,23,26\n",
    ", 5,18,31,10\n",
    ", 2,8,24,14\n",
    ",32,27,3,9\n",
    ",19,13,30,6\n",
    ",22,11,4,25]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 581,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f=[]\n",
    "for i in range(len(p)):\n",
    "    f.append(  result32[p[i]-1]  )\n",
    "# print f    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 582,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "r1=[]\n",
    "for i in range(len(l0)):\n",
    "    r1.append( int(l0[i]!=f[i])  )  \n",
    "print r1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 583,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# final answer for the first around of DES\n",
    "l1=[int(x) for x in l1]\n",
    "# print l1\n",
    "# print r1\n",
    "\n",
    "l1=[str(x) for x in l1]\n",
    "r1=[str(x) for x in r1]\n",
    "# print l1\n",
    "# print r1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 584,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '1', '1', '1', '1', '0', '0', '1', '0', '1', '0', '1', '1', '0', '1', '1', '0', '1', '1', '1', '1', '0', '1', '0', '0', '0', '0', '1', '1', '1', '0', '0']\n",
      "64\n",
      "0xc\n",
      "['0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x7', '0x9', '0x5', '0xb', '0x7', '0xa', '0x1', '0xc']\n"
     ]
    }
   ],
   "source": [
    "# final result in hex !!!!\n",
    "\n",
    "print l1+r1\n",
    "print len(l1+r1)\n",
    "lr=l1+r1\n",
    "result=[]\n",
    "for x in range(len(lr)/4):\n",
    "    result.append( hex( int(''.join(lr[4*x:4*x+4]), 2)  ) )\n",
    "print hex(int(''.join( lr[60:60+4] ), 2))\n",
    "print result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 585,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0x0\n"
     ]
    }
   ],
   "source": [
    "print h"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}

a2_2.ipynb

a2_3.ipynb