Python Language
सॉकेट और संदेश एन्क्रिप्शन / डिक्रिप्शन क्लाइंट और सर्वर के बीच
खोज…
परिचय
क्रिप्टोग्राफी का उपयोग सुरक्षा उद्देश्यों के लिए किया जाता है। IDEA एन्क्रिप्शन MODE CTR का उपयोग करके Python में एन्क्रिप्शन / डिक्रिप्शन के इतने सारे उदाहरण नहीं हैं। इस दस्तावेज का उद्देश्य:
स्टेशन-टू-स्टेशन संचार में RSA डिजिटल हस्ताक्षर योजना का विस्तार और कार्यान्वयन। संदेश की अखंडता के लिए हैशिंग का उपयोग करना, यह SHA-1 है। सरल कुंजी परिवहन प्रोटोकॉल का उत्पादन करें। IDEA एन्क्रिप्शन के साथ कुंजी एन्क्रिप्ट करें। ब्लॉक सिफर का मोड काउंटर मोड है
टिप्पणियों
प्रयुक्त भाषा: पायथन 2.7 (डाउनलोड लिंक: https://www.python.org/downloads/ )
लाइब्रेरी में प्रयुक्त:
* PyCrypto (डाउनलोड लिंक: https://pypi.python.org/pypi/pycrypto )
* PyCryptoPlus (डाउनलोड लिंक: https://github.com/doegox/python-cryptoplus )
पुस्तकालय स्थापना:
PyCrypto: फ़ाइल को अनज़िप करें। निर्देशिका में जाएं और विंडोज़ के लिए लिनक्स (alt + ctrl + t) और CMD (शिफ्ट + राइट क्लिक + सेलेक्ट कमांड प्रॉम्प्ट यहाँ खोलें) के लिए टर्मिनल खोलें। उसके बाद python setup.py install (Make Sure Python Environment को Windows OS में ठीक से सेट किया गया है) लिखें
PyCryptoPlus: आखिरी लाइब्रेरी के रूप में।
कार्य कार्यान्वयन: कार्य को दो भागों में विभाजित किया गया है। एक है हैंडशेक प्रोसेस और दूसरा है कम्युनिकेशन प्रोसेस। सॉकेट सेटअप:
सार्वजनिक कुंजी बनाने के साथ-साथ सार्वजनिक और निजी कुंजी बनाने के लिए, हमें अब सॉकेट सेटअप करने की आवश्यकता है। सॉकेट स्थापित करने के लिए, हमें "इंपोर्ट सॉकेट" और कनेक्ट (क्लाइंट के लिए) या सर्वर (आईपी के लिए) बाइंड के साथ एक अन्य मॉड्यूल को आयात करना होगा और उपयोगकर्ता से सॉकेट के साथ पोर्ट प्राप्त करना होगा।
----------ग्राहक की ओर----------
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM) host = raw_input("Server Address To Be Connected -> ") port = int(input("Port of The Server -> ")) server.connect((host, port))----------सर्वर साइड---------
try: #setting up socket server = socket.socket(socket.AF_INET,socket.SOCK_STREAM) server.bind((host,port)) server.listen(5) except BaseException: print "-----Check Server Address or Port-----""Socket.AF_INET, socket.SOCK_STREAM" हमें स्वीकार () फ़ंक्शन और संदेश मूल सिद्धांतों का उपयोग करने की अनुमति देगा। इसके बजाय, हम “socket.AF_INET, socket.SOCK_DGRAM” का भी उपयोग कर सकते हैं, लेकिन उस समय हमें setblocking (मान) का उपयोग करना होगा।
हैंडशेक प्रक्रिया:
- (ग्राहक) पहला काम सार्वजनिक और निजी कुंजी बनाना है। निजी और सार्वजनिक कुंजी बनाने के लिए, हमें कुछ मॉड्यूल आयात करने होंगे। वे हैं: क्रिप्टो आयात से यादृच्छिक और Crypto.PublicKey आयात RSA से। कुंजियाँ बनाने के लिए, हमें कोडों की कुछ सरल पंक्तियों को लिखना होगा:
random_generator = Random.new().read
key = RSA.generate(1024,random_generator)
public = key.publickey().exportKey()
random_generator " क्रिप्टो आयात रैंडम से " मॉड्यूल से लिया गया है। कुंजी " Crypto.PublicKey इंपोर्ट आरएसए " से ली गई है, जो यादृच्छिक वर्ण उत्पन्न करके 1024 के आकार की एक निजी कुंजी बनाएगी। सार्वजनिक पहले से निर्मित निजी कुंजी से सार्वजनिक कुंजी निर्यात कर रहा है।
(ग्राहक) सार्वजनिक और निजी कुंजी बनाने के बाद, हमें SHA-1 हैश का उपयोग करके सर्वर पर भेजने के लिए सार्वजनिक कुंजी हैश करना होगा। SHA-1 हैश का उपयोग करने के लिए हमें "इंपोर्ट हैशलीब" लिखकर दूसरे मॉड्यूल को आयात करना होगा। सार्वजनिक कुंजी के पास हम कोड की दो पंक्तियां लिखेंगे:
hash_object = hashlib.sha1(public) hex_digest = hash_object.hexdigest()
यहाँ hash_object और hex_digest हमारा परिवर्तनशील है। इसके बाद, क्लाइंट सर्वर पर hex_digest और पब्लिक को भेज देगा और सर्वर क्लाइंट की और सार्वजनिक कुंजी के नए हैश से प्राप्त हैश की तुलना करके उन्हें सत्यापित करेगा। यदि नया हैश और हैश क्लाइंट से मेल खाता है, तो यह अगली प्रक्रिया में चला जाएगा। जैसा कि क्लाइंट से भेजा गया सार्वजनिक स्ट्रिंग के रूप में है, यह सर्वर साइड में कुंजी के रूप में उपयोग करने में सक्षम नहीं होगा। इसे रोकने और स्ट्रिंग सार्वजनिक कुंजी को rsa सार्वजनिक कुंजी में परिवर्तित करने के लिए, हमें server_public_key = RSA.importKey(getpbk) , यहाँ getpbk क्लाइंट से सार्वजनिक कुंजी है।
(SERVER) सत्र कुंजी बनाने के लिए अगला चरण है। यहाँ, मैंने एक यादृच्छिक कुंजी "कुंजी = os.urandom (16)" बनाने के लिए "os" मॉड्यूल का उपयोग किया है जो हमें 16bit लंबी कुंजी देगा और उसके बाद मैंने "AES.MODE_CTR" में उस कुंजी को एन्क्रिप्ट किया है और इसे फिर से शुरू किया है। SHA-1 के साथ:
#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()
तो en_digest हमारी सत्र कुंजी होगी।
(सर्वर) हैंडशेक प्रक्रिया के अंतिम भाग के लिए क्लाइंट से प्राप्त सार्वजनिक कुंजी और सर्वर साइड में बनाई गई सत्र कुंजी को एन्क्रिप्ट करना है।
#encrypting session key and public key E = server_public_key.encrypt(encrypto,16)
एन्क्रिप्ट करने के बाद, सर्वर क्लाइंट को स्ट्रिंग के रूप में भेज देगा।
(ग्राहक) सर्वर से (सार्वजनिक और सत्र कुंजी) की एन्क्रिप्टेड स्ट्रिंग प्राप्त करने के बाद, क्लाइंट उन्हें निजी कुंजी का उपयोग करके डिक्रिप्ट करेगा जो पहले सार्वजनिक कुंजी के साथ बनाया गया था। जैसा कि एन्क्रिप्टेड (सार्वजनिक और सत्र कुंजी) स्ट्रिंग के रूप में था, अब हमें इसे eval () का उपयोग करके एक कुंजी के रूप में वापस प्राप्त करना होगा। यदि डिक्रिप्शन किया जाता है, तो हैंडशेक प्रक्रिया भी पूरी हो जाती है क्योंकि दोनों पक्ष यह पुष्टि करते हैं कि वे एक ही कुंजी का उपयोग कर रहे हैं। डिक्रिप्ट करने के लिए:
en = eval(msg) decrypt = key.decrypt(en) # hashing sha1 en_object = hashlib.sha1(decrypt) en_digest = en_object.hexdigest()
मैंने यहां SHA-1 का उपयोग किया है ताकि यह आउटपुट में पठनीय हो।
संचार प्रक्रिया:
संचार प्रक्रिया के लिए, हमें IDEA एन्क्रिप्शन MODE_CTR के लिए कुंजी के रूप में दोनों ओर से सत्र कुंजी का उपयोग करना होगा। दोनों पक्ष सत्र कुंजी का उपयोग करके IDEA.MODE_CTR के साथ संदेशों को एन्क्रिप्ट और डिक्रिप्ट करेंगे।
(एन्क्रिप्शन) आईडीईए एन्क्रिप्शन के लिए, हमें 16 बिट की कुंजी चाहिए और कॉल करने योग्य होना चाहिए। MODE_CTR में काउंटर अनिवार्य है। सत्र कुंजी जिसे हमने एन्क्रिप्ट किया है और हैशेड अब 40 के आकार का है जो IDEA एन्क्रिप्शन की सीमा कुंजी को पार कर जाएगा। इसलिए, हमें सत्र कुंजी के आकार को कम करने की आवश्यकता है। कम करने के लिए, हम फ़ंक्शन स्ट्रिंग [मूल्य: मान] में निर्मित सामान्य अजगर का उपयोग कर सकते हैं। जहां उपयोगकर्ता की पसंद के अनुसार मूल्य कोई भी हो सकता है। हमारे मामले में, मैंने "कुंजी [: 16]" किया है जहां यह कुंजी से 0 से 16 मान लेगा। यह रूपांतरण कई तरीकों से किया जा सकता है जैसे कि कुंजी [1:17] या कुंजी [16:]। अगला भाग IDEA.new () लिखकर नया IDEA एन्क्रिप्शन फ़ंक्शन बनाने के लिए है, जो प्रसंस्करण के लिए 3 तर्क लेगा। पहला तर्क KEY होगा, दूसरा तर्क IDEA एन्क्रिप्शन (हमारे मामले में, IDEA.MODE_CTR) का मोड होगा और तीसरा तर्क काउंटर होगा = जो एक कॉल करने योग्य फ़ंक्शन होना चाहिए। काउंटर = स्ट्रिंग का आकार धारण करेगा जो फ़ंक्शन द्वारा वापस आ जाएगा। काउंटर = को परिभाषित करने के लिए, हमें एक उचित मूल्यों का उपयोग करना होगा। इस मामले में, मैंने लैम्ब्डा को परिभाषित करके कुंजी के आकार का उपयोग किया है। लैम्ब्डा का उपयोग करने के बजाय, हम काउंटर.उटिल का उपयोग कर सकते हैं जो काउंटर = के लिए यादृच्छिक मूल्य उत्पन्न करता है। Counter.Util का उपयोग करने के लिए, हमें क्रिप्टो से काउंटर मॉड्यूल आयात करने की आवश्यकता है। इसलिए, कोड होगा:
ideaEncrypt = IDEA.new(key, IDEA.MODE_CTR, counter=lambda : key)
एक बार हमारे आईडिया एन्क्रिप्शन चर के रूप में "ideaEncrypt" को परिभाषित करने के बाद, हम किसी भी संदेश को एन्क्रिप्ट करने के लिए इनक्रिप्टेड फ़ंक्शन में निर्मित का उपयोग कर सकते हैं।
eMsg = ideaEncrypt.encrypt(whole)
#converting the encrypted message to HEXADECIMAL to readable eMsg =
eMsg.encode("hex").upper()
इस कोड सेगमेंट में, पूरा संदेश एन्क्रिप्टेड है और eMsg एन्क्रिप्टेड संदेश है। संदेश को एन्क्रिप्ट करने के बाद, मैंने इसे पठनीय और ऊपरी बनाने के लिए इसे HEXADECIMAL में बदल दिया है (अक्षरों को अपरकेस बनाने के लिए फ़ंक्शन में बनाया गया है। उसके बाद, यह एन्क्रिप्टेड संदेश डिक्रिप्शन के लिए विपरीत स्टेशन पर भेजा जाएगा।
- (डिक्रिप्शन)
एन्क्रिप्ट किए गए संदेशों को डिक्रिप्ट करने के लिए, हमें उन्हीं तर्कों और उसी कुंजी का उपयोग करके एक और एन्क्रिप्शन वैरिएबल बनाने की आवश्यकता होगी लेकिन इस बार वेरिएबल एन्क्रिप्टेड संदेशों को डिक्रिप्ट करेगा। पिछली बार के समान ही कोड। हालाँकि, संदेशों को डिक्रिप्ट करने से पहले, हमें हेक्साडेसिमल से संदेश को डीकोड करना होगा क्योंकि हमारे एन्क्रिप्शन पार्ट में, हमने पठनीय बनाने के लिए हेक्साडेसिमल में एन्क्रिप्टेड मैसेज को इनकोड किया। इसलिए, पूरा कोड होगा:
decoded = newmess.decode("hex")
ideaDecrypt = IDEA.new(key, IDEA.MODE_CTR, counter=lambda: key)
dMsg = ideaDecrypt.decrypt(decoded)
इन प्रक्रियाओं को एन्क्रिप्ट और डिक्रिप्ट करने के लिए सर्वर और क्लाइंट पक्ष दोनों में किया जाएगा।
सर्वर साइड कार्यान्वयन
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")
ग्राहक पक्ष कार्यान्वयन
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()