Numerically_Find_Fault_locations_S_for_unknowns_in_LFSR.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Numerically verify fault injections at S[i] to recovr unknowns in LFSR.\n",
    "#If any unknowns can be recovered then the output will indicate the corresponding keystream indices, target register, and recovered unknown.\n",
    "#e.g., the output eq0_s14=s21 reads as inject fault at target s14 and then observing the differential for ouput index 0 will recover the unknown s14.\n",
    "# The parameters can be modified accordingly to:\n",
    "#Find_Fault_locations_S_for_unknowns_in_NFSR, \n",
    "#Find_Fault_locations_S_for_unknowns_in_LFSR\n",
    "#Find_Fault_locations_B_for_unknowns_in_NFSR, \n",
    "#Find_Fault_locations_B_for_unknowns_in_LFSR\n",
    "#extrapolating other equations with more than one unknowns.\n",
    "from IPython import get_ipython\n",
    "get_ipython().magic('reset -sf')\n",
    "from sage.crypto.boolean_function import BooleanFunction\n",
    "from random import randint\n",
    "import random\n",
    "import numpy\n",
    "\n",
    "R.<s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26, s27, s28, s29, s30, s31, s32, s33, s34, s35, s36, s37, s38, s39, s40, s41, s42, s43, s44, s45, s46, s47, s48, s49, s50, s51, s52, s53, s54, s55, s56, s57, s58, s59, s60, s61, s62, s63, s64, s65, s66, s67, s68, s69, s70, s71, s72, s73, s74, s75, s76, s77, s78, s79, s80, s81, s82, s83, s84, s85, s86, s87, s88, s89, s90, s91, s92, s93, s94, s95, s96, s97, s98, s99, s100, s101, s102, s103, s104, s105, s106, s107, s108, s109, s110, s111, s112, s113, s114, s115, s116, s117, s118, s119, s120, s121, s122, s123, s124, s125, s126, s127, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49, b50, b51, b52, b53, b54, b55, b56, b57, b58, b59, b60, b61, b62, b63, b64, b65, b66, b67, b68, b69, b70, b71, b72, b73, b74, b75, b76, b77, b78, b79, b80, b81, b82, b83, b84, b85, b86, b87, b88, b89, b90, b91, b92, b93, b94, b95, b96, b97, b98, b99, b100, b101, b102, b103, b104, b105, b106, b107, b108, b109, b110, b111, b112, b113, b114, b115, b116, b117, b118, b119, b120, b121, b122, b123, b124, b125, b126, b127> = BooleanPolynomialRing()\n",
    "R.inject_variables()\n",
    "\n",
    "C.<s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26, s27, s28, s29, s30, s31, s32, s33, s34, s35, s36, s37, s38, s39, s40, s41, s42, s43, s44, s45, s46, s47, s48, s49, s50, s51, s52, s53, s54, s55, s56, s57, s58, s59, s60, s61, s62, s63, s64, s65, s66, s67, s68, s69, s70, s71, s72, s73, s74, s75, s76, s77, s78, s79, s80, s81, s82, s83, s84, s85, s86, s87, s88, s89, s90, s91, s92, s93, s94, s95, s96, s97, s98, s99, s100, s101, s102, s103, s104, s105, s106, s107, s108, s109, s110, s111, s112, s113, s114, s115, s116, s117, s118, s119, s120, s121, s122, s123, s124, s125, s126, s127, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49, b50, b51, b52, b53, b54, b55, b56, b57, b58, b59, b60, b61, b62, b63, b64, b65, b66, b67, b68, b69, b70, b71, b72, b73, b74, b75, b76, b77, b78, b79, b80, b81, b82, b83, b84, b85, b86, b87, b88, b89, b90, b91, b92, b93, b94, b95, b96, b97, b98, b99, b100, b101, b102, b103, b104, b105, b106, b107, b108, b109, b110, b111, b112, b113, b114, b115, b116, b117, b118, b119, b120, b121, b122, b123, b124, b125, b126, b127> = BooleanPolynomialRing()\n",
    "C.inject_variables()\n",
    "\n",
    "#Generate pre-output Z\n",
    "\n",
    "def grain(State_S, State_B):\n",
    "    #update function of LFSR and NFSR\n",
    "    feedback_L = State_S[0] + State_S[7] + State_S[38] + State_S[70] + State_S[81] + State_S[96]\n",
    "    feedback_N = State_S[0] + State_B[0] + State_B[26] + State_B[56] + State_B[91] + State_B[96] + State_B[3] * State_B[67] + State_B[11] * State_B[13] + State_B[17] * State_B[18] + State_B[27] * State_B[59] + State_B[40] * State_B[48] + State_B[61] * State_B[65] + State_B[68] * State_B[84] + State_B[22] * State_B[24] * State_B[25] + State_B[70] * State_B[78] * State_B[82] + State_B[88] * State_B[92] * State_B[93] * State_B[95]\n",
    "\n",
    "    #feedback update\n",
    "    for j in range(128):\n",
    "        if j<=126:\n",
    "            State_S[j] = State_S[j+1]\n",
    "            State_B[j] = State_B[j+1]\n",
    "        else:\n",
    "            State_S[127] = feedback_L\n",
    "            State_B[127] = feedback_N\n",
    "        \n",
    "    #h function\n",
    "    h = State_B[12]*State_S[8] + State_S[13]*State_S[20] + State_B[95]*State_S[42] + State_S[60]*State_S[79] + State_B[12]*State_B[95]*State_S[94]\n",
    "    #pre-output function\n",
    "    z = h + State_S[93] + State_B[2]+ State_B[15] + State_B[36] + State_B[45] + State_B[64] + State_B[73] + State_B[89]\n",
    "    return z\n",
    "\n",
    "kesytream_round = 200\n",
    "num_test = 100\n",
    "#print(success)\n",
    "\n",
    "for unknowns in range(128):\n",
    "    success = [[0 for i in range(128)] for j in range(kesytream_round)]\n",
    "    for i in range(num_test): #Test for 100 random initial state\n",
    "        #print('Test',i)\n",
    "        #initialize the internal states with random value (random Key and IV)\n",
    "        S_temp = [R(random.randint(0,1)) for u in range(128)]\n",
    "        B_temp = [R(random.randint(0,1)) for u in range(128,256,1)]\n",
    "        S = [C() for u in range(128)]\n",
    "        B = [C() for u in range(128)]\n",
    "        statef_S = [C() for u in range(128)]\n",
    "        statef_B = [C() for u in range(128,256,1)]\n",
    "    \n",
    "        #Fault target location\n",
    "        for faulty_state in range(128):\n",
    "            #Restore the random state\n",
    "            for l in range(128):\n",
    "                S[l] = S_temp[l]\n",
    "                B[l] = B_temp[l]\n",
    "                statef_S[l] = S[l]\n",
    "                statef_B[l] = B[l]\n",
    "            \n",
    "            #This is the recovered bit with the fault injection\n",
    "            #Change this to B if the unknowns are to be identified from the NFSR\n",
    "            recover_state = S[unknowns]\n",
    " \n",
    "            #Inject fault at the target location in LFSR\n",
    "            statef_S[faulty_state] = statef_S[faulty_state] + 1\n",
    "            #Inject fault at the target location in LFSR\n",
    "            #statef_B[faulty_state] = statef_B[faulty_state] + 1\n",
    "        \n",
    "            #Generate the keystream for the desired number of rounds\n",
    "            for target_output in range(kesytream_round):\n",
    "                zff = grain(S, B)\n",
    "                zf = grain(statef_S, statef_B)\n",
    "                if target_output%2==0:\n",
    "                #if keystream >=1 and keystream%2==0:\n",
    "                    d = zf + zff\n",
    "                    if recover_state == d:\n",
    "                        success[target_output][faulty_state] = success[target_output][faulty_state]+1\n",
    "\n",
    "    print('Unknown register location:', unknowns)\n",
    "    #print('Success count:',success)\n",
    "    for i in range(kesytream_round):\n",
    "        for j in range(128):\n",
    "            if success[i][j] ==num_test:\n",
    "                print('eq', i,'_','s',j,'=','s',unknowns,sep='') # modify accordingly depending on the other parameters\n",
    "                #print('round',i)\n",
    "                #print('target','s', j, sep='')\n",
    "    print('-----------------------------------------------------------------------------------------')\n",
    "       \n",
    "print('end')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 9.0",
   "language": "sage",
   "name": "sagemath"
  },
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}