Sockets And Message Encryption/Decryption Between Client and Server

Sockets And Message Encryption/Decryption Between Client and Server

Cryptography is used for security purposes. There are not so many examples of Encryption/Decryption in Python using IDEA encryption MODE CTR. Aim of this documentation :

Extend and implement of the RSA Digital Signature scheme in station-to-station communication. Using Hashing for integrity of message, that is SHA-1. Produce simple Key Transport protocol. Encrypt Key with IDEA encryption. Mode of Block Cipher is Counter Mode

Section 123.1: Server side Implementation

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 encrypted 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 ("\nNew 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")

Client side Implementation

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 ("\nNew 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=("------Receiving Message------
",en_digest))
thread_send.start()
thread_recv.start()
thread_send.join()
thread_recv.join()
time.sleep(0.5)
time.sleep(60)
server.close()

LEAVE A REPLY

Please enter your comment!
Please enter your name here