ObjectSecurityProtocol/Server.py at master · CarlTern/ObjectSecurityProtocol · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import socket
from Crypto.Cipher import AES
from Crypto.Util import number

UDP_IP = "127.0.0.1"
UDP_PORT = 5005

class Server:
    #Constructor, we need to add self variable in constructor and methods in order to point to the object.
    def __init__(self, localAdress, port):
        self.localAdress = localAdress
        self.port = port
        self.UDPClientSocket = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
        self.UDPClientSocket.bind((localAdress, port))

    def run(self):
        print("Welcome to server side!")
        print("Instance is running on: " + str(self.localAdress) + ":" + str(self.port))
        while(True):
            data, addr = self.UDPClientSocket.recvfrom(1024) # buffer size is 1024 bytes
            if(data is not None):
                if(chr(data[0]) == "h"):
                    print ("Received handshake from", addr)
                    self.handleHandshake(data)
                    handShakeDone = True;
                if(chr(data[0]) == "c" and (self.secret is not None) and handShakeDone):
                    print("Received data from", addr)
                    self.handleSecureIncommingData(data)
                    handShakeDone = False;

    def handleHandshake(self, data):
        handShake = bytes("h", "utf-8") # or c for communication
        self.privateKey = number.getRandomInteger(224)
        prime = data[1:257]
        prime = int.from_bytes(prime, byteorder='big')
        generatorOfP = data[257 : 285]
        generatorOfP = int.from_bytes(generatorOfP, byteorder='big')
        ClientpublicKey = data[285 : 541]
        ClientpublicKey = int.from_bytes(ClientpublicKey, byteorder='big')

        secret = pow(ClientpublicKey, self.privateKey, prime)
        self.secret = str(secret)[0:32]
        newPublicKey = pow(generatorOfP, self.privateKey, prime)
        prime = prime.to_bytes(256, byteorder='big')
        generatorOfP = generatorOfP.to_bytes(28, byteorder='big')
        newPublicKey = newPublicKey.to_bytes(256, byteorder='big')

        data = handShake + prime + generatorOfP  + newPublicKey
        #first byte is header, the rest is keys.
        self.UDPClientSocket.sendto( data , (self.localAdress, 5004))
        print("Secret:", self.secret)

    def handleSecureIncommingData(self, data):
        communicationFlag = data[0].to_bytes(1,byteorder="big")
        nonce = data [1:12]
        ciphertext = data [12:46]
        mac = data [46:62]
        messageLength = data [62:64]
        aesCipher = AES.new(bytes(self.secret,'utf-8'), AES.MODE_CCM, nonce)
        aesCipher.update(communicationFlag)
        secretMessage = aesCipher.decrypt(ciphertext)
        secretMessageConcat = secretMessage[0:int.from_bytes(messageLength, byteorder = 'big')]
        try:
            aesCipher.verify(mac)
            data = secretMessageConcat.decode("utf-8")
            print("Success! Secret message: ", data)
        except ValueError:
            print ("Error: Either Key is not correct or message the message is corrupted")

if __name__ == "__main__":
    server = Server(UDP_IP, UDP_PORT)
    server.run()