class User:
def __int__(
self
): #construct the components NOT give values as Python returns no attributes...don't know why
self.userID = None
self.message = None
"""
public key components of the server
"""
self.n_RSA = 0 # n = p*q
self.e_RSA = 0
self.sigG_RSA = 0
"""
public key components of the user DH
"""
self.p_DH = 0
self.q_DH = 0
self.public_DH = 0
"""
private key components of the user DH
"""
self.private_DH = 0
self.sessionKey = 0
"""
HMAC
"""
self.demoHMAC = None
self.messageHMAC = None
self.taylorArray = []
#setup phase
def setUser(self, new_ID,
new_message): #update user here because of no attributes error
self.userID = new_ID
self.message = new_message
def setRSA(self, new_e, new_N, new_sigG): #update RSA
self.e_RSA = new_e
self.n_RSA = new_N
self.sigG_RSA = new_sigG
def sigVerfication(self): #verify by the user
hash = SHA256.new(data=self.message.encode('utf-8'))
hash = hash.digest()
hash = int.from_bytes(hash, byteorder='big')
if hash == FME(self.sigG_RSA, self.e_RSA,
self.n_RSA): #if hashed "hello" is sigG
return True
def getMessage(self): #for printing out "Hello" can replace
return self.message
def getUserID(self): #for sending USerID, that's all
return self.userID
#handshake phase
def setDH(self, new_p, new_q): #p and q are given
self.p = new_p
self.q = new_q
def handshake(self, p, q): #generating DH
self.demoDH = DH()
self.setDH(p, q) #not necessary to do this as line 88
self.demoDH.setSytemPrameters(self.p, self.q)
self.private_DH = self.demoDH.setPrivate(
) #DH: selecting private key first then public key
self.public_DH = self.demoDH.setPublic(
) #generate public key, this goes to the server
def session(self, public_key_S):
self.sessionKey = self.demoDH.setSession(
public_key_S) #by Server Public key
def getPublic_DH(self):
return self.public_DH
def getSession_DH(self):
return self.sessionKey
#data exchange phase
def dataExchange(self): #generate data exchange components here
self.demoHMAC = HMAC()
self.demoCBC = CBC()
self.demoCBC.createKey(
self.sessionKey
) #user generate CBC keys: neither Server or User is okay, but only one of them
def getKey(self):
return self.demoCBC.getKey(
) #16 bytes Assume the connection is secured and this must be top-secret
def getIV(self):
return self.demoCBC.getIV(
) #16 bytes Assume the connection is secured and this must be top-secret
def HMAC1(
self
): #Before exchange the message original one goes to the server for authorization
taylor = "I was seven, and you were nine I looked at you like the stars th"
m = self.demoHMAC.HMAC(self.sessionKey, taylor) # assume this is tag
return m # string type
def dataExchange2(self): #encrypting the message return as array
taylor = "I was seven, and you were nine I looked at you like the stars th"
self.taylorArray = self.demoCBC.encrypt(
taylor) #already session and IV are created in line 106
return self.taylorArray
def setHMAC(self, m): #set the server HMAC value for decrypted message
self.messageHMAC = m
def dataExchange3(self,
swift): #decrypt partial messages and return as string
msg = self.demoCBC.decrypt(swift)
if self.messageHMAC == self.demoHMAC.HMAC(self.sessionKey,
msg): # verification check
print("Authorized Server")
else:
print("Who are you?")
class Server:
def __int__(self):
self.bits = 0
self.IDs = 0
self.serverID = None
self.message = None
self.demoRSA = None
"""
pirvate key components must be hidden
"""
self.p_RSA = 0
self.q_RSA = 0
self.d_RSA = 0
"""
public key components
"""
self.n_RSA = 0 # n = p*q
self.e_RSA = 0 # this value is given
self.sigG_RSA = 0 #sigG = hash(message)^d mod n, I use SHA 256 for the hash
self.hashedMessage_RSA = 0 #for verification phase
self.sigV_RSA = None #sigV = 1 is if hash(message) = sigG^e mod n
self.demoDH = None
"""
DH components
"""
self.p_DH = 0
self.q_DH = 0
self.public_DH = 0
"""
private key components of the user DH
"""
self.private_DH = 0
self.sessionKey = 0
"""
HMAC
"""
self.demoHMAC = None
self.messageHMAC = None
self.swiftArray = []
# set up phase
def updateRSAKeys(self):
"""
pirvate key components must be hidden
"""
self.p_RSA = self.demoRSA.getP()
self.q_RSA = self.demoRSA.getQ()
self.d_RSA = self.demoRSA.getD()
"""
public key components
"""
self.n_RSA = self.demoRSA.getN()
self.sigG_RSA = self.demoRSA.getSigG(
) #sigG = hash(message)^d mod n, I use SHA 256 for the hash
self.hashedMessage_RSA = self.demoRSA.getHashedM(
) #for verification phase
self.sigV_RSA = None #sigV = 1 is if hash(message) = sigG^e mod n
def setKey(self, message, new_bits): #generate the RSA ans IDs
self.message = message
self.bits = new_bits
self.e_RSA = 65537 # this value is given
self.demoRSA = RSA()
self.demoRSA.RSA(self.bits, self.e_RSA)
self.demoRSA.sigGeneration(self.message)
self.updateRSAKeys()
self.IDs = int(1780119054 *
random.random()) #not necessary to generate
self.serverID = 1780119054 #just give -> can change any numbers
"""
public key components
"""
def getN(self):
return self.n_RSA
def getE(self):
return self.e_RSA
def getSigG(self):
return self.sigG_RSA
def getIDs(self):
return self.IDs
def getServerID(self):
return self.serverID
#handshake phase
def setDH(self, new_p, new_q): #p and q are given
self.p = new_p
self.q = new_q
def handshake(self, p, q): # generate DH
self.demoDH = DH()
self.setDH(p, q) #not necessary to do this
self.demoDH.setSytemPrameters(self.p, self.q)
self.private_DH = self.demoDH.setPrivate(
) #private first and public after private is random select
self.public_DH = self.demoDH.setPublic(
) # for create session key and this goes to the user
def session(self, public_key_U):
self.sessionKey = self.demoDH.setSession(
public_key_U) #generate by User public key
def getPublic_DH(self):
return self.public_DH
def getSession_HD(self):
return self.sessionKey
#data exchange phase
def dataExchange(
self
): #generate components no need to create session and IV as the user does
self.demoHMAC = HMAC()
self.demoCBC = CBC()
def setData(self, sessionkey, IVA): #this must be top-secret
self.demoCBC.setkey(sessionkey, IVA)
def setHMAC(self, m): #for the user verfication message
self.messageHMAC = m
def dataExchange2(self,
taylor): #decrypt the partial messages, para is arrray
msg = self.demoCBC.decrypt(taylor) # return as string
if self.messageHMAC == self.demoHMAC.HMAC(self.sessionKey,
msg): #check verification
print("Authorized User")
else:
print("Who are you?")
def HMAC1(self): #for the server verfication message
swift = "at shined In the sky, the pretty lights. And our daddies used to"
m = self.demoHMAC.HMAC(self.sessionKey, swift)
return m # string type
def dataExchange3(self): #encrypt the message
swift = "at shined In the sky, the pretty lights. And our daddies used to"
self.swiftArray = self.demoCBC.encrypt(swift)
return self.swiftArray
