Сокеты и шифрование / дешифрование сообщений между клиентом и сервером

Введение

Примеры

  • 0

    Реализация на стороне сервера

    import socket
    import hashlib
    import os
    import time
    import itertools
    import threading
    import sys
    import Crypto.Cipher.AES as AES
    from Crypto.PublicKey import RSA
    from CryptoPlus.Cipher import IDEA
    
    #server address and port number input from admin
    host= raw_input("Server Address - > ")
    port = int(input("Port - > "))
    #boolean for checking server and port
    check = False
    done = False
    
    def animate():
        for c in itertools.cycle(['....','.......','..........','............']):
            if done:
                break
            sys.stdout.write('\rCHECKING IP ADDRESS AND NOT USED PORT '+c)
            sys.stdout.flush()
            time.sleep(0.1)
        sys.stdout.write('\r -----SERVER STARTED. WAITING FOR CLIENT-----\n')
    try:
        #setting up socket
        server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        server.bind((host,port))
        server.listen(5)
        check = True
    except BaseException:
        print "-----Check Server Address or Port-----"
        check = False
    
    if check is True:
        # server Quit
        shutdown = False
    # printing "Server Started Message"
    thread_load = threading.Thread(target=animate)
    thread_load.start()
    
    time.sleep(4)
    done = True
    #binding client and address
    client,address = server.accept()
    print ("CLIENT IS CONNECTED. CLIENT'S ADDRESS ->",address)
    print ("\n-----WAITING FOR PUBLIC KEY & PUBLIC KEY HASH-----\n")
    
    #client's message(Public Key)
    getpbk = client.recv(2048)
    
    #conversion of string to KEY
    server_public_key = RSA.importKey(getpbk)
    
    #hashing the public key in server side for validating the hash from client
    hash_object = hashlib.sha1(getpbk)
    hex_digest = hash_object.hexdigest()
    
    if getpbk != "":
        print (getpbk)
        client.send("YES")
        gethash = client.recv(1024)
        print ("\n-----HASH OF PUBLIC KEY----- \n"+gethash)
    if hex_digest == gethash:
        # creating session key
        key_128 = os.urandom(16)
        #encrypt CTR MODE session key
        en = AES.new(key_128,AES.MODE_CTR,counter = lambda:key_128)
        encrypto = en.encrypt(key_128)
        #hashing sha1
        en_object = hashlib.sha1(encrypto)
        en_digest = en_object.hexdigest()
    
        print ("\n-----SESSION KEY-----\n"+en_digest)
    
        #encrypting session key and public key
        E = server_public_key.encrypt(encrypto,16)
        print ("\n-----ENCRYPTED PUBLIC KEY AND SESSION KEY-----\n"+str(E))
        print ("\n-----HANDSHAKE COMPLETE-----")
        client.send(str(E))
        while True:
            #message from client
            newmess = client.recv(1024)
            #decoding the message from HEXADECIMAL to decrypt the ecrypted version of the message only
            decoded = newmess.decode("hex")
            #making en_digest(session_key) as the key
            key = en_digest[:16]
            print ("\nENCRYPTED MESSAGE FROM CLIENT -> "+newmess)
            #decrypting message from the client
            ideaDecrypt = IDEA.new(key, IDEA.MODE_CTR, counter=lambda: key)
            dMsg = ideaDecrypt.decrypt(decoded)
            print ("\n**New Message**  "+time.ctime(time.time()) +" > "+dMsg+"\n")
            mess = raw_input("\nMessage To Client -> ")
            if mess != "":
                ideaEncrypt = IDEA.new(key, IDEA.MODE_CTR, counter=lambda : key)
                eMsg = ideaEncrypt.encrypt(mess)
                eMsg = eMsg.encode("hex").upper()
                if eMsg != "":
                    print ("ENCRYPTED MESSAGE TO CLIENT-> " + eMsg)
                client.send(eMsg)
        client.close()
    else:
        print ("\n-----PUBLIC KEY HASH DOESNOT MATCH-----\n") 
  • 0

    Реализация на стороне клиента

    import time
    import socket
    import threading
    import hashlib
    import itertools
    import sys
    from Crypto import Random
    from Crypto.PublicKey import RSA
    from CryptoPlus.Cipher import IDEA
    
    #animating loading
    done = False
    def animate():
        for c in itertools.cycle(['....','.......','..........','............']):
            if done:
                break
            sys.stdout.write('\rCONFIRMING CONNECTION TO SERVER '+c)
            sys.stdout.flush()
            time.sleep(0.1)
    
    #public key and private key
    random_generator = Random.new().read
    key = RSA.generate(1024,random_generator)
    public = key.publickey().exportKey()
    private = key.exportKey()
    
    #hashing the public key
    hash_object = hashlib.sha1(public)
    hex_digest = hash_object.hexdigest()
    
    #Setting up socket
    server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    
    #host and port input user
    host = raw_input("Server Address To Be Connected -> ")
    port = int(input("Port of The Server -> "))
    #binding the address and port
    server.connect((host, port))
    # printing "Server Started Message"
    thread_load = threading.Thread(target=animate)
    thread_load.start()
    
    time.sleep(4)
    done = True
    
    def send(t,name,key):
        mess = raw_input(name + " : ")
        key = key[:16]
        #merging the message and the name
        whole = name+" : "+mess
        ideaEncrypt = IDEA.new(key, IDEA.MODE_CTR, counter=lambda : key)
        eMsg = ideaEncrypt.encrypt(whole)
        #converting the encrypted message to HEXADECIMAL to readable
        eMsg = eMsg.encode("hex").upper()
        if eMsg != "":
            print ("ENCRYPTED MESSAGE TO SERVER-> "+eMsg)
        server.send(eMsg)
    def recv(t,key):
        newmess = server.recv(1024)
        print ("\nENCRYPTED MESSAGE FROM SERVER-> " + newmess)
        key = key[:16]
        decoded = newmess.decode("hex")
        ideaDecrypt = IDEA.new(key, IDEA.MODE_CTR, counter=lambda: key)
        dMsg = ideaDecrypt.decrypt(decoded)
        print ("\n**New Message From Server**  " + time.ctime(time.time()) + " : " + dMsg + "\n")
    
    while True:
        server.send(public)
        confirm = server.recv(1024)
        if confirm == "YES":
            server.send(hex_digest)
    
        #connected msg
        msg = server.recv(1024)
        en = eval(msg)
        decrypt = key.decrypt(en)
        # hashing sha1
        en_object = hashlib.sha1(decrypt)
        en_digest = en_object.hexdigest()
    
        print ("\n-----ENCRYPTED PUBLIC KEY AND SESSION KEY FROM SERVER-----")
        print (msg)
        print ("\n-----DECRYPTED SESSION KEY-----")
        print (en_digest)
        print ("\n-----HANDSHAKE COMPLETE-----\n")
        alais = raw_input("\nYour Name -> ")
    
        while True:
            thread_send = threading.Thread(target=send,args=("------Sending Message------",alais,en_digest))
            thread_recv = threading.Thread(target=recv,args=("------Recieving Message------",en_digest))
            thread_send.start()
            thread_recv.start()
    
            thread_send.join()
            thread_recv.join()
            time.sleep(0.5)
        time.sleep(60)
        server.close() 

Синтаксис

Параметры

Примечания