Python/cryptography/galois_field.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "054915e4",
   "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": 2,
   "id": "62243eff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0, 1, 1, 0, 1]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def id2bit(ls:list):\n",
    "    if(len(ls)==0):\n",
    "        return [0,0,0,0, 0,0,0,0]\n",
    "    aa = [0 for i in range(max(ls)+1)]\n",
    "    for i in ls:\n",
    "        aa[i]=1\n",
    "    return aa[::-1]\n",
    "def bit2id(ls:list,log=False):\n",
    "    ls = ls[::-1]\n",
    "    aa =[]\n",
    "    \n",
    "    for i in range(len(ls)):\n",
    "        if(ls[i]==1):\n",
    "            aa.append(i)\n",
    "    return aa[::-1]\n",
    "\n",
    "def bit2mul(a,b,log=False):\n",
    "    \n",
    "    ai = bit2id(a)\n",
    "    bi = bit2id(b)\n",
    "    a,b = a[::-1],b[::-1]\n",
    "    \n",
    "    if(ai==[]):\n",
    "        return a\n",
    "    elif(bi==[]):\n",
    "        return b\n",
    "    \n",
    "    addn = [ [ ai[i]+bi[j] for j in range(len(bi)) ][::-1] for i in range(len(ai)) ][::-1]\n",
    "    addn = [id2bit(i) for i in addn]\n",
    "    \n",
    "    maxsiz = max([len(i) for i in addn])\n",
    "    for i in range(len(addn)):\n",
    "        if(len(addn[i])<maxsiz):\n",
    "            addn[i] = [0 for j in range(maxsiz-len(addn[i]))]+addn[i]\n",
    "    smm=[]\n",
    "    for i in range(maxsiz):\n",
    "        t= 0\n",
    "        for j in addn:\n",
    "            t += j[i]\n",
    "        smm.append(t%2)\n",
    "    return smm\n",
    "\n",
    "def bit2add(a,b):\n",
    "    a,b = list(a),list(b)\n",
    "    a,b=a[::-1],b[::-1]\n",
    "    maxsiz=max(len(a),len(b))\n",
    "    \n",
    "    \n",
    "    if(len(a)<maxsiz):\n",
    "            a = a+[0 for j in range(maxsiz-len(a))]\n",
    "    if(len(b)<maxsiz):\n",
    "            b = b+[0 for j in range(maxsiz-len(b))]\n",
    "    smm=[]\n",
    "    for i in range(maxsiz):\n",
    "        smm.append((a[i]+b[i])%2)\n",
    "    return smm[::-1]\n",
    "def bit2str(bit:list):\n",
    "    s = \"\"\n",
    "    for i in bit:\n",
    "        s+=str(i)\n",
    "    return s\n",
    "def str2bit(s:str):\n",
    "    if(set(s).issubset(set('01'))):\n",
    "        bit=[]\n",
    "        for i in s:\n",
    "            bit.append(int(i))\n",
    "        return bit\n",
    "    else:\n",
    "        print(\"bit string should contain 1s and 0s\")\n",
    "def modgf(dsr:list,dnt = [1, 0, 0, 0, 1, 1, 0, 1, 1]):\n",
    "    dsr = bit2id(dsr)\n",
    "    dnt = bit2id(dnt)\n",
    "    qtnt = []\n",
    "    while (len(dnt)!=0 and len(dsr)!=0 and (max(dnt)-max(dsr)>=0)):\n",
    "        ml = max(dnt)-max(dsr)\n",
    "        qtnt.append(ml)\n",
    "        plus = id2bit(dnt)\n",
    "        minus = id2bit([ml+i for i in dsr])\n",
    "        rem = bit2add(plus,minus)\n",
    "        dnt = bit2id(rem)\n",
    "    return id2bit(dnt),id2bit(qtnt)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# import numpy as np\n",
    "def ext_eucld(a,b,log=False):\n",
    "    ai,bi = bit2id(a),bit2id(b)\n",
    "    if((len(ai)!=0 and len(bi)!=0)):\n",
    "        if(max(max(ai),max(bi))==max(bi)):\n",
    "            a,b=b,a\n",
    "    elif(len(ai)==0 and len(bi)!=0):\n",
    "        a,b=b,a\n",
    "    def eucld(a,b,log=False):\n",
    "        \n",
    "        a,b = a[::-1],b[::-1]\n",
    "        if(set(b)==set([0]) or (b[0]==1 and (set(b[1:])==set([0])))):\n",
    "            return []\n",
    "        ls = []\n",
    "        \n",
    "        while not (b[0]==1 and (set(b[1:])==set([0]))):\n",
    "            \n",
    "            r,idx = modgf(b[::-1],dnt=a[::-1])\n",
    "            r,idx = r[::-1],idx[::-1]\n",
    "            \n",
    "            if(set(r)==set([0])):\n",
    "                return ls\n",
    "            \n",
    "            ls.append(idx[::-1])\n",
    "            a = b\n",
    "            b = r\n",
    "        return ls\n",
    "    \n",
    "    row = [[[0,0,0,0, 0,0,0,1],[0,0,0,0, 0,0,0,0]],\n",
    "                    [[0,0,0,0, 0,0,0,0],[0,0,0,0, 0,0,0,1]]]\n",
    "    ls = eucld(a,b)\n",
    "    for i in ls:\n",
    "        r10,r11 = row[-1][0], row[-1][1]\n",
    "        r20,r21 = row[-2][0], row[-2][1]\n",
    "        r0 = bit2add(r20,bit2mul(r10,i))\n",
    "        r1 = bit2add(r21,bit2mul(r11,i))\n",
    "        rowl = [r0,r1]\n",
    "        row.append(rowl)\n",
    "    return row[-1]\n",
    "def Gfinv(bit,irrpoly = [1, 0, 0, 0, 1, 1, 0, 1, 1]):\n",
    "    if(set(bit)==set('0')):\n",
    "        return '--'\n",
    "    ans = ext_eucld(irrpoly,bit)\n",
    "    ans = ans[-1][-len(bit):]\n",
    "    return ans\n",
    "\n",
    "\n",
    "Gfinv([0,0,0,0,0,1,0,0],irrpoly=[0,0,0,1, 0,0,1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b8ce266",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38ba4051",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c2b9aab",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9410bfdf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "edb53805",
   "metadata": {},
   "outputs": [],
   "source": [
    "def genmapping(n:int,irrpoly):\n",
    "    gf = [str(bin(i))[2:] for i in range(2**n)]\n",
    "    for i in range(len(gf)):\n",
    "        if(len(gf[i])<n):\n",
    "            gf[i] = '0'*(n-len(gf[i])) + gf[i]\n",
    "    key2ele = dict(enumerate(gf))\n",
    "    ele2key = dict([i[::-1] for i in list(enumerate(gf))])\n",
    "    invmap = dict()\n",
    "    for i in gf:\n",
    "        if(set(i)!=set('0')):\n",
    "            inv = bit2str(Gfinv(str2bit(i),irrpoly=irrpoly))\n",
    "            invmap[ele2key[i]] = ele2key[inv]\n",
    "    return gf,invmap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d4ca99d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "gf5,invmap = genmapping(n=5,irrpoly=id2bit([5,2,0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "44e4797e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(invmap.values())==set(invmap.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b08bd2b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 1,\n",
       " 2: 18,\n",
       " 3: 28,\n",
       " 4: 9,\n",
       " 5: 23,\n",
       " 6: 14,\n",
       " 7: 12,\n",
       " 8: 22,\n",
       " 9: 4,\n",
       " 10: 25,\n",
       " 11: 16,\n",
       " 12: 7,\n",
       " 13: 15,\n",
       " 14: 6,\n",
       " 15: 13,\n",
       " 16: 11,\n",
       " 17: 24,\n",
       " 18: 2,\n",
       " 19: 29,\n",
       " 20: 30,\n",
       " 21: 26,\n",
       " 22: 8,\n",
       " 23: 5,\n",
       " 24: 17,\n",
       " 25: 10,\n",
       " 26: 21,\n",
       " 27: 31,\n",
       " 28: 3,\n",
       " 29: 19,\n",
       " 30: 20,\n",
       " 31: 27}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "invmap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90374ee9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "06a7f472",
   "metadata": {},
   "outputs": [],
   "source": [
    "gf28 = [str(bin(i))[2:] for i in range(256)]\n",
    "for i in range(len(gf28)):\n",
    "    if(len(gf28[i])<8):\n",
    "        gf28[i] = '0'*(8-len(gf28[i])) + gf28[i]\n",
    "\n",
    "key2ele = dict(enumerate(gf28))\n",
    "ele2key = dict([i[::-1] for i in list(enumerate(gf28))])\n",
    "invmap = dict()\n",
    "for i in gf28:\n",
    "\n",
    "    if(set(i)!=set('0')):\n",
    "        inv = bit2str(Gfinv(str2bit(i)))\n",
    "        invmap[ele2key[i]] = ele2key[inv]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5fcfedd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(invmap.values())==set(invmap.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4059dff6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06b3e5d5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37dd903a",
   "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
}