View difference between Paste ID: B9UbjSG5 and nwTf6zts

 import sys
 import numpy as np
 import random
 import os.path
 from simplecrypt import encrypt,decrypt
 from Crypto.Hash import SHA
 from Crypto.Util import number
 
 prime_value_q = number.getPrime(160)
 maxFeatures=0
 stDev=2
 mean=10
 history_file_name=""
 newUser = True
 h = 5
 ti =10
 
 class Poly:
   coeff = []
   def __init__(self, coeff):
     self.coeff = coeff
 
   def val(self, x):
     sum_val = 0
     for i, value in enumerate(self.coeff):
       sum_val = sum_val + value*pow(x, i)
     return sum_val
 
 def poly_gen(m_minustwo,hpwd):
     coefficient = [hpwd] + random.sample(xrange(100), m_minustwo)
     return Poly(coefficient)
 
 def alphaTrue(pswd, i, coeffList):
     i=i+1
     #Get SHA
     sha = SHA.new(str(2*i) + pswd).hexdigest()
     #Format SHA from str to long
     fmtSHA = long(''.join([str(ord(h)) for h in sha]))
     #calc Alpha Value
     A=coeffList.val(2*i) + (fmtSHA % prime_value_q)
     #print "ALPHA  ", coeffList.val(2*i)
     #print "ALPHA  %s %s %s %s" % (i, (2 * i), pswd, fmtSHA)
     return A
 
 def alphaFalse(pswd, i):
     pswd=pswd + str(random.randrange(0, 1000))
     i=i + 1
     coeffList = poly_gen(maxFeatures - 5, random.randrange(0, prime_value_q - 1))
     # Get SHA
     sha = SHA.new(str(2 * i) + pswd).hexdigest()
     # Format SHA from str to long
     fmtSHA = long(''.join([str(ord(h)) for h in sha]))
     # calc Alpha Value
     A = coeffList.val(2 * i) + (fmtSHA % prime_value_q)
     return A
 
 def betaTrue(pswd, i, coeffList):
     i=i+1
     #Get SHA
     sha = SHA.new(str(2*i+1) + pswd).hexdigest()
     #print "SHA:",sha
     #Format SHA from str to long
     fmtSHA = long(''.join([str(ord(h)) for h in sha]))
     #calc Beta Value
     B=coeffList.val(2*i+1) + (fmtSHA % prime_value_q)
     #print "BETA  ", coeffList.val(2*i+1)
     #print "BETA  %s %s %s %s" % (i, (2 * i + 1), pswd, fmtSHA)
     return B
 
 def betaFalse(pswd, i):
     pswd=pswd + str(random.randrange(0, 1000))
     i=i + 1
     coeffList = poly_gen(maxFeatures - 5, random.randrange(0, prime_value_q - 1))
     # Get SHA
     sha = SHA.new(str(2 * i+1) + pswd).hexdigest()
     # Format SHA from str to long
     fmtSHA = long(''.join([str(ord(h)) for h in sha]))
     # calc Beta Value
     B = coeffList.val(2 * i+1) + (fmtSHA % prime_value_q)
     return B
 
 def instrTblGenerator(pswd, featuresList):
     instrTbl=[]
     avgFeatureSpeed = np.mean(featuresList, axis=0)
     sigma = np.std(featuresList, axis=0)
     hpwd = random.randrange(0, prime_value_q - 1)
     #print "encrypt    " , hpwd
     coeffList = poly_gen(maxFeatures - 1, hpwd)
 
 
 
     for i in range(maxFeatures):
 
 
         if ((i < len(avgFeatureSpeed)) and ((abs(avgFeatureSpeed[i] - mean) - 0.0001) > (stDev * sigma[i]))):
             #print "mean:%s avg spd:%s"%(mean,avgFeatureSpeed[i])
             if (avgFeatureSpeed[i] < mean):
                 # Fast: beta=Random  alpha=TRUE
                 #print "ALPHA FAST"
 
                 A=alphaTrue(pswd, i, coeffList)
                 B = betaFalse(pswd, i)
                 instrTbl.append([A, B])
                # print "Alpha:%s   Beta: %s"%(A,B)
 
             else:# SLOW: beta=TRUE  alpha=Random
 
                 #print "BETA FAST"
 
                 A = alphaFalse(pswd, i)
                 B = betaTrue(pswd, i, coeffList)
                 instrTbl.append([A, B])
              #   print "Alpha:%s   Beta: %s" % (A, B)
 
 
         else:# Neither: beta=TRUE  alpha=TRUE
 
             #print "mean:%s avg spd:%s" % (mean, avgFeatureSpeed[i-1])
             #print "SAME"
             A = alphaTrue(pswd, i, coeffList)
             B = betaTrue(pswd, i, coeffList)
             instrTbl.append([A, B])
             #print "Alpha:%s   Beta: %s\n" % (A, B)
 
 
     return [hpwd, instrTbl]
 
 #CHANGE UP
 def DecryptFromFile(key):
   with open(history_file_name+'.hf', 'rb') as f:
     cipher_text = f.read()
   pad, plain_text = decrypt(key, cipher_text).split("````")
   return plain_text
 
 def hist_gen(hpwd,featuresList):
     features2str = ''
 
     for i in xrange(1, len(featuresList)):
         features2str += ','.join([str(j) for j in featuresList[i]]) + '\n'
         paddedfeatures2str = "````" + features2str
     strhpwd=SHA.new(str(hpwd)).hexdigest()
     ciphertext = encrypt(strhpwd, paddedfeatures2str.rjust(800, '^'))
     file = open((history_file_name+".hf"), "w")
     file.write(ciphertext)
     file.close()
 
 
 '''def file_parser(inFile):
     global maxFeatures
     i=0
     featuresList =[]
     while i < len(inFile):
         pswd=inFile[i]
         i = i + 1
         #convert features from string to int
         features = map(int,inFile[i].split(','))
 
         if (len(pswd) - 2 != len(features)):
 
             print 'Feature and password do not match!'
             sys.exit()
         maxFeatures = len(pswd) - 1
         featuresList.append(features)
         i = i + 1
     return pswd,featuresList'''
 #CHANGE UP
 def lamb(x_array,i):
     mult = 1
     for j in range(len(x_array)):
         if j!=i:
             mult = mult*(x_array[j]/(x_array[j]-x_array[i]))
     return mult
 
 #CHANGE UP
 #this is our Lagrange function, which takes x,y pairs and q to recreate hpwd
 def Lagrange(x_array, y_array):
     sum = 0
     for i in range(len(y_array)):
         #this calls the lambda function which creates uses the x values to create the coefficient to multiply y with
         lam = lamb(x_array,i)
         #this is where we sum the array
         sum = sum + (lam * y_array[i])
     return sum
 
 # lagrange interpolation to get h_pwd from xy values
 def h_pwdLagrange(x,y, feature_num):
   h_pwd = 0
   nums = []
   dens = []
   dens_sum = 1
   for i in xrange(0, feature_num):
     lambda_num = 1
     lambda_den = 1
     for j in xrange(0, feature_num):
       if (i != j):
         lambda_num *= x[j]
         lambda_den *= x[j] - x[i]
     nums.append(lambda_num * y[i])
     dens.append(lambda_den)
   for i in xrange(0, len(nums)):
     h_pwd += get_Num(i, nums, dens)
     dens_sum *= dens[i]
   return h_pwd/dens_sum # floor division to avoide float conversion
 
 #used to minimize the divisions
 def get_Num(index, nums, dens):
   num = 1
   for i in xrange(0, len(nums)):
     if i == index:
       num *= nums[i]
     else:
       num *= dens[i]
   return num
 
 
 def login(features,instrTbl,password):
     ys=[]
     alphas = []
     betas = []
     xs = []
     # parse the instruction table to list of alpha and list of beta
     i = 1
     j = 0
     # password = alpha if features < ti , password = beta if features>=ti
 
 
     for f in features:
         if f < ti:
             sha = SHA.new(str(2 * i) + password).hexdigest()
             sha = long(''.join([str(ord(h)) for h in sha]))
             p = instrTbl[j][0] - sha % prime_value_q
             #print "Decrypt alph   ", p
             #print "Decrypt alph  %s %s %s %s" %( i, (2 * i), password, sha)
             ys.append(p)
             xs.append(2*i)
 
         else:
             sha = SHA.new(str(2 * i + 1) + password).hexdigest()
             sha = long(''.join([str(ord(h)) for h in sha]))
             p = instrTbl[j][1] - sha % prime_value_q
             #print "Decrypt beta   ", p
             #print "Decrypt beta  %s %s %s %s" % (i, (2 * i+1), password, sha)
             ys.append(p)
             xs.append(2*i+1)
         i = i + 1
         j = j + 1
     hpwd = h_pwdLagrange(xs, ys,maxFeatures)
     #print "decreypt       " , hpwd
     featuresList = []
     try:
         inst = DecryptFromFile(SHA.new(str(hpwd)).hexdigest()).strip()
 
         instList = inst.split("\n")
         #print "hist    ", instList
         if len(instList) == 6:
             instList = instList[1:]
         #print instList
         for i in instList:
             features = i.split(',')
             features = map(int, features)
             featuresList.append(features)
         #print featuresList
         return featuresList
         #features = content[i].split(',')
         # print features
         #features = map(int, features)
 
     except:
         return featuresList
 
 
 
 
 
 
 
 '''def main(inFileName,hisfilename):
     global history_file_name, newUser
     history_file_name=hisfilename
 
     if os.path.exists((hisfilename+".hf")):
         newUser=False
     else:
         with open(inFileName, 'r') as inFile:
 
             pswd, featuresList = file_parser(inFile.readlines())
             print pswd, featuresList
             if not newUser:
 
                 login(pswd)
             else:
                 hpwd, instrTbl = instrTblGenerator(pswd, featuresList)
                 hist_gen(hpwd, featuresList)'''
 
 
 def main(filename):
     global maxFeatures, history_file_name
     featuresList=[]
     instrTbl=[]
     try:
         with open(filename, 'r') as f:
             content = f.read()
             #this is to handle the header!!! delete this if its not neccessary
             #content = content.split("\outl0\strokewidth0 \strokec2 ")[1][:-1]
             #########
             content = content.split()
     except:
         print("filename: " + filename + " is incorrect!")
         return
     i = 0
     j = 1
     while i < len(content):
         password = content[i]
         maxFeatures = len(password) - 1
         i = i + 1
         features = content[i].split(',')
         #print features
         features = map(int, features)
 
         #print "ooooo   ", j
         #print "features   ", features
         #print "Feature new    ", featuresList
         if j <= h:
             #print "features lest   ", len(featuresList)
             featuresList.append(features)
 
             print "1"
         if j == h:
             #print "i equals to h  "
             #create_inst
             hpwd, instrTbl = instrTblGenerator(password, featuresList)
             #creat_hist
             history_file_name = filename.split(".")[0]
             hist_gen(hpwd, featuresList)
         if j > h:
             #print "feature list size   ", len(featuresList)
             #print "i is fuck " ,i
             # if length of login return m_features is not 0
             #and then we are going to pass m_features to make a new hist and inst
             newFeaturesList = login(features,instrTbl,password)
 
             if len(newFeaturesList) != 0:
                 print("1")
                 featuresList = newFeaturesList
                 featuresList.append(features)
                 hpwd, instrTbl = instrTblGenerator(password, featuresList)
                 hist_gen(hpwd, featuresList)
             else:
                 print("0")
 
         i = i + 1
         j = j + 1
 
 if __name__ == '__main__':
     main(sys.argv[1:][0])