예제 #1
0
 def pre_key_generation(self):
     if self.pre_dh_state == 0:
         sys.stdout.write("Pre Key Generation Started. Please Wait...\n")
         self.dh = DH()
         self.pre_dh_state = 1
         sys.stdout.write("Pre Key Generation Completed.\n")
         self.display()
예제 #2
0
 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
예제 #3
0
 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
예제 #4
0
 def addConnection(self, connectionPort, receivedKey=None):
     if receivedKey:
         self.connections[connectionPort] = {"name":None, "dh": DH(self.mySecretKey)}
         self.connections[connectionPort]["dh"].computeSharedKey(receivedKey)
         self.sendKeyToConnection(connectionPort, False)
     else:
         self.connections[connectionPort] = {"name":None, "dh": DH(self.mySecretKey)}
         self.sendKeyToConnection(connectionPort, True)
     print("Added connection",connectionPort)
예제 #5
0
 def __init__(self, myPort, mySecretKey, myName, addressOfPublicServer=10009):
     self.myName = myName
     self.myPort = myPort
     self.mySecretKey = mySecretKey
     self.myDH = DH(self.mySecretKey)
     self.addressOfPublicServer = addressOfPublicServer
     self.signaturePublicKey, self.signaturePrivateKey = getKeys()          ## as strings
     self.connections = {}
     self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     self.sock.bind(('localhost',self.myPort))
     self.registerToNetwork()
     self.receiveThread = threading.Thread(target=self.receiveThreadFunction, name=self.myName)
     self.receiveThread.start()
     self.currentNewConnectionPublicKey = None
     self.networkActivityLoggerPort = 10010
예제 #6
0
    def keyReceived(self, connectionPort, dataDict):
        digitalSignature = dataDict["digitalSignature"]
        self.getPublicKeyForNewConnection(connectionPort)
        publicKey = dataDict["publicKey"]

        #print("Key received from -", connectionPort, ", digitalSignature -",digitalSignature, ", public key -", publicKey,", signaturePublicKey -", self.currentNewConnectionPublicKey)
        # print("for debug " ,decryptor(digitalSignature, self.currentNewConnectionPublicKey),connectionPort)

        if decryptor(digitalSignature, self.currentNewConnectionPublicKey) != publicKey:
            print("Error - unexpected behaviour")    
            return                       

        if connectionPort in self.connections:
            # connection port in dictionary
            self.connections[connectionPort]["dh"].computeSharedKey(dataDict["publicKey"])
            self.connections[connectionPort]["name"] = dataDict["name"]
            if dataDict["requestKey"]:
                # other needs key
                self.sendKeyToConnection(connectionPort)
        else:            
            # connection port not in dictionary
            # receive new connection
            self.connections[connectionPort] = {"name":dataDict["name"], "dh": DH(self.mySecretKey, dataDict["publicKey"])}
            if dataDict["requestKey"]:
                self.sendKeyToConnection(connectionPort)
            print("Log - new connection",dataDict["name"],"added")
예제 #7
0
class TestDH(unittest.TestCase):
    # create a DH object and
    # set a fixed prvsecret instead of a random number
    def setUp(self):
        self.alice = DH(321, 2203)
        self.alice.prvsecret = 12
        self.bob = DH(321, 2203)
        self.bob.prvsecret = 19

    def test_gen_pubkey(self):
        self.assertEqual(self.alice.gen_pubkey(), 486)
        self.assertEqual(self.bob.gen_pubkey(), 1876)

    def test_gen_shared_secret(self):
        self.assertEqual(self.alice.gen_shared_secret(1876), 956)
        self.assertEqual(self.bob.gen_shared_secret(486), 956)

    def test_set_shared_secret(self):
        self.alice.set_shared_secret(1876)
        self.bob.set_shared_secret(486)
        self.assertEqual(self.alice.sharedsecret, self.bob.sharedsecret)

    def test_DH_init(self):
        self.assertRaises(ValueError, DH, 2, 2)
예제 #8
0
class Client:
    def __init__(self, myPort, mySecretKey, myName, addressOfPublicServer=10009):
        self.myName = myName
        self.myPort = myPort
        self.mySecretKey = mySecretKey
        self.myDH = DH(self.mySecretKey)
        self.addressOfPublicServer = addressOfPublicServer
        self.signaturePublicKey, self.signaturePrivateKey = getKeys()          ## as strings
        self.connections = {}
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.bind(('localhost',self.myPort))
        self.registerToNetwork()
        self.receiveThread = threading.Thread(target=self.receiveThreadFunction, name=self.myName)
        self.receiveThread.start()
        self.currentNewConnectionPublicKey = None
        self.networkActivityLoggerPort = 10010

    # registers to network // sends public key to public
    def registerToNetwork(self):
        print("Registering to network")
        messageDict = {"type": "register", "signaturePublicKey":self.signaturePublicKey, "name": self.myName}
        self.logNetworkActivity(messageDict)
        self.sock.sendto(self.dictToBinary(messageDict), ("localhost",self.addressOfPublicServer))
        print("Done")

    # get signaturePublicKey
    def getPublicKeyForNewConnection(self, connectionPort):
        receiverThread = threading.Thread(target=self.receiveFromPublicThreadFunction, name="signature receiver thread")
        receiverThread.start()
        messageDict = {"type": "verify", "entityAddress": connectionPort}
        self.logNetworkActivity(messageDict)
        self.sock.sendto(self.dictToBinary(messageDict), ('localhost',self.addressOfPublicServer))
        receiverThread.join()

    def receiveFromPublicThreadFunction(self):
        while True:
            data, recvAddress = self.sock.recvfrom(4096)
            dataDict = self.binaryToDict(data)
            if dataDict["type"]=="receiveSignaturePublicKey":
                self.currentNewConnectionPublicKey = dataDict["signaturePublicKey"]
                break

    # receive encrypted message
    def messageReceived(self, connectionPort, dataDict):
        if self.connections[connectionPort]["dh"].getSharedKey():
            print("Message from",self.connections[connectionPort]["name"],"-",decrypt(dataDict["message"],self.connections[connectionPort]["dh"].getSharedKey()))
        else:
            print("Error - Key not available to decrypt")

    # receive key
    def keyReceived(self, connectionPort, dataDict):
        digitalSignature = dataDict["digitalSignature"]
        self.getPublicKeyForNewConnection(connectionPort)
        publicKey = dataDict["publicKey"]

        #print("Key received from -", connectionPort, ", digitalSignature -",digitalSignature, ", public key -", publicKey,", signaturePublicKey -", self.currentNewConnectionPublicKey)
        # print("for debug " ,decryptor(digitalSignature, self.currentNewConnectionPublicKey),connectionPort)

        if decryptor(digitalSignature, self.currentNewConnectionPublicKey) != publicKey:
            print("Error - unexpected behaviour")    
            return                       

        if connectionPort in self.connections:
            # connection port in dictionary
            self.connections[connectionPort]["dh"].computeSharedKey(dataDict["publicKey"])
            self.connections[connectionPort]["name"] = dataDict["name"]
            if dataDict["requestKey"]:
                # other needs key
                self.sendKeyToConnection(connectionPort)
        else:            
            # connection port not in dictionary
            # receive new connection
            self.connections[connectionPort] = {"name":dataDict["name"], "dh": DH(self.mySecretKey, dataDict["publicKey"])}
            if dataDict["requestKey"]:
                self.sendKeyToConnection(connectionPort)
            print("Log - new connection",dataDict["name"],"added")

    # thread that receives messages by listening to connection
    def receiveThreadFunction(self):
        while True:
            data, recvAddress = self.sock.recvfrom(4096)
            dataDict = self.binaryToDict(data)
            recvPort = recvAddress[1]
            # routing request appropriatly
            if dataDict["type"]=="message":
                self.messageReceived(recvPort, dataDict)
            if dataDict["type"]=="key":
                self.keyReceived(recvPort, dataDict)

    # make new conn
    def addConnection(self, connectionPort, receivedKey=None):
        if receivedKey:
            self.connections[connectionPort] = {"name":None, "dh": DH(self.mySecretKey)}
            self.connections[connectionPort]["dh"].computeSharedKey(receivedKey)
            self.sendKeyToConnection(connectionPort, False)
        else:
            self.connections[connectionPort] = {"name":None, "dh": DH(self.mySecretKey)}
            self.sendKeyToConnection(connectionPort, True)
        print("Added connection",connectionPort)

    # send shared key to all
    def sendKeyToConnection(self, connectionPort, requestKey=False):
        digitalSignature = self.generateDigitalSignature(self.myDH.getPublicKey())
        messageDict = {"type": "key", "name": self.myName, "publicKey": self.connections[connectionPort]["dh"].getPublicKey(), "requestKey": requestKey, "digitalSignature":digitalSignature}
        
        # for _ in messageDict.keys():
        #     print(type(messageDict[_]))
        self.logNetworkActivity(messageDict)
        self.sock.sendto(self.dictToBinary(messageDict),('localhost',connectionPort))

    # send encrypted message
    def sendMessage(self, connectionPort, message):
        if type(connectionPort) is str:
            for conn in self.connections:
                if self.connections[conn]==connectionPort:
                    connectionPort = conn
                    break
        if self.connections[connectionPort]["dh"].getSharedKey() is None:
            # shared key not available
            print("Error - channel not protected")
        else:
            # shared key available
            encryptedMessage = encrypt(message, self.connections[connectionPort]["dh"].getSharedKey())
            messageDict = {"type": "message","name": self.myName, "message": encryptedMessage}
            self.logNetworkActivity(messageDict)
            self.sock.sendto(self.dictToBinary(messageDict),('localhost',connectionPort))

    # region utility functions
    def logNetworkActivity(self, message):
        if type(message) is type({1:1}):
            self.sock.sendto(self.dictToBinary(message), ("localhost", 10010))
        else:
            self.sock.sendto(message, ("localhost", 10010))

    def generateDigitalSignature(self, connectionPort):
        return encryptor(connectionPort, self.signaturePrivateKey)

    def connectionsStatus(self):
        print("No. of connections -", len(self.connections))
        for conn in self.connections:
            print("    Connection name -",self.connections[conn]["name"], end=", ")
            self.connections[conn]["dh"].toString()
            
    def dictToBinary(self, inputDict):
        tempJSON = pickle.dumps(inputDict)
        return tempJSON
    
    def binaryToDict(self, inputBinary):
        # tempJSON = inputBinary.decode()
        return pickle.loads(inputBinary) 
    # endregion
예제 #9
0
 def create_public_keys(self):
     self.log(f'Creating public keys...')
     key_1 = sympy.randprime(2**17, 2**18)
     key_2 = DH.primRoots(key_1)[0]
     self.log(f'Public Keys created {key_1} - {key_2}')
     return (key_1, key_2)
예제 #10
0
#!/usr/bin/env python
"""
example diffie-hellman keyexchange

for more information about DH see:
http://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange
"""
from DH import DH

PRIMITIVE_ROOT = 42
PRIME = 44318

ALICE = DH(PRIMITIVE_ROOT, PRIME)
print "ALICE: g=%i, p=%i" % (ALICE.in_g, ALICE.in_p)
print "ALICE: secret: %i" % ALICE.prvsecret
print "ALICE: pubkey: %s\n" % ALICE.gen_pubkey()

BOB = DH(PRIMITIVE_ROOT, PRIME)
print "BOB: g=%i, p=%i" % (BOB.in_g, BOB.in_p)
print "BOB: secret: %i" % BOB.prvsecret
print "BOB: pubkey: %s\n" % BOB.gen_pubkey()

print "keyexchange..."
ALICE.set_shared_secret(BOB.gen_pubkey())
BOB.set_shared_secret(ALICE.gen_pubkey())

print "ALICE shared: %s" % ALICE.sharedsecret
print "BOB shared: %s" % BOB.sharedsecret
예제 #11
0
 def setUp(self):
     self.alice = DH(321, 2203)
     self.alice.prvsecret = 12
     self.bob = DH(321, 2203)
     self.bob.prvsecret = 19
예제 #12
0
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?")
예제 #13
0
class Transport:
    def __init__(self):
        self.uri = None
        self.socket = None
        self.shared_secret = None
        self.pre_dh_state = 0
        self.dh = None
        self.secret_chat = 0
        self.o = None
        self.org = None

    def connect(self, ip, port):
        self.uri = (ip, port)
        csocket = socket(AF_INET, SOCK_STREAM)
        try:
            csocket.connect(self.uri)
            self.socket = csocket
            return True
        except:
            return False

    def isseen(self):
        state = self.socket.recv(4).decode()
        if state == "SEEN":
            return True

    def start_secret_chat(self):
        self.socket.send(b"STARTSECCHAT")
        data = self.socket.recv(15).decode()
        if data == "STARTSECCHATACK":
            return True
        exit("Peer refused chat or timeout reached!")

    def send(self, message):
        self.socket.send(message)
        if self.isseen():
            return True
        return True

    def pre_key_generation(self):
        if self.pre_dh_state == 0:
            sys.stdout.write("Pre Key Generation Started. Please Wait...\n")
            self.dh = DH()
            self.pre_dh_state = 1
            sys.stdout.write("Pre Key Generation Completed.\n")
            self.display()

    def communicate(self):
        self.pre_key_generation()
        while True:
            rList, wList, error_sockets = select.select([self.socket, sys.stdin], [], [])
            for sock in rList:
                if sock == self.socket:
                    data = sock.recv(1024)
                    if self.secret_chat == 1 and data[:4] != b"SEEN" and data[:15] != b"STARTSECCHATREQ":
                        msg_key = data[:16]
                        d_msg = self.o.decrypt(data, msg_key, self.org)
                        sock.send(b"SEEN")
                        return d_msg
                    if data[:15] == b"STARTSECCHATREQ" and self.secret_chat == 0:
                        answer = input("New secret chat request. Do you want to accept? (Y/n): ")
                        if answer.lower() == "y" or answer.lower() == '':
                            self.org = "op"
                            self.socket.send(b"STARTSECCHATACK")
                        else:
                            self.socket.send(b"STARTSECCHATNACK")
                            sys.stdout.write("Peer refused secret chat connection!\n")
                            self.display()
                    elif data[:16] == b"STARTSECCHATNACK":
                        sys.stdout.write("Peer refused secret chat connection!\n")
                        self.display()
                    elif data[:15] == b"STARTSECCHATACK":
                        self.org = "org"
                        self.dh.gen_private()
                        self.socket.send(b"DHPARAMS" + self.dh.dh_parameters)
                    elif data[:8] == b"DHPARAMS":
                        self.dh.dh_parameters = data[8:]
                        self.dh.gen_private()
                        self.dh.gen_public()
                        self.socket.send(b"PPUBLICKEY" + self.dh.public_key)
                    elif data[:10] == b"PPUBLICKEY":
                        peer_pub_key = data[10:]
                        self.shared_secret = self.dh.gen_shared_key(peer_pub_key)
                        self.o = Oracle(self.shared_secret)
                        self.secret_chat = 1
                        sys.stdout.write("Secret shared key generated\n")
                        self.display()
                        sys.stdout.write("~~~ [+] Secret chat started [+] ~~~\n")
                        self.display()
                        if self.dh.public_key is None:
                            self.dh.gen_public()
                            self.socket.send(b"PPUBLICKEY" + self.dh.public_key)
                    elif data[:4] == b"SEEN":
                        sys.stdout.write("[*] Seen\n")
                        self.display()
                    else:
                        sock.send(b"SEEN")
                        return data
                else:
                    msg = sys.stdin.readline()
                    if msg.strip() == "/help":
                        sys.stdout.write("/help : Help  /secret : Starting secret chat\n")
                        self.display()
                    elif msg.strip() == "/secret":
                        if self.secret_chat == 0:
                            self.socket.send(b"STARTSECCHATREQ")
                            return "SENT"
                        else:
                            return b"Secret chat already established."

                    elif self.secret_chat == 1 and self.shared_secret is not None:
                        e_msg = self.o.encrypt(msg.encode(), self.org)
                        if self.socket.send(e_msg):
                            return "SENT"
                    elif self.socket.send(msg.encode()) and msg != '':
                        return "SENT"

    def display(self):
        you = "\33[33m\33[1m> \33[0m"
        sys.stdout.write(you)
        sys.stdout.flush()
import sys
from DH import DH
from random import randint

a = DH(sys.maxsize - 1, 5).setPrivateKey(randint(0, 99999))
b = DH(sys.maxsize - 1, 5).setPrivateKey(randint(0, 88888))

a.setForeignKey(b.sharedKey)
b.setForeignKey(a.sharedKey)

print(a.sessionKey)
print(b.sessionKey)
예제 #15
0
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
예제 #16
0
 def create_shared_key(self, key_1, key_2):
     self.log('Creating Shared Key...')
     self.dh = DH(key_2, key_1)
     self.dh.create_shared_key()
     self.log('Shared Key Created!')
     return self.dh.shared_key
예제 #17
0
class Messenger(wx.Frame):
    def __init__(self):
        super().__init__(parent=None, title='CryptoChat Application')
        self.InitUI()
        self.Centre()

        self.makeMenuBar()

        self.CreateStatusBar()
        self.log(
            "Write your usser name and Server Address, then Click to connect..."
        )

        self.Show()

        self.connected = False
        self.sessionOpen = False

        self.dh = None
        self.users = {}

    def InitUI(self):
        panel = wx.Panel(self)
        vbox = wx.BoxSizer(wx.VERTICAL)

        hbUser = wx.BoxSizer(wx.HORIZONTAL)
        self.lblUser = wx.StaticText(panel, label='User Name')
        self.txtUser = wx.TextCtrl(panel)
        hbUser.Add(self.lblUser, flag=wx.RIGHT, border=8)
        hbUser.Add(self.txtUser, proportion=1)
        vbox.Add(hbUser,
                 flag=wx.EXPAND | wx.LEFT | wx.RIGHT | wx.TOP,
                 border=10)
        vbox.Add((-1, 5))

        hbServer = wx.BoxSizer(wx.HORIZONTAL)
        self.lblSever = wx.StaticText(panel, label='Server Address')
        self.txtServer = wx.TextCtrl(panel, value='http://localhost:5000')
        self.btnConnect = wx.Button(panel, label='Connect')
        hbServer.Add(self.lblSever, flag=wx.RIGHT, border=8)
        hbServer.Add(self.txtServer, proportion=1)
        hbServer.Add(self.btnConnect, proportion=0.5)
        vbox.Add(hbServer,
                 flag=wx.EXPAND | wx.LEFT | wx.RIGHT | wx.TOP,
                 border=10)
        vbox.Add((-1, 10))

        hbUsers = wx.BoxSizer(wx.HORIZONTAL)
        self.lblUsers = wx.StaticText(panel, label='Connected users')
        self.cmbUsers = wx.ComboBox(panel)
        self.btnChatWith = wx.Button(panel, label='Chat...')
        hbUsers.Add(self.lblUsers, flag=wx.RIGHT, border=8)
        hbUsers.Add(self.cmbUsers, proportion=1)
        hbUsers.Add(self.btnChatWith, proportion=0.5)
        vbox.Add(hbUsers,
                 flag=wx.EXPAND | wx.LEFT | wx.RIGHT | wx.TOP,
                 border=10)
        vbox.Add((-1, 10))

        hbChat = wx.BoxSizer(wx.HORIZONTAL)
        lblChat = wx.StaticText(panel, label='Chat Box')
        hbChat.Add(lblChat)
        vbox.Add(hbChat, flag=wx.LEFT | wx.TOP, border=10)
        vbox.Add((-1, 10))

        hbChatBx = wx.BoxSizer(wx.HORIZONTAL)
        self.txtChat = rt.RichTextCtrl(panel,
                                       style=wx.VSCROLL | wx.HSCROLL
                                       | wx.TE_READONLY)
        hbChatBx.Add(self.txtChat, proportion=1, flag=wx.EXPAND)
        vbox.Add(hbChatBx,
                 proportion=1,
                 flag=wx.EXPAND | wx.RIGHT | wx.EXPAND,
                 border=10)

        hbMsg = wx.BoxSizer(wx.HORIZONTAL)
        self.txtMsg = wx.TextCtrl(panel)
        self.btnSendMsg = wx.Button(panel, label='Send')
        hbMsg.Add(self.txtMsg, proportion=1)
        hbMsg.Add(self.btnSendMsg, proportion=0.3)
        vbox.Add(hbMsg,
                 proportion=1,
                 flag=wx.EXPAND | wx.LEFT | wx.RIGHT | wx.TOP,
                 border=10)
        vbox.Add((-1, 10))

        panel.SetSizer(vbox)

        self.cmbUsers.Enabled = False
        self.btnChatWith.Enabled = False

        self.btnConnect.Bind(wx.EVT_BUTTON, self.OnConnect)
        self.btnChatWith.Bind(wx.EVT_BUTTON, self.OnChatWith)
        self.btnSendMsg.Bind(wx.EVT_BUTTON, self.OnSendMsg)

        self.initControls()

    def log(self, msg):
        self.SetStatusText(msg)
        logger.info(msg)

    def initControls(self):
        self.cmbUsers.Enabled = False
        self.btnChatWith.Enabled = False
        self.txtChat.Enabled = False
        self.txtMsg.Enabled = False
        self.btnSendMsg.Enabled = False

    def makeMenuBar(self):
        fileMenu = wx.Menu()
        exitItem = fileMenu.Append(wx.ID_EXIT)
        helpMenu = wx.Menu()
        aboutItem = helpMenu.Append(wx.ID_ABOUT)

        menuBar = wx.MenuBar()
        menuBar.Append(fileMenu, "&File")
        menuBar.Append(helpMenu, "&Help")

        self.SetMenuBar(menuBar)

        self.Bind(wx.EVT_MENU, self.OnExit, exitItem)
        self.Bind(wx.EVT_MENU, self.OnAbout, aboutItem)

    def create_public_keys(self):
        self.log(f'Creating public keys...')
        key_1 = sympy.randprime(2**17, 2**18)
        key_2 = DH.primRoots(key_1)[0]
        self.log(f'Public Keys created {key_1} - {key_2}')
        return (key_1, key_2)

    def create_shared_key(self, key_1, key_2):
        self.log('Creating Shared Key...')
        self.dh = DH(key_2, key_1)
        self.dh.create_shared_key()
        self.log('Shared Key Created!')
        return self.dh.shared_key

    def create_full_key(self, shared_key):
        self.log(f'Creating Full key with shared key {shared_key}...')
        self.dh.create_full_key(shared_key)

    def next_key(self):
        self.log("Generating new private key...")
        self.dh.next_key()
        self.log('Creating Shared Key...')
        self.log(
            f'Shared Key Created! {self.dh.private_key} - {self.dh.shared_key}'
        )
        return self.dh.shared_key

    def OnConnect(self, event):
        if not self.connected:  #Connect to web server
            self.log("Connecting to server...")
            #try:
            self.btnConnect.LabelText = 'Disconnect'
            user = self.txtUser.Value
            server = self.txtServer.Value
            sio.connect(server)
            self.log(
                f'Connected to server {server} with user {user} session id:{sio.sid}'
            )
            sio.emit('login', {'session': sio.sid, 'user': user})
            self.cmbUsers.Clear()
            self.connected = True
            # except:
            # err = sys.exc_info()[0]
            # log(f"System error! {err}")
        else:  #Disconnect
            self.log("Disconecting from server...")
            self.btnConnect.LabelText = 'Connect'
            sio.emit('logout', {
                'session': sio.sid,
                'user': self.txtUser.Value
            })
            self.connected = False
            self.log("Disconnected")
            sio.disconnect()
        self.txtUser.Enabled = not self.connected
        self.txtServer.Enabled = not self.connected
        self.initControls()

    def OnChatWith(self, event):
        user = self.cmbUsers.GetStringSelection()
        key_1, key_2 = self.create_public_keys()
        requester_shared_key = self.create_shared_key(key_1, key_2)
        data = {
            'requester': self.txtUser.Value,
            'requester_sid': sio.sid,
            'requester_shared_key': requester_shared_key,
            'user': user,
            'user_sid': self.users[user],
            'user_shared_key': None,
            'key_1': key_1,
            'key_2': key_2
        }
        self.log(f'Sending chat request to user {user}...')
        sio.emit('chatwith', data)

    def OnSendMsg(self, event):
        msg = self.txtMsg.Value
        now = datetime.datetime.now()
        nowStr = now.strftime("%Y-%m-%d %H:%M:%S")
        if len(msg):
            msg = f'{nowStr} \t {self.txtUser.Value}: {self.txtMsg.Value}'
            self.txtChat.BeginTextColour((255, 0, 0))
            self.txtChat.WriteText(msg)
            self.txtChat.EndTextColour()
            self.txtChat.Newline()
            self.log('Encrypting message...')
            enc = self.dh.encrypt(msg)
            user = self.cmbUsers.GetStringSelection()
            s_id = self.users[user]
            data = {
                'requester': self.txtUser.Value,
                'requester_sid': sio.sid,
                'requester_shared_key': self.dh.shared_key,
                'user': user,
                'user_sid': s_id,
                'user_shared_key': None,
                'enc': enc
            }
            self.log(f'Sending Encrypted  message...{enc}')
            sio.emit('sendmessage', data)
            self.txtMsg.Clear()

    def decryptMessage(self, enc):
        msg = self.dh.decrypt(enc)
        self.log('Decrypting message...')
        self.txtChat.BeginTextColour((0, 150, 100))
        self.txtChat.WriteText(msg)
        self.txtChat.EndTextColour()
        self.txtChat.Newline()
        self.log('Message decrypted!')

    def OnExit(self, event):
        """Close the frame, terminating the application."""
        self.Close(True)

    def OnAbout(self, event):
        """Display an About Dialog"""
        message = '''
            Author: Asahi Cantu Moreno
            Application Description: This project emulates the diffe-hallman encryption mechanism to securely send messages from the web
            from one user to another.
            Created for the assignment of  Network Security and Cryptography for the University of Stavanger
        '''
        wx.MessageBox(message, "About Client Application",
                      wx.OK | wx.ICON_INFORMATION)