पाइथन के साथ क्रिप्टोग्राफी - त्वरित गाइड

क्रिप्टोग्राफी कोडेड संदेशों के माध्यम से दो उपयोगकर्ताओं के बीच संचार की कला है। क्रिप्टोग्राफी का विज्ञान एक पार्टी से दूसरे में स्थानांतरित किए गए गोपनीय संदेशों को सुरक्षा प्रदान करने के मूल उद्देश्य के साथ उभरा।

क्रिप्टोग्राफी को सूचना सुरक्षा में मान्यता के रूप में गोपनीयता और गोपनीयता का परिचय देने के लिए संदेश को छिपाने की कला और विज्ञान के रूप में परिभाषित किया गया है।

क्रिप्टोग्राफी की शब्दावली

क्रिप्टोग्राफी में अक्सर इस्तेमाल की जाने वाली शर्तों को यहाँ समझाया गया है -

सादे पाठ

सादा पाठ संदेश वह पाठ है जो पठनीय है और इसे सभी उपयोगकर्ताओं द्वारा समझा जा सकता है। सादा पाठ वह संदेश है जो क्रिप्टोग्राफी से गुजरता है।

सिफर पाठ

सिफर टेक्स्ट, सादे टेक्स्ट पर क्रिप्टोग्राफी लागू करने के बाद प्राप्त संदेश है।

एन्क्रिप्शन

सादे पाठ को सिफर पाठ में बदलने की प्रक्रिया को एन्क्रिप्शन कहा जाता है। इसे एन्कोडिंग भी कहा जाता है।

डिक्रिप्शन

सिफर टेक्स्ट को प्लेन टेक्स्ट में बदलने की प्रक्रिया को डिक्रिप्शन कहा जाता है। इसे डिकोडिंग भी कहा जाता है।

नीचे दिए गए आरेख में क्रिप्टोग्राफी की पूरी प्रक्रिया का एक चित्रण दिखाया गया है -

आधुनिक क्रिप्टोग्राफी के लक्षण

आधुनिक क्रिप्टोग्राफी की बुनियादी विशेषताएं इस प्रकार हैं -

  • यह बिट सीक्वेंस पर काम करता है।

  • यह जानकारी हासिल करने के लिए गणितीय एल्गोरिदम का उपयोग करता है।

  • इसे गोपनीयता प्राप्त करने के लिए सुरक्षित संचार चैनल में रुचि रखने वाले दलों की आवश्यकता होती है।

दोहरी शक्ति एन्क्रिप्शन, जिसे कई एन्क्रिप्शन भी कहा जाता है, पहले से ही एन्क्रिप्टेड टेक्स्ट को एक या अधिक बार एन्क्रिप्ट करने की प्रक्रिया है, या तो एक ही या अलग एल्गोरिथम / पैटर्न के साथ।

दोहरी शक्ति एन्क्रिप्शन के अन्य नामों में कैस्केड एन्क्रिप्शन या कैस्केड साइफ़रिंग शामिल हैं।

दोहरे शक्ति एन्क्रिप्शन के स्तर

डबल स्ट्रेंथ इनक्रिप्शन में एन्क्रिप्शन के विभिन्न स्तर शामिल हैं जिन्हें यहाँ नीचे समझाया गया है -

एन्क्रिप्शन की पहली परत

सिफर पाठ मूल पठनीय संदेश से हैश एल्गोरिदम और सममित कुंजी का उपयोग करके उत्पन्न होता है। बाद में असममित कुंजी की मदद से सममित कुंजियों को एन्क्रिप्ट किया जाता है। इस पैटर्न के लिए सबसे अच्छा चित्रण एक कैप्सूल में सिफर पाठ के हैश पाचन को जोड़ रहा है। रिसीवर पहले डाइजेस्ट की गणना करेगा और बाद में टेक्स्ट को यह सत्यापित करने के लिए डिक्रिप्ट करेगा कि टेक्स्ट के बीच में छेड़छाड़ नहीं की गई है।

एन्क्रिप्शन की दूसरी परत

एन्क्रिप्शन की दूसरी परत समान या अलग एल्गोरिथ्म के साथ पाठ को सिफर करने के लिए एक और परत जोड़ने की प्रक्रिया है। आमतौर पर, एक 32-बिट वर्ण लंबा सममित पासवर्ड उसी के लिए उपयोग किया जाता है।

एन्क्रिप्शन की तीसरी परत

इस प्रक्रिया में, एन्क्रिप्टेड कैप्सूल संचार साथी को एसएसएल / टीएलएस कनेक्शन के माध्यम से प्रेषित किया जाता है।

निम्नलिखित चित्र डबल एन्क्रिप्शन प्रक्रिया सचित्र दिखाता है -

हाइब्रिड क्रिप्टोग्राफी

हाइब्रिड क्रिप्टोग्राफी विभिन्न प्रकार के कई सिफर का उपयोग करने की प्रक्रिया है, जिसमें प्रत्येक साइफर के लाभ शामिल हैं। एक सामान्य दृष्टिकोण है जो आमतौर पर एक सममित सिफर के लिए एक यादृच्छिक गुप्त कुंजी उत्पन्न करने के लिए पीछा किया जाता है और फिर असममित कुंजी क्रिप्टोग्राफी के माध्यम से इस कुंजी को एन्क्रिप्ट किया जाता है।

इस पैटर्न के कारण, मूल संदेश स्वयं सममित सिफर का उपयोग करके और फिर गुप्त कुंजी का उपयोग करके एन्क्रिप्ट किया गया है। संदेश प्राप्त करने के बाद रिसीवर गुप्त कुंजी का उपयोग करते हुए संदेश को अपनी निजी कुंजी का उपयोग करके पहले संदेश को डिक्रिप्ट करने के लिए निर्दिष्ट कुंजी का उपयोग करता है।

पायथन एक ओपन सोर्स स्क्रिप्टिंग भाषा है जो उच्च-स्तरीय, व्याख्यात्मक, इंटरैक्टिव और ऑब्जेक्ट-ओरिएंटेड है। इसे अत्यधिक पठनीय बनाया गया है। पायथन भाषा का वाक्यविन्यास अंग्रेजी कीवर्ड को समझने और उपयोग करने में आसान है।

पायथन भाषा की विशेषताएं

पायथन निम्नलिखित प्रमुख विशेषताएं प्रदान करता है -

व्याख्या की

इंटरप्रेटर का उपयोग करके पायथन को रनटाइम पर संसाधित किया जाता है। निष्पादन से पहले किसी कार्यक्रम को संकलित करने की आवश्यकता नहीं है। यह PERL और PHP के समान है।

वस्तु के उन्मुख

पायथन ऑब्जेक्ट-ओरिएंटेड स्टाइल और डिज़ाइन पैटर्न का अनुसरण करता है। इसमें एन्कैप्सुलेशन और बहुरूपता जैसी विभिन्न विशेषताओं के साथ वर्ग परिभाषा शामिल है।

पायथन भाषा के प्रमुख बिंदु

पायथन प्रोग्रामिंग भाषा के प्रमुख बिंदु इस प्रकार हैं -

  • इसमें कार्यात्मक और संरचित प्रोग्रामिंग और विधियों के साथ-साथ ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग विधियां शामिल हैं।

  • इसका उपयोग स्क्रिप्टिंग भाषा के रूप में या प्रोग्रामिंग भाषा के रूप में किया जा सकता है।

  • इसमें स्वचालित कचरा संग्रह शामिल है।

  • इसमें उच्च-स्तरीय गतिशील डेटा प्रकार शामिल हैं और विभिन्न गतिशील प्रकार की जाँच का समर्थन करता है।

  • पायथन में C, C ++ और जावा जैसी भाषाओं के साथ एकीकरण की सुविधा शामिल है।

पायथन भाषा के लिए डाउनलोड लिंक निम्नानुसार है - www.python.org/downloads इसमें विंडोज, मैकओएस और लिनक्स वितरण जैसे विभिन्न ऑपरेटिंग सिस्टम के पैकेज शामिल हैं।

पायथन स्ट्रिंग्स

स्ट्रिंग्स की मूल घोषणा नीचे दी गई है -

str = 'Hello World!'

पायथन लिस्ट्स

अजगर की सूचियों को यौगिक डेटा प्रकारों के रूप में घोषित किया जा सकता है, जिन्हें कॉमा द्वारा अलग किया जाता है और वर्ग कोष्ठक ([]) के भीतर संलग्न किया जाता है।

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

पायथन टुपल्स

टपल एक गतिशील डेटा प्रकार का पायथन है जिसमें अल्पविराम द्वारा अलग किए गए मानों की संख्या होती है। टुपल्स कोष्ठक के साथ संलग्न हैं।

tinytuple = (123, 'john')

पायथन शब्दकोश

पायथन डिक्शनरी एक प्रकार की हैश टेबल है। एक शब्दकोश कुंजी लगभग किसी भी प्रकार का पायथन हो सकती है, जो आमतौर पर संख्या या तार होते हैं।

tinydict = {'name': 'omkar','code':6734, 'dept': 'sales'}

क्रिप्टोग्राफी पैकेज

पायथन में क्रिप्टोग्राफी नामक एक पैकेज शामिल है जो क्रिप्टोग्राफिक व्यंजनों और प्राइमेटिव प्रदान करता है। यह Python 2.7, Python 3.4+ और PyPy 5.3+ का समर्थन करता है। क्रिप्टोग्राफी पैकेज की मूल स्थापना निम्नलिखित कमांड के माध्यम से प्राप्त की जाती है -

pip install cryptography

आम क्रिप्टोग्राफ़िक एल्गोरिदम जैसे उच्च स्तरीय व्यंजनों और निम्न स्तर के इंटरफेस दोनों के साथ विभिन्न पैकेज हैं symmetric ciphers, message digests तथा key derivation functions.

इस ट्यूटोरियल के दौरान, हम क्रिप्टोग्राफिक एल्गोरिदम के कार्यान्वयन के लिए पायथन के विभिन्न पैकेजों का उपयोग करेंगे।

पिछले अध्याय ने आपको अपने स्थानीय कंप्यूटर पर पायथन की स्थापना का अवलोकन दिया। इस अध्याय में आप रिवर्स सिफर और इसके कोडिंग के बारे में विस्तार से जानेंगे।

रिवर्स सिफर का एल्गोरिदम

रिवर्स सिफर का एल्गोरिथ्म निम्नलिखित विशेषताएं रखता है -

  • रिवर्स सिफर साइफर टेक्स्ट के स्ट्रिंग को सिफर टेक्स्ट के रूप में बदलने के लिए पैटर्न का उपयोग करता है।

  • एन्क्रिप्शन और डिक्रिप्शन की प्रक्रिया समान है।

  • सिफर पाठ को डिक्रिप्ट करने के लिए, उपयोगकर्ता को सादे पाठ को प्राप्त करने के लिए सिफर पाठ को उल्टा करना होगा।

कमी

रिवर्स सिफर की बड़ी खामी यह है कि यह बहुत कमजोर है। एक हैकर मूल संदेश प्राप्त करने के लिए सिफर पाठ को आसानी से तोड़ सकता है। इसलिए, सुरक्षित संचार चैनल को बनाए रखने के लिए रिवर्स सिफर को अच्छा विकल्प नहीं माना जाता है,।

उदाहरण

एक उदाहरण पर विचार करें जहां कथन है This is program to explain reverse cipherरिवर्स सिफर एल्गोरिथ्म के साथ लागू किया जाना है। निम्न अजगर कोड आउटपुट प्राप्त करने के लिए एल्गोरिथ्म का उपयोग करता है।

message = 'This is program to explain reverse cipher.'
translated = '' #cipher text is stored in this variable
i = len(message) - 1

while i >= 0:
   translated = translated + message[i]
   i = i - 1
print(“The cipher text is : “, translated)

उत्पादन

आप उलटा पाठ देख सकते हैं, यह निम्न चित्र में दिखाए अनुसार आउटपुट है -

व्याख्या

  • सादा पाठ को चर संदेश में संग्रहीत किया जाता है और अनुवादित चर का उपयोग सिफर पाठ के निर्माण के लिए किया जाता है।

  • सादे पाठ की लंबाई का उपयोग करके गणना की जाती है for पाश और की मदद से index number। अक्षर सिफर पाठ चर में संग्रहीत हैंtranslated जो अंतिम पंक्ति में छपा है।

पिछले अध्याय में, हमने रिवर्स सिफर से निपटा है। इस अध्याय में सीज़र सिफर के बारे में विस्तार से बात की गई है।

सीज़र सिफर का एल्गोरिदम

सीज़र सिफर का एल्गोरिदम निम्नलिखित विशेषताएं रखता है -

  • सीज़र सिफर तकनीक एन्क्रिप्शन तकनीक की सरल और आसान विधि है।

  • यह प्रतिस्थापन सिफर का सरल प्रकार है।

  • सादे पाठ के प्रत्येक अक्षर को अक्षर के साथ कुछ निश्चित संख्या में अक्षरों के साथ बदल दिया जाता है।

निम्नलिखित चित्र में सीज़र सिफर एल्गोरिदम कार्यान्वयन के कार्य को दर्शाया गया है -

सीजर सिफर एल्गोरिदम का कार्यक्रम कार्यान्वयन निम्नानुसार है -

def encrypt(text,s):
result = ""
   # transverse the plain text
   for i in range(len(text)):
      char = text[i]
      # Encrypt uppercase characters in plain text
      
      if (char.isupper()):
         result += chr((ord(char) + s-65) % 26 + 65)
      # Encrypt lowercase characters in plain text
      else:
         result += chr((ord(char) + s - 97) % 26 + 97)
      return result
#check the above function
text = "CEASER CIPHER DEMO"
s = 4

print "Plain Text : " + text
print "Shift pattern : " + str(s)
print "Cipher: " + encrypt(text,s)

उत्पादन

आप सीज़र सिफर देख सकते हैं, जैसा कि निम्न चित्र में दिखाया गया है -

व्याख्या

सादा पाठ चरित्र एक समय में एक है।

  • दिए गए सादे पाठ में प्रत्येक वर्ण के लिए, पाठ की एन्क्रिप्शन और डिक्रिप्शन की प्रक्रिया के आधार पर नियम के अनुसार दिए गए चरित्र को रूपांतरित करें।

  • चरणों का पालन करने के बाद, एक नया स्ट्रिंग उत्पन्न होता है जिसे सिफर टेक्स्ट कहा जाता है।

सीज़र सिफर एल्गोरिथम की हैकिंग

विभिन्न संभावनाओं के साथ सिफर पाठ को हैक किया जा सकता है। ऐसी ही एक संभावना हैBrute Force Technique,जिसमें हर संभव डिक्रिप्शन कुंजी आज़माना शामिल है। यह तकनीक अधिक प्रयास की मांग नहीं करती है और हैकर के लिए अपेक्षाकृत सरल है।

सीजर सिफर एल्गोरिदम को हैक करने के लिए कार्यक्रम कार्यान्वयन निम्नानुसार है -

message = 'GIEWIVrGMTLIVrHIQS' #encrypted message
LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

for key in range(len(LETTERS)):
   translated = ''
   for symbol in message:
      if symbol in LETTERS:
         num = LETTERS.find(symbol)
         num = num - key
         if num < 0:
            num = num + len(LETTERS)
         translated = translated + LETTERS[num]
      else:
         translated = translated + symbol
print('Hacking key #%s: %s' % (key, translated))

पिछले उदाहरण में एन्क्रिप्टेड सिफर पाठ पर विचार करें। फिर, कुंजी के साथ संभव हैकिंग विधियों के साथ उत्पादन और जानवर बल हमले तकनीक का उपयोग इस प्रकार है -

अब तक, आपने रिवर्स सिफर और सीज़र सिफर एल्गोरिदम के बारे में सीखा है। अब, ROT13 एल्गोरिथ्म और इसके कार्यान्वयन पर चर्चा करते हैं।

ROT13 एल्गोरिथम की व्याख्या

ROT13 सिफर संक्षिप्त रूप को संदर्भित करता है Rotate by 13 places। यह सीज़र सिफर का एक विशेष मामला है जिसमें शिफ्ट हमेशा १३ होता है। प्रत्येक अक्षर संदेश को एन्क्रिप्ट या डिक्रिप्ट करने के लिए १३ स्थानों पर स्थानांतरित किया जाता है।

उदाहरण

निम्नलिखित आरेख ROT13 एल्गोरिथम प्रक्रिया को सचित्र रूप से समझाता है -

प्रोग्राम कोड

ROT13 एल्गोरिदम का कार्यक्रम कार्यान्वयन निम्नानुसार है -

from string import maketrans

rot13trans = maketrans('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz', 
   'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm')

# Function to translate plain text
def rot13(text):
   return text.translate(rot13trans)
def main():
   txt = "ROT13 Algorithm"
   print rot13(txt)
	
if __name__ == "__main__":
   main()

आप ROT13 आउटपुट को निम्न चित्र में दिखाए अनुसार देख सकते हैं -

कमी

ROT13 एल्गोरिथ्म 13 पारियों का उपयोग करता है। इसलिए, सिफर टेक्स्ट को डिक्रिप्ट करने के लिए पात्रों को रिवर्स तरीके से शिफ्ट करना बहुत आसान है।

ROT13 एल्गोरिथम का विश्लेषण

ROT13 सिफर एल्गोरिथ्म को सीज़र सिफर का विशेष मामला माना जाता है। यह एक बहुत ही सुरक्षित एल्गोरिथ्म नहीं है और आवृत्ति विश्लेषण के साथ या संभव 25 कुंजियों को आज़माकर आसानी से तोड़ा जा सकता है जबकि ROT13 को 13 स्थानों पर शिफ्ट करके तोड़ा जा सकता है। इसलिए, इसमें कोई व्यावहारिक उपयोग शामिल नहीं है।

ट्रांसपोज़िशन सिफर एक क्रिप्टोग्राफ़िक एल्गोरिथ्म है जहाँ प्लेनेट में अल्फाबेट्स के क्रम को सिफर टेक्स्ट बनाने के लिए फिर से व्यवस्थित किया जाता है। इस प्रक्रिया में, वास्तविक सादे पाठ अक्षर शामिल नहीं हैं।

उदाहरण

एक ट्रांसपोज़ेशन सिफर के लिए एक सरल उदाहरण है columnar transposition cipherसादे पाठ में प्रत्येक वर्ण क्षैतिज रूप से निर्दिष्ट वर्णमाला चौड़ाई के साथ लिखा गया है। सिफर को लंबवत लिखा जाता है, जो एक पूरी तरह से अलग सिफर टेक्स्ट बनाता है।

सादे पाठ पर विचार करें hello world, और हमें नीचे दिखाए अनुसार सरल स्तंभ ट्रांसपोज़िशन तकनीक लागू करें

सादे पाठ वर्ण क्षैतिज रूप से रखे गए हैं और सिफर पाठ को ऊर्ध्वाधर प्रारूप के साथ बनाया गया है : holewdlo lr. अब, रिसीवर को सिफर टेक्स्ट को प्लेन टेक्स्ट को डिक्रिप्ट करने के लिए उसी टेबल का उपयोग करना होगा।

कोड

निम्नलिखित कार्यक्रम कोड स्तंभ पारगमन तकनीक के बुनियादी कार्यान्वयन को प्रदर्शित करता है -

def split_len(seq, length):
   return [seq[i:i + length] for i in range(0, len(seq), length)]
def encode(key, plaintext):
   order = {
      int(val): num for num, val in enumerate(key)
   }
ciphertext = ''

for index in sorted(order.keys()):
   for part in split_len(plaintext, len(key)):
      try:ciphertext += part[order[index]]
         except IndexError:
            continue
   return ciphertext
print(encode('3214', 'HELLO'))

व्याख्या

  • फ़ंक्शन का उपयोग करना split_len(), हम सादे पाठ वर्णों को विभाजित कर सकते हैं, जिन्हें स्तंभ या पंक्ति प्रारूप में रखा जा सकता है।

  • encode विधि स्तंभों की संख्या निर्दिष्ट करने के साथ कुंजी पाठ बनाने में मदद करती है और प्रत्येक स्तंभ के माध्यम से वर्णों को पढ़कर सिफर पाठ को प्रिंट करती है।

उत्पादन

स्तंभ प्रत्यारोपण तकनीक के बुनियादी कार्यान्वयन के लिए प्रोग्राम कोड निम्नलिखित आउटपुट देता है -

Note- जब क्रिप्टोकरेंसी तकनीक का प्रदर्शन किया जाता है, तो क्रिप्टोकरंसीज ने क्रिप्टो सुरक्षा में एक महत्वपूर्ण सुधार देखा। उन्होंने यह भी नोट किया कि समान ट्रांसपोज़र सिफर का उपयोग करके सिफर टेक्स्ट को फिर से एन्क्रिप्ट करना बेहतर सुरक्षा बनाता है।

पिछले अध्याय में, हमने ट्रांसपोज़ेशन सिफर के बारे में सीखा है। इस अध्याय में, हम इसके एन्क्रिप्शन पर चर्चा करते हैं।

Pyperclip

का मुख्य उपयोग pyperclipपायथन प्रोग्रामिंग भाषा में प्लगइन क्लिपबोर्ड पर पाठ को कॉपी करने और चिपकाने के लिए क्रॉस प्लेटफॉर्म मॉड्यूल का प्रदर्शन करना है। आप अजगर को स्थापित कर सकते हैंpyperclip मॉड्यूल को कमांड का उपयोग करके दिखाया गया है

pip install pyperclip

यदि सिस्टम में आवश्यकता पहले से मौजूद है, तो आप निम्न आउटपुट देख सकते हैं -

कोड

ट्रांसपोज़ेशन सिफर को एन्क्रिप्ट करने के लिए पायथन कोड जिसमें मुख्य मॉड्यूल है, जैसा कि नीचे दिखाया गया है -

import pyperclip
def main():
   myMessage = 'Transposition Cipher'
   myKey = 10
   ciphertext = encryptMessage(myKey, myMessage)
   
   print("Cipher Text is")
   print(ciphertext + '|')
   pyperclip.copy(ciphertext)

def encryptMessage(key, message):
   ciphertext = [''] * key
   
   for col in range(key):
      position = col
      while position < len(message):
         ciphertext[col] += message[position]
			position += key
      return ''.join(ciphertext) #Cipher text
if __name__ == '__main__':
   main()

उत्पादन

जिसमें ट्रांसक्रिपशन सिफर को एन्क्रिप्ट करने का प्रोग्राम कोड है pyperclip मुख्य मॉड्यूल निम्नलिखित आउटपुट देता है -

व्याख्या

  • कार्यक्रम main() कॉल करता है encryptMessage() जिसमें वर्णों का उपयोग करने के लिए विभाजन की प्रक्रिया शामिल है len फ़ंक्शन और उन्हें एक स्तंभ प्रारूप में पुनरावृत्त करना।

  • मुख्य फ़ंक्शन को आरंभ में उचित आउटपुट प्राप्त करने के लिए शुरू किया जाता है।

इस अध्याय में, आप ट्रांसपोज़ेशन सिफर को डिक्रिप्ट करने की प्रक्रिया सीखेंगे।

कोड

ट्रांसपोज़ेशन सिफर को डिक्रिप्ट करने की बेहतर समझ के लिए निम्न कोड को देखें। संदेश के लिए सिफर पाठTransposition Cipher कुंजी के साथ 6 के रूप में लाया जाता है Toners raiCntisippoh.

import math, pyperclip
def main():
   myMessage= 'Toners raiCntisippoh'
   myKey = 6
   plaintext = decryptMessage(myKey, myMessage)
   
   print("The plain text is")
   print('Transposition Cipher')

def decryptMessage(key, message):
   numOfColumns = math.ceil(len(message) / key)
   numOfRows = key
   numOfShadedBoxes = (numOfColumns * numOfRows) - len(message)
   plaintext = float('') * numOfColumns
   col = 0
   row = 0
   
   for symbol in message:
      plaintext[col] += symbol
      col += 1
      if (col == numOfColumns) or (col == numOfColumns - 1 and row >= numOfRows - numOfShadedBoxes):
         col = 0 row += 1 return ''.join(plaintext)
if __name__ == '__main__':
   main()

व्याख्या

सिफर टेक्स्ट और उल्लिखित कुंजी दो मान हैं जिन्हें कॉलम स्वरूप में वर्णों को रखकर और उन्हें क्षैतिज रूप से पढ़कर रिवर्स तकनीक में सिफर टेक्स्ट को डिकोड या डिक्रिप्ट करने के लिए इनपुट मापदंडों के रूप में लिया जाता है।

आप पत्र को एक कॉलम प्रारूप में रख सकते हैं और बाद में संयुक्त या कोड के निम्नलिखित टुकड़े का उपयोग करके उन्हें एक साथ जोड़ सकते हैं -

for symbol in message:
   plaintext[col] += symbol
   col += 1
   
   if (col == numOfColumns) or (col == numOfColumns - 1 and row >= numOfRows - numOfShadedBoxes):
   col = 0
   row += 1
return ''.join(plaintext)

उत्पादन

ट्रांसपोज़ेशन सिफर को डिक्रिप्ट करने का प्रोग्राम कोड निम्न आउटपुट देता है -

पायथन में, संचार चैनल पर संचारित करने से पहले फ़ाइलों को एन्क्रिप्ट और डिक्रिप्ट करना संभव है। इसके लिए आपको प्लगइन का इस्तेमाल करना होगाPyCrypto। आप नीचे दिए गए कमांड का उपयोग करके इस प्लगइन को स्थापित कर सकते हैं।

pip install pycrypto

कोड

पासवर्ड रक्षक के साथ फ़ाइल को एन्क्रिप्ट करने का प्रोग्राम कोड नीचे उल्लिखित है -

# =================Other Configuration================
# Usages :
usage = "usage: %prog [options] "
# Version
Version="%prog 0.0.1"
# ====================================================
# Import Modules
import optparse, sys,os
from toolkit import processor as ps
def main():
   parser = optparse.OptionParser(usage = usage,version = Version)
   parser.add_option(
      '-i','--input',type = 'string',dest = 'inputfile',
      help = "File Input Path For Encryption", default = None)
   
   parser.add_option(
      '-o','--output',type = "string",dest = 'outputfile',
      help = "File Output Path For Saving Encrypter Cipher",default = ".")
	
   parser.add_option(
      '-p','--password',type = "string",dest = 'password',
      help = "Provide Password For Encrypting File",default = None)
	
   parser.add_option(
      '-p','--password',type = "string",dest = 'password',
      help = "Provide Password For Encrypting File",default = None)
	
   (options, args)= parser.parse_args()
	
   # Input Conditions Checkings
   if not options.inputfile or not os.path.isfile(options.inputfile):
      print " [Error] Please Specify Input File Path"
      exit(0)
   if not options.outputfile or not os.path.isdir(options.outputfile):
      print " [Error] Please Specify Output Path"
      exit(0)
   if not options.password:
      print " [Error] No Password Input"
      exit(0)
   inputfile = options.inputfile

   outputfile = os.path.join(
      options.outputfile,os.path.basename(options.inputfile).split('.')[0]+'.ssb')
   password = options.password
   base = os.path.basename(inputfile).split('.')[1]
   work = "E"

   ps.FileCipher(inputfile,outputfile,password,work)
   return

   if __name__ == '__main__':
   main()

आप पासवर्ड के साथ एन्क्रिप्शन प्रक्रिया को निष्पादित करने के लिए निम्न कमांड का उपयोग कर सकते हैं -

python pyfilecipher-encrypt.py -i file_path_for_encryption -o output_path -p password

उत्पादन

जब आप ऊपर दिए गए कोड को निष्पादित करते हैं तो आप निम्नलिखित आउटपुट देख सकते हैं -

व्याख्या

पासवर्ड एमडी 5 हैश एल्गोरिथ्म का उपयोग करके उत्पन्न किए जाते हैं और मानों को विंडोज सिस्टम में केवल सुरक्षित बैकअप फाइलों में संग्रहीत किया जाता है, जिसमें निम्न मान शामिल हैं -

इस अध्याय में, हम पायथन का उपयोग करके क्रिप्टोग्राफी में फ़ाइलों के डिक्रिप्शन पर चर्चा करते हैं। ध्यान दें कि डिक्रिप्शन प्रक्रिया के लिए, हम उसी प्रक्रिया का पालन करेंगे, लेकिन आउटपुट पथ को निर्दिष्ट करने के बजाय, हम इनपुट पथ या आवश्यक फ़ाइल पर ध्यान केंद्रित करेंगे जो एन्क्रिप्टेड है।

कोड

निम्नलिखित पायथन का उपयोग करके क्रिप्टोग्राफी में फ़ाइलों को डिक्रिप्ट करने के लिए एक नमूना कोड है -

#!/usr/bin/python
# ---------------- READ ME ---------------------------------------------
# This Script is Created Only For Practise And Educational Purpose Only
# This Script Is Created For http://bitforestinfo.blogspot.in
# This Script is Written By
#
#
##################################################
######## Please Don't Remove Author Name #########
############### Thanks ###########################
##################################################
#
#
# =================Other Configuration================
# Usages :
usage = "usage: %prog [options] "
# Version
Version="%prog 0.0.1"
# ====================================================
# Import Modules
import optparse, sys,os
from toolkit import processor as ps
def main():
   parser = optparse.OptionParser(usage = usage,version = Version)
   parser.add_option(
      '-i','--input',type = 'string',dest = 'inputfile',
      help = "File Input Path For Encryption", default = None)
   
   parser.add_option(
      '-o','--output',type = "string",dest = 'outputfile',
      help = "File Output Path For Saving Encrypter Cipher",default = ".")
   
   parser.add_option(
      '-p','--password',type = "string",dest = 'password',
      help = "Provide Password For Encrypting File",default = None)
      (options, args) =  parser.parse_args()
      # Input Conditions Checkings
      if not options.inputfile or not os.path.isfile(options.inputfile):
         print " [Error] Please Specify Input File Path"
         exit(0)
      if not options.outputfile or not os.path.isdir(options.outputfile):
         print " [Error] Please Specify Output Path"
         exit(0)
      if not options.password:
         print " [Error] No
         exit(0)
      inputfile = options.inputfile
      outputfile = options.outputfile
      password = options.password
      work = "D"
      ps.FileCipher(inputfile,outputfile,password,work)
      return
if __name__ == '__main__':
   main()

उपरोक्त कोड निष्पादित करने के लिए आप निम्न कमांड का उपयोग कर सकते हैं -

python pyfilecipher-decrypt.py -i encrypted_file_path -p password

उत्पादन

जब आप ऊपर दिखाए गए कमांड को निष्पादित करते हैं, तो आप निम्नलिखित कोड देख सकते हैं -

Note - आउटपुट एन्क्रिप्शन से पहले और डिक्रिप्शन के बाद हैश वैल्यू को निर्दिष्ट करता है, जो नोट करता है कि एक ही फाइल एन्क्रिप्टेड है और प्रक्रिया सफल रही।

बेस 64 एन्कोडिंग बाइनरी डेटा को टेक्स्ट फॉर्मेट में परिवर्तित करता है, जिसे संचार चैनल के माध्यम से पारित किया जाता है, जहां उपयोगकर्ता टेक्स्ट को सुरक्षित रूप से संभाल सकता है। बेस 64 को भी कहा जाता हैPrivacy enhanced Electronic mail (PEM) और मुख्य रूप से ईमेल एन्क्रिप्शन प्रक्रिया में उपयोग किया जाता है।

पायथन में एक मॉड्यूल शामिल है जिसे कहा जाता है BASE64 जिसमें नीचे दिए गए अनुसार दो प्राथमिक कार्य शामिल हैं -

  • base64.decode(input, output) - यह निर्दिष्ट इनपुट मान पैरामीटर को डीकोड करता है और डिकोड किए गए आउटपुट को ऑब्जेक्ट के रूप में संग्रहीत करता है।

  • Base64.encode(input, output) - यह निर्दिष्ट इनपुट मान पैरामीटर को एन्कोड करता है और डिकोड किए गए आउटपुट को ऑब्जेक्ट के रूप में संग्रहीत करता है।

एनकोडिंग के लिए कार्यक्रम

बेस 64 एनकोडिंग करने के लिए आप निम्नलिखित कोड का उपयोग कर सकते हैं -

import base64
encoded_data = base64.b64encode("Encode this text")

print("Encoded text with base 64 is")
print(encoded_data)

उत्पादन

बेस 64 एनकोडिंग के लिए कोड आपको निम्नलिखित आउटपुट देता है -

डिकोडिंग के लिए कार्यक्रम

आप बेस 64 डिकोडिंग करने के लिए निम्नलिखित कोड का उपयोग कर सकते हैं -

import base64
decoded_data = base64.b64decode("RW5jb2RlIHRoaXMgdGV4dA==")

print("decoded text is ")
print(decoded_data)

उत्पादन

बेस 64 डिकोडिंग के लिए कोड आपको निम्न आउटपुट देता है -

ASCII और base64 के बीच अंतर

जब आप डेटा एन्कोडिंग के लिए ASCII और base64 पर काम करते हैं तो आप निम्नलिखित अंतरों का निरीक्षण कर सकते हैं -

  • जब आप ASCII में पाठ को एनकोड करते हैं, तो आप एक टेक्स्ट स्ट्रिंग से शुरू करते हैं और इसे बाइट्स के अनुक्रम में परिवर्तित करते हैं।

  • जब आप बेस 64 में डेटा एनकोड करते हैं, तो आप बाइट्स के अनुक्रम से शुरू करते हैं और इसे टेक्स्ट स्ट्रिंग में परिवर्तित करते हैं।

कमी

बेस 64 एल्गोरिथ्म आमतौर पर डेटाबेस में पासवर्ड स्टोर करने के लिए उपयोग किया जाता है। मुख्य दोष यह है कि प्रत्येक डिकोड किए गए शब्द को किसी भी ऑनलाइन टूल के माध्यम से आसानी से एन्कोड किया जा सकता है और घुसपैठियों को आसानी से जानकारी मिल सकती है।

इस अध्याय में, आइए हम पायथन में कोडिंग के साथ-साथ XOR प्रक्रिया को समझते हैं।

कलन विधि

एन्क्रिप्शन और डिक्रिप्शन का XOR एल्गोरिथम सादे पाठ को ASCII बाइट्स में कनवर्ट करता है और इसे निर्दिष्ट बाइट में बदलने के लिए XOR प्रक्रिया का उपयोग करता है। यह अपने उपयोगकर्ताओं को निम्नलिखित लाभ प्रदान करता है -

  • तेजी से गणना
  • बाएँ और दाएँ पक्ष में कोई अंतर नहीं
  • समझने और विश्लेषण करने में आसान

कोड

XOR प्रक्रिया करने के लिए आप निम्नलिखित कोड का उपयोग कर सकते हैं -

def xor_crypt_string(data, key = 'awesomepassword', encode = False, decode = False):
   from itertools import izip, cycle
   import base64
   
   if decode:
      data = base64.decodestring(data)
   xored = ''.join(chr(ord(x) ^ ord(y)) for (x,y) in izip(data, cycle(key)))
   
   if encode:
      return base64.encodestring(xored).strip()
   return xored
secret_data = "XOR procedure"

print("The cipher text is")
print xor_crypt_string(secret_data, encode = True)
print("The plain text fetched")
print xor_crypt_string(xor_crypt_string(secret_data, encode = True), decode = True)

उत्पादन

XOR प्रक्रिया का कोड आपको निम्नलिखित आउटपुट देता है -

व्याख्या

  • कार्यक्रम xor_crypt_string() इनकॉड और डिकोड के मोड और स्ट्रिंग मान को निर्दिष्ट करने के लिए एक पैरामीटर शामिल है।

  • मूल कार्यों को आधार 64 मॉड्यूल के साथ लिया जाता है जो सादे पाठ / सिफर पाठ को एन्क्रिप्ट या डिक्रिप्ट करने के लिए XOR प्रक्रिया / संचालन का अनुसरण करता है।

Note - XOR एन्क्रिप्शन का उपयोग डेटा को एन्क्रिप्ट करने के लिए किया जाता है और यह ब्रूट-फोर्स विधि द्वारा क्रैक करना मुश्किल है, जो कि सही सिफर टेक्स्ट के साथ मैच करने के लिए रैंडम एन्क्रिप्टिंग कीज़ को जेनरेट करके है।

सीज़र सिफर तकनीक का उपयोग करते समय, प्रतीकों को एन्क्रिप्ट और डिक्रिप्ट करना में मूल्यों को जोड़ या घटाना की एक सरल बुनियादी प्रक्रिया के साथ संख्या में परिवर्तित करना शामिल है।

यदि गुणन का उपयोग सिफर पाठ में परिवर्तित करने के लिए किया जाता है, तो इसे ए कहा जाता है wrap-aroundपरिस्थिति। नीचे दिखाए गए अनुसार अक्षरों और संबंधित संख्याओं पर विचार करें -

संख्याओं का उपयोग गुणन प्रक्रिया के लिए किया जाएगा और संबंधित कुंजी है 7. इस तरह के परिदृश्य में इस्तेमाल किया जाने वाला मूल सूत्र एक गुणक सिफर उत्पन्न करने के लिए निम्नानुसार है -

(Alphabet Number * key)mod(total number of alphabets)

आउटपुट के माध्यम से प्राप्त संख्या ऊपर उल्लिखित तालिका में मैप की गई है और संबंधित पत्र को एन्क्रिप्ट किए गए पत्र के रूप में लिया गया है।

पायथन में एक गुणक सिफर का मूल मॉडुलेशन फ़ंक्शन निम्नानुसार है -

def unshift(key, ch):
   offset = ord(ch) - ASC_A
   return chr(((key[0] * (offset + key[1])) % WIDTH) + ASC_A)

Note- एक गुणक सिफर के साथ लाभ यह है कि यह 8,953,851 जैसी बहुत बड़ी कुंजी के साथ काम कर सकता है। नौ मिलियन कुंजी के बहुमत के माध्यम से एक कंप्यूटर को ब्रूट-फोर्स के लिए काफी लंबा समय लगेगा।

अफ्फिन सिफर मल्टीप्लायरेटिव सिफर और सीज़र सिफर एल्गोरिदम का संयोजन है। एफ़िन सिफर का मूल कार्यान्वयन नीचे दी गई छवि में दिखाया गया है -

इस अध्याय में, हम इसके अनुरूप वर्ग बनाकर एफाइन सिफर लागू करेंगे जिसमें एन्क्रिप्शन और डिक्रिप्शन के लिए दो बुनियादी कार्य शामिल हैं।

कोड

एफ़िन सिफर लागू करने के लिए आप निम्नलिखित कोड का उपयोग कर सकते हैं -

class Affine(object):
   DIE = 128
   KEY = (7, 3, 55)
   def __init__(self):
      pass
   def encryptChar(self, char):
      K1, K2, kI = self.KEY
      return chr((K1 * ord(char) + K2) % self.DIE)
		
   def encrypt(self, string):
      return "".join(map(self.encryptChar, string))
   
   def decryptChar(self, char):
      K1, K2, KI = self.KEY
      return chr(KI * (ord(char) - K2) % self.DIE)
   
   def decrypt(self, string):
      return "".join(map(self.decryptChar, string))
		affine = Affine()
print affine.encrypt('Affine Cipher')
print affine.decrypt('*18?FMT')

उत्पादन

जब आप एफ़िन सिफर लागू करते हैं तो आप निम्न आउटपुट देख सकते हैं -

आउटपुट सादे पाठ संदेश के लिए एन्क्रिप्टेड संदेश प्रदर्शित करता है Affine Cipher और इनपुट के रूप में भेजे गए संदेश के लिए डिक्रिप्टेड संदेश abcdefg.

इस अध्याय में, आप मोनोथैबेटिक सेफर के बारे में और पायथन का उपयोग करके इसकी हैकिंग के बारे में जानेंगे।

मोनोलफैबेटिक सिफर

संपूर्ण संदेश को एन्क्रिप्ट करने के लिए एक मोनोऑलफैबेटिक सिफर एक निश्चित प्रतिस्थापन का उपयोग करता है। JSON ऑब्जेक्ट्स के साथ पायथन डिक्शनरी का उपयोग करने वाला एक मोनोफैबेटिक सेफ़र यहाँ दिखाया गया है -

monoalpha_cipher = {
   'a': 'm',
   'b': 'n',
   'c': 'b',
   'd': 'v',
   'e': 'c',
   'f': 'x',
   'g': 'z',
   'h': 'a',
   'i': 's',
   'j': 'd',
   'k': 'f',
   'l': 'g',
   'm': 'h',
   'n': 'j',
   'o': 'k',
   'p': 'l',
   'q': 'p',
   'r': 'o',
   's': 'i',
   't': 'u',
   'u': 'y',
   'v': 't',
   'w': 'r',
   'x': 'e',
   'y': 'w',
   'z': 'q',
	' ': ' ',
}

इस शब्दकोश की मदद से, हम संबंधित अक्षरों के साथ अक्षरों को JSON ऑब्जेक्ट में मान के रूप में एन्क्रिप्ट कर सकते हैं। निम्नलिखित कार्यक्रम एक वर्ग प्रतिनिधित्व के रूप में एक मोनोलेफैबेटिक प्रोग्राम बनाता है जिसमें एन्क्रिप्शन और डिक्रिप्शन के सभी कार्य शामिल हैं।

from string import letters, digits
from random import shuffle

def random_monoalpha_cipher(pool = None):
   if pool is None:
      pool = letters + digits
   original_pool = list(pool)
   shuffled_pool = list(pool)
   shuffle(shuffled_pool)
   return dict(zip(original_pool, shuffled_pool))

def inverse_monoalpha_cipher(monoalpha_cipher):
   inverse_monoalpha = {}
   for key, value in monoalpha_cipher.iteritems():
      inverse_monoalpha[value] = key
   return inverse_monoalpha

def encrypt_with_monoalpha(message, monoalpha_cipher):
   encrypted_message = []
   for letter in message:
      encrypted_message.append(monoalpha_cipher.get(letter, letter))
   return ''.join(encrypted_message)

def decrypt_with_monoalpha(encrypted_message, monoalpha_cipher):
   return encrypt_with_monoalpha(
      encrypted_message,
      inverse_monoalpha_cipher(monoalpha_cipher)
   )

इस फाइल को बाद में मोनोलेफैबेटिक सिफर की एन्क्रिप्शन और डिक्रिप्शन प्रक्रिया को लागू करने के लिए कहा जाता है जिसे नीचे वर्णित किया गया है -

import monoalphabeticCipher as mc

cipher = mc.random_monoalpha_cipher()
print(cipher)
encrypted = mc.encrypt_with_monoalpha('Hello all you hackers out there!', cipher)
decrypted = mc.decrypt_with_monoalpha('sXGGt SGG Nt0 HSrLXFC t0U UHXFX!', cipher)

print(encrypted)
print(decrypted)

उत्पादन

जब आप ऊपर दिए गए कोड को लागू करते हैं तो आप निम्नलिखित आउटपुट देख सकते हैं -

इस प्रकार, आप एक निर्दिष्ट कुंजी मान जोड़ी के साथ एक मोनोफैबेटिक सिफर को हैक कर सकते हैं जो सिफर पाठ को वास्तविक सादे पाठ में क्रैक करता है।

सरल स्थानापन्न सिफर सबसे अधिक उपयोग किया जाने वाला सिफर है और इसमें प्रत्येक सिफर पाठ चरित्र के लिए हर सादे पाठ चरित्र को प्रतिस्थापित करने का एक एल्गोरिथ्म शामिल है। इस प्रक्रिया में, सीज़र सिफर एल्गोरिथ्म की तुलना में अल्फाबेट्स को जोड़ दिया जाता है।

उदाहरण

एक साधारण प्रतिस्थापन सिफर के लिए कीज़ में आमतौर पर 26 अक्षर होते हैं। एक उदाहरण कुंजी है -

plain alphabet : abcdefghijklmnopqrstuvwxyz
cipher alphabet: phqgiumeaylnofdxjkrcvstzwb

उपरोक्त कुंजी is− का उपयोग कर एक उदाहरण एन्क्रिप्शन

plaintext : defend the east wall of the castle
ciphertext: giuifg cei iprc tpnn du cei qprcni

निम्नलिखित कोड सरल प्रतिस्थापन सिफर को लागू करने के लिए एक कार्यक्रम दिखाता है -

import random, sys

LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def main():
   message = ''
   if len(sys.argv) > 1:
      with open(sys.argv[1], 'r') as f:
         message = f.read()
   else:
      message = raw_input("Enter your message: ")
   mode = raw_input("E for Encrypt, D for Decrypt: ")
   key = ''
   
   while checkKey(key) is False:
      key = raw_input("Enter 26 ALPHA key (leave blank for random key): ")
      if key == '':
         key = getRandomKey()
      if checkKey(key) is False:
		print('There is an error in the key or symbol set.')
   translated = translateMessage(message, key, mode)
   print('Using key: %s' % (key))
   
   if len(sys.argv) > 1:
      fileOut = 'enc.' + sys.argv[1]
      with open(fileOut, 'w') as f:
         f.write(translated)
      print('Success! File written to: %s' % (fileOut))
   else: print('Result: ' + translated)

# Store the key into list, sort it, convert back, compare to alphabet.
def checkKey(key):
   keyString = ''.join(sorted(list(key)))
   return keyString == LETTERS
def translateMessage(message, key, mode):
   translated = ''
   charsA = LETTERS
   charsB = key
   
   # If decrypt mode is detected, swap A and B
   if mode == 'D':
      charsA, charsB = charsB, charsA
   for symbol in message:
      if symbol.upper() in charsA:
         symIndex = charsA.find(symbol.upper())
         if symbol.isupper():
            translated += charsB[symIndex].upper()
         else:
            translated += charsB[symIndex].lower()
				else:
               translated += symbol
         return translated
def getRandomKey():
   randomList = list(LETTERS)
   random.shuffle(randomList)
   return ''.join(randomList)
if __name__ == '__main__':
   main()

उत्पादन

जब आप ऊपर दिए गए कोड को लागू करते हैं तो आप निम्नलिखित आउटपुट देख सकते हैं -

इस अध्याय में, हम विभिन्न तरीकों का उपयोग करके प्रतिस्थापन प्रतिस्थापन सिफर के परीक्षण पर ध्यान केंद्रित करेंगे, जो नीचे दिए गए अनुसार यादृच्छिक तारों को उत्पन्न करने में मदद करता है -

import random, string, substitution
def main():
   for i in range(1000):
      key = substitution.getRandomKey()
      message = random_string()
      print('Test %s: String: "%s.."' % (i + 1, message[:50]))
      print("Key: " + key)
      encrypted = substitution.translateMessage(message, key, 'E')
      decrypted = substitution.translateMessage(encrypted, key, 'D')
      
      if decrypted != message:
         print('ERROR: Decrypted: "%s" Key: %s' % (decrypted, key))
         sys.exit()
      print('Substutition test passed!')

def random_string(size = 5000, chars = string.ascii_letters + string.digits):
   return ''.join(random.choice(chars) for _ in range(size))
if __name__ == '__main__':
   main()

उत्पादन

आप आउटपुट को यादृच्छिक रूप से उत्पन्न स्ट्रिंग्स के रूप में देख सकते हैं जो यादृच्छिक सादे पाठ संदेश बनाने में मदद करता है, जैसा कि नीचे दिखाया गया है -

परीक्षण सफलतापूर्वक पूरा होने के बाद, हम आउटपुट संदेश देख सकते हैं Substitution test passed!.

इस प्रकार, आप व्यवस्थित तरीके से एक प्रतिस्थापन सिफर को हैक कर सकते हैं।

इस अध्याय में, आप प्रतिस्थापन सिफर के सरल कार्यान्वयन के बारे में जान सकते हैं जो सरल प्रतिस्थापन प्रतिस्थापन सिफर तकनीक में प्रयुक्त तर्क के अनुसार एन्क्रिप्ट और डिक्रिप्ट किए गए संदेश को प्रदर्शित करता है। इसे कोडिंग के वैकल्पिक दृष्टिकोण के रूप में माना जा सकता है।

कोड

सरल प्रतिस्थापन प्रतिस्थापन सिफर का उपयोग कर डिक्रिप्शन करने के लिए आप निम्न कोड का उपयोग कर सकते हैं -

import random
chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + \
   'abcdefghijklmnopqrstuvwxyz' + \
   '0123456789' + \
   ':.;,?!@#$%&()+=-*/_<> []{}`~^"\'\\'

def generate_key():
   """Generate an key for our cipher"""
   shuffled = sorted(chars, key=lambda k: random.random())
   return dict(zip(chars, shuffled))

def encrypt(key, plaintext):
   """Encrypt the string and return the ciphertext"""
   return ''.join(key[l] for l in plaintext)

def decrypt(key, ciphertext):
   """Decrypt the string and return the plaintext"""
   flipped = {v: k for k, v in key.items()}
   return ''.join(flipped[l] for l in ciphertext)

def show_result(plaintext):
   """Generate a resulting cipher with elements shown"""
   key = generate_key()
   encrypted = encrypt(key, plaintext)
   decrypted = decrypt(key, encrypted)
   
   print 'Key: %s' % key
	print 'Plaintext: %s' % plaintext
   print 'Encrypted: %s' % encrypted
   print 'Decrypted: %s' % decrypted
show_result('Hello World. This is demo of substitution cipher')

उत्पादन

उपरोक्त कोड आपको यहाँ दिखाए अनुसार आउटपुट देता है -

इस अध्याय में, आप पायथन में क्रिप्टोग्राफी के विभिन्न मॉड्यूल के बारे में विस्तार से जानेंगे।

क्रिप्टोग्राफी मॉड्यूल

इसमें सभी व्यंजनों और आदिम शामिल हैं, और पायथन में कोडिंग का एक उच्च स्तरीय इंटरफ़ेस प्रदान करता है। आप निम्नलिखित आदेश का उपयोग करके क्रिप्टोग्राफी मॉड्यूल स्थापित कर सकते हैं -

pip install cryptography

कोड

क्रिप्टोग्राफी मॉड्यूल को लागू करने के लिए आप निम्नलिखित कोड का उपयोग कर सकते हैं -

from cryptography.fernet import Fernet
key = Fernet.generate_key()
cipher_suite = Fernet(key)
cipher_text = cipher_suite.encrypt("This example is used to demonstrate cryptography module")
plain_text = cipher_suite.decrypt(cipher_text)

उत्पादन

ऊपर दिया गया कोड निम्नलिखित आउटपुट का उत्पादन करता है -

यहां दिए गए कोड का उपयोग पासवर्ड को सत्यापित करने और उसके हैश बनाने के लिए किया जाता है। इसमें प्रमाणीकरण उद्देश्य के लिए पासवर्ड को सत्यापित करने के लिए तर्क भी शामिल है।

import uuid
import hashlib

def hash_password(password):
   # uuid is used to generate a random number of the specified password
   salt = uuid.uuid4().hex
   return hashlib.sha256(salt.encode() + password.encode()).hexdigest() + ':' + salt

def check_password(hashed_password, user_password):
   password, salt = hashed_password.split(':')
   return password == hashlib.sha256(salt.encode() + user_password.encode()).hexdigest()

new_pass = input('Please enter a password: ')
hashed_password = hash_password(new_pass)
print('The string to store in the db is: ' + hashed_password)
old_pass = input('Now please enter the password again to check: ')

if check_password(hashed_password, old_pass):
   print('You entered the right password')
else:
   print('Passwords do not match')

उत्पादन

Scenario 1 - यदि आपने एक सही पासवर्ड डाला है, तो आप निम्न आउटपुट पा सकते हैं -

Scenario 2 - यदि हम गलत पासवर्ड दर्ज करते हैं, तो आप निम्न आउटपुट पा सकते हैं -

व्याख्या

Hashlibपैकेज का उपयोग डेटाबेस में पासवर्ड संग्रहीत करने के लिए किया जाता है। इस कार्यक्रम में,salt उपयोग किया जाता है जो हैश फ़ंक्शन को लागू करने से पहले पासवर्ड स्ट्रिंग में एक यादृच्छिक अनुक्रम जोड़ता है।

Vignere Cipher में एन्क्रिप्शन और डिक्रिप्शन के लिए उपयोग किए जाने वाले सीज़र सिफर एल्गोरिदम के साथ एक मोड़ शामिल है। विग्नेयर सिफर केवल एक प्रमुख अंतर के साथ सीज़र सिफर एल्गोरिदम के समान काम करता है: सीज़र सिफर में एक-चरित्र बदलाव के लिए एल्गोरिथ्म शामिल है, जबकि विग्नर सिफर में कई अल्फाबेट शिफ्ट के साथ कुंजी शामिल है।

गणितीय समीकरण

एन्क्रिप्शन के लिए गणितीय समीकरण इस प्रकार है -

$ $ E_ {k} \ left (M {_ {i {}}} दाहिने) = \ बाएँ (M_ {i} + K_ {i} \ right) \; \? \; mod \; \; 26 $$

डिक्रिप्शन के लिए गणितीय समीकरण निम्नानुसार है -

$ $ डी_ {के} \ लेफ्ट (सी {_ {आई {}} \ राइट) = \ लेफ्ट (सी_ {आई} -के_ {आई} \ राइट) \; \; \; mod \; \; 26 $$

विग्नियर सिफर प्रतिस्थापन के एक से अधिक सेट का उपयोग करता है, और इसलिए इसे भी कहा जाता है polyalphabetic cipher। विग्नियर सिफर एक संख्यात्मक कुंजी प्रतिनिधित्व के बजाय एक पत्र कुंजी का उपयोग करेगा: पत्र ए का उपयोग कुंजी 0 के लिए, पत्र बी के लिए कुंजी 1 और इतने पर किया जाएगा। एन्क्रिप्शन प्रक्रिया के पहले और बाद के अक्षरों की संख्या नीचे दिखाई गई है -

Vignere कुंजी लंबाई के आधार पर संभावित कुंजी की संख्या का संभावित संयोजन निम्नानुसार दिया गया है, जो इस बात का परिणाम देता है कि Vignere Cipher Algorithm कितना सुरक्षित है -

विग्नेरे झांकी

Vignere सिफर के लिए इस्तेमाल की जाने वाली झांकी नीचे दी गई है -

इस अध्याय में, आइए समझते हैं कि विग्नियर सिफर को कैसे लागू किया जाए। पाठ पर विचार करेंThis is basic implementation of Vignere Cipher एन्कोड किया जाना है और उपयोग की जाने वाली कुंजी है PIZZA.

कोड

आप पायथन में एक विग्नियर सिफर को लागू करने के लिए निम्नलिखित कोड का उपयोग कर सकते हैं -

import pyperclip

LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def main():
   myMessage = "This is basic implementation of Vignere Cipher"
   myKey = 'PIZZA'
   myMode = 'encrypt'
   
   if myMode == 'encrypt':
      translated = encryptMessage(myKey, myMessage)
   elif myMode == 'decrypt':
      translated = decryptMessage(myKey, myMessage)
   
   print('%sed message:' % (myMode.title()))
   print(translated)
   print()
def encryptMessage(key, message):
   return translateMessage(key, message, 'encrypt')
def decryptMessage(key, message):
   return translateMessage(key, message, 'decrypt')
def translateMessage(key, message, mode):
   translated = [] # stores the encrypted/decrypted message string
   keyIndex = 0
   key = key.upper()
   
   for symbol in message:
      num = LETTERS.find(symbol.upper())
      if num != -1:
         if mode == 'encrypt':
            num += LETTERS.find(key[keyIndex])
				elif mode == 'decrypt':
               num -= LETTERS.find(key[keyIndex])
            num %= len(LETTERS)
            
            if symbol.isupper():
               translated.append(LETTERS[num])
            elif symbol.islower():
               translated.append(LETTERS[num].lower())
            keyIndex += 1
            
            if keyIndex == len(key):
               keyIndex = 0
         else:
            translated.append(symbol)
      return ''.join(translated)
if __name__ == '__main__':
   main()

उत्पादन

जब आप ऊपर दिए गए कोड को लागू करते हैं तो आप निम्नलिखित आउटपुट देख सकते हैं -

विग्नियर सिफर को हैक करने के संभावित संयोजन असंभव के बगल में हैं। इसलिए, इसे एक सुरक्षित एन्क्रिप्शन मोड माना जाता है।

एक बार का पैड सिफर एक प्रकार का विग्नियर सिफर है जिसमें निम्नलिखित विशेषताएं शामिल हैं -

  • यह एक अटूट सिफर है।

  • कुंजी संदेश की लंबाई के समान है जो एन्क्रिप्टेड है।

  • कुंजी यादृच्छिक प्रतीकों से बना है।

  • जैसा कि नाम से पता चलता है, कुंजी का उपयोग केवल एक बार किया जाता है और फिर कभी किसी अन्य संदेश को एन्क्रिप्ट करने के लिए उपयोग नहीं किया जाता है।

इसके कारण, एन्क्रिप्टेड संदेश क्रिप्टोकरंसी के लिए हमला करने के लिए असुरक्षित होगा। एक बार के पैड सिफर के लिए उपयोग की जाने वाली कुंजी को कहा जाता हैpad, क्योंकि यह कागज के पैड पर छपा होता है।

यह अटूट क्यों है?

निम्नलिखित विशेषताओं के कारण कुंजी अटूट है -

  • कुंजी दिए गए संदेश के समान है।

  • कुंजी वास्तव में यादृच्छिक और विशेष रूप से ऑटो-जेनरेट की गई है।

  • कुंजी और सादा पाठ की गणना मोडुलो 10/26/2 के रूप में की जाती है।

  • प्रत्येक कुंजी को एक बार उपयोग किया जाना चाहिए और प्रेषक और रिसीवर दोनों द्वारा नष्ट कर दिया जाना चाहिए।

  • कुंजी की दो प्रतियां होनी चाहिए: एक प्रेषक के साथ और दूसरी रिसीवर के साथ।

एन्क्रिप्शन

पत्र को एन्क्रिप्ट करने के लिए, उपयोगकर्ता को प्लेनटेक्स्ट के नीचे एक कुंजी लिखना होगा। प्लेनटेक्स्ट लेटर को सबसे ऊपर और की-लेटर को बाईं ओर रखा गया है। दो अक्षरों के बीच प्राप्त क्रॉस सेक्शन सादा पाठ है। यह नीचे दिए गए उदाहरण में वर्णित है -

डिक्रिप्शन

किसी पत्र को डिक्रिप्ट करने के लिए, उपयोगकर्ता बाईं ओर मुख्य अक्षर लेता है और उस पंक्ति में सिफर टेक्स्ट अक्षर पाता है। सादे पाठ पत्र को स्तंभ के शीर्ष पर रखा जाता है जहां उपयोगकर्ता सिफर पाठ पत्र पा सकता है।

अजगर के लिए एक हैकी कार्यान्वयन मॉड्यूल शामिल है one-time-padसिफर कार्यान्वयन। पैकेज नाम को वन-टाइम-पैड कहा जाता है जिसमें एक कमांड लाइन एन्क्रिप्शन टूल शामिल होता है जो एक-टाइम पैड सिफर एल्गोरिदम के समान एन्क्रिप्शन तंत्र का उपयोग करता है।

इंस्टालेशन

इस मॉड्यूल को स्थापित करने के लिए आप निम्न कमांड का उपयोग कर सकते हैं -

pip install onetimepad

यदि आप इसे कमांड-लाइन से उपयोग करना चाहते हैं, तो निम्न कमांड चलाएं -

onetimepad

कोड

निम्नलिखित कोड एक बार पैड सिफर उत्पन्न करने में मदद करता है -

import onetimepad

cipher = onetimepad.encrypt('One Time Cipher', 'random')
print("Cipher text is ")
print(cipher)
print("Plain text is ")
msg = onetimepad.decrypt(cipher, 'random')

print(msg)

उत्पादन

जब आप ऊपर दिए गए कोड को चलाते हैं तो आप निम्नलिखित आउटपुट देख सकते हैं -

Note - अगर संदेश की लंबाई (सादा पाठ) से कम है तो एन्क्रिप्टेड संदेश को क्रैक करना बहुत आसान है।

किसी भी मामले में, कुंजी आवश्यक रूप से यादृच्छिक नहीं है, जो एक उपकरण के रूप में एक बार पैड सिफर बनाता है।

इस अध्याय में, हम सममित और असममित क्रिप्टोग्राफी के बारे में विस्तार से चर्चा करते हैं।

सममित क्रिप्टोग्राफी

इस प्रकार में, एन्क्रिप्शन और डिक्रिप्शन प्रक्रिया एक ही कुंजी का उपयोग करती है। इसे भी कहा जाता हैsecret key cryptography। सममित क्रिप्टोग्राफी की मुख्य विशेषताएं इस प्रकार हैं -

  • यह सरल और तेज है।
  • दोनों पक्ष सुरक्षित तरीके से कुंजी का आदान-प्रदान करते हैं।

कमी

सममित क्रिप्टोग्राफी का प्रमुख दोष यह है कि यदि घुसपैठिया को कुंजी लीक होती है, तो संदेश आसानी से बदला जा सकता है और इसे जोखिम कारक माना जाता है।

डेटा एन्क्रिप्शन स्टैंडर्ड (DES)

सबसे लोकप्रिय सममित कुंजी एल्गोरिथ्म डेटा एन्क्रिप्शन स्टैंडर्ड (डीईएस) और पायथन में एक पैकेज शामिल है जिसमें डेस एल्गोरिथ्म के पीछे तर्क शामिल है।

इंस्टालेशन

डेस पैकेज की स्थापना के लिए कमांड pyDES पायथन में है -

pip install pyDES

डेस एल्गोरिथ्म का सरल कार्यक्रम कार्यान्वयन इस प्रकार है -

import pyDes

data = "DES Algorithm Implementation"
k = pyDes.des("DESCRYPT", pyDes.CBC, "\0\0\0\0\0\0\0\0", pad=None, padmode=pyDes.PAD_PKCS5)
d = k.encrypt(data)

print "Encrypted: %r" % d
print "Decrypted: %r" % k.decrypt(d)
assert k.decrypt(d) == data

यह चर के लिए कहता है padmode जो डेस एल्गोरिथ्म कार्यान्वयन के अनुसार सभी पैकेज प्राप्त करता है और एक निर्दिष्ट तरीके से एन्क्रिप्शन और डिक्रिप्शन का अनुसरण करता है।

उत्पादन

आप ऊपर दिए गए कोड के परिणामस्वरूप निम्न आउटपुट देख सकते हैं -

असममित क्रिप्टोग्राफी

इसे भी कहा जाता है public key cryptography.यह सममित क्रिप्टोग्राफी के रिवर्स तरीके से काम करता है। इसका मतलब यह है कि इसके लिए दो कुंजी की आवश्यकता है: एक एन्क्रिप्शन के लिए और दूसरी डिक्रिप्शन के लिए। सार्वजनिक कुंजी का उपयोग एन्क्रिप्ट करने के लिए किया जाता है और निजी कुंजी का उपयोग डिक्रिप्टिंग के लिए किया जाता है।

कमी

  • इसकी प्रमुख लंबाई के कारण, यह कम एन्क्रिप्शन गति में योगदान देता है।
  • कुंजी प्रबंधन महत्वपूर्ण है।

पायथन में निम्नलिखित प्रोग्राम कोड RSA एल्गोरिथ्म और इसके कार्यान्वयन का उपयोग करके असममित क्रिप्टोग्राफी के काम को दिखाता है -

from Crypto import Random
from Crypto.PublicKey import RSA
import base64

def generate_keys():
   # key length must be a multiple of 256 and >= 1024
   modulus_length = 256*4
   privatekey = RSA.generate(modulus_length, Random.new().read)
   publickey = privatekey.publickey()
   return privatekey, publickey

def encrypt_message(a_message , publickey):
   encrypted_msg = publickey.encrypt(a_message, 32)[0]
   encoded_encrypted_msg = base64.b64encode(encrypted_msg)
   return encoded_encrypted_msg

def decrypt_message(encoded_encrypted_msg, privatekey):
   decoded_encrypted_msg = base64.b64decode(encoded_encrypted_msg)
   decoded_decrypted_msg = privatekey.decrypt(decoded_encrypted_msg)
   return decoded_decrypted_msg

a_message = "This is the illustration of RSA algorithm of asymmetric cryptography"
privatekey , publickey = generate_keys()
encrypted_msg = encrypt_message(a_message , publickey)
decrypted_msg = decrypt_message(encrypted_msg, privatekey)

print "%s - (%d)" % (privatekey.exportKey() , len(privatekey.exportKey()))
print "%s - (%d)" % (publickey.exportKey() , len(publickey.exportKey()))
print " Original content: %s - (%d)" % (a_message, len(a_message))
print "Encrypted message: %s - (%d)" % (encrypted_msg, len(encrypted_msg))
print "Decrypted message: %s - (%d)" % (decrypted_msg, len(decrypted_msg))

उत्पादन

जब आप ऊपर दिए गए कोड को निष्पादित करते हैं तो आप निम्न आउटपुट पा सकते हैं -

RSA एल्गोरिथ्म एक सार्वजनिक कुंजी एन्क्रिप्शन तकनीक है और इसे एन्क्रिप्शन का सबसे सुरक्षित तरीका माना जाता है। इसका आविष्कार रिवेस्ट, शमीर और एडलमैन द्वारा वर्ष 1978 में किया गया था और इसलिए इसका नाम थाRSA कलन विधि।

कलन विधि

RSA एल्गोरिथ्म में निम्नलिखित विशेषताएं हैं -

  • आरएसए एल्गोरिथ्म प्राइम संख्याओं सहित पूर्णांकों पर एक परिमित क्षेत्र में एक लोकप्रिय घातांक है।

  • इस विधि द्वारा उपयोग किए जाने वाले पूर्णांक पर्याप्त रूप से बड़े होते हैं, जिन्हें हल करना मुश्किल होता है।

  • इस एल्गोरिथ्म में कुंजियों के दो सेट हैं: निजी कुंजी और सार्वजनिक कुंजी।

RSA एल्गोरिदम पर काम करने के लिए आपको निम्न चरणों से गुजरना होगा -

चरण 1: आरएसए मापांक उत्पन्न करें

प्रारंभिक प्रक्रिया दो प्रमुख संख्याओं के चयन से शुरू होती है, जैसे कि p और q, और फिर उनके उत्पाद N की गणना, जैसा कि दिखाया गया है -

N=p*q

यहां, N को निर्दिष्ट बड़ी संख्या बताएं।

चरण 2: व्युत्पन्न संख्या (ई)

एक व्युत्पन्न संख्या के रूप में संख्या ई पर विचार करें जो 1 से अधिक होनी चाहिए और (पी -1) और (क्यू -1) से कम होनी चाहिए। प्राथमिक शर्त यह होगी कि 1 को छोड़कर (पी -1) और (क्यू -1) का कोई सामान्य कारक नहीं होना चाहिए

चरण 3: सार्वजनिक कुंजी

संख्याओं की निर्दिष्ट जोड़ी n तथा e RSA सार्वजनिक कुंजी बनाता है और इसे सार्वजनिक किया जाता है।

चरण 4: निजी कुंजी

निजी चाबी dसंख्या पी, क्यू और ई से गणना की जाती है। संख्याओं के बीच गणितीय संबंध निम्नानुसार है -

ed = 1 mod (p-1) (q-1)

उपरोक्त सूत्र विस्तारित यूक्लिडियन एल्गोरिथ्म के लिए मूल सूत्र है, जो इनपुट मापदंडों के रूप में पी और क्यू लेता है।

एन्क्रिप्शन फॉर्मूला

एक प्रेषक पर विचार करें, जो किसी को सार्वजनिक पाठ के लिए सादा पाठ संदेश भेजता है (n,e). दिए गए परिदृश्य में सादे पाठ संदेश को एन्क्रिप्ट करने के लिए, निम्नलिखित सिंटैक्स का उपयोग करें -

C = Pe mod n

डिक्रिप्शन फॉर्मूला

डिक्रिप्शन प्रक्रिया बहुत सीधी है और इसमें एक व्यवस्थित दृष्टिकोण में गणना के लिए विश्लेषिकी शामिल है। रिसीवर को देखते हुए C निजी कुंजी है d, परिणाम मापांक की गणना इस प्रकार की जाएगी -

Plaintext = Cd mod n

इस अध्याय में, हम पायथन का उपयोग करके आरएसए एल्गोरिथ्म के चरणवार कार्यान्वयन पर ध्यान केंद्रित करेंगे।

RSA कुंजी बनाना

RSA कुंजियाँ बनाने में निम्नलिखित चरण शामिल हैं -

  • क्रमशः दो बड़ी अभाज्य संख्याएँ बनाएँ p तथा q। इन नंबरों के उत्पाद को कहा जाएगाn, कहाँ पे n= p*q

  • एक यादृच्छिक संख्या उत्पन्न करें जो अपेक्षाकृत प्रमुख है (p-1) तथा (q-1). संख्या के रूप में कहा जाता है e।

  • ई के मॉड्यूलर व्युत्क्रम की गणना करें। गणना की गई व्युत्क्रम को कहा जाएगाd।

RSA कुंजियाँ बनाने के लिए एल्गोरिदम

हमें Python का उपयोग करते हुए RSA कुंजी बनाने के लिए दो प्राथमिक एल्गोरिदम की आवश्यकता है - Cryptomath module तथा Rabin Miller module।

क्रिप्टोमैथ मॉड्यूल

क्रिप्टोमैथ मॉड्यूल का स्रोत कोड जो आरएसए एल्गोरिदम के सभी बुनियादी कार्यान्वयन निम्नानुसार है -

def gcd(a, b):
   while a != 0:
      a, b = b % a, a
   return b

def findModInverse(a, m):
   if gcd(a, m) != 1:
      return None
   u1, u2, u3 = 1, 0, a
   v1, v2, v3 = 0, 1, m
   
   while v3 != 0:
      q = u3 // v3
         v1, v2, v3, u1, u2, u3 = (u1 - q * v1), (u2 - q * v2), (u3 - q * v3), v1, v2, v3
   return u1 % m

राबिनमिलर मॉड्यूल

RabinMiller मॉड्यूल का स्रोत कोड जो RSA एल्गोरिथ्म के सभी बुनियादी कार्यान्वयन निम्नानुसार है -

import random
def rabinMiller(num):
   s = num - 1
   t = 0
   
   while s % 2 == 0:
      s = s // 2
      t += 1
   for trials in range(5):
      a = random.randrange(2, num - 1)
      v = pow(a, s, num)
      if v != 1:
         i = 0
         while v != (num - 1):
            if i == t - 1:
               return False
            else:
               i = i + 1
               v = (v ** 2) % num
      return True
def isPrime(num):
   if (num 7< 2):
      return False
   lowPrimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 
   67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 
   157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 
   251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,317, 331, 337, 347, 349, 
   353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 
   457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 
   571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 
   673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 
   797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 
   911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
	
   if num in lowPrimes:
      return True
   for prime in lowPrimes:
      if (num % prime == 0):
         return False
   return rabinMiller(num)
def generateLargePrime(keysize = 1024):
   while True:
      num = random.randrange(2**(keysize-1), 2**(keysize))
      if isPrime(num):
         return num

RSA कुंजियाँ बनाने का पूरा कोड इस प्रकार है -

import random, sys, os, rabinMiller, cryptomath

def main():
   makeKeyFiles('RSA_demo', 1024)

def generateKey(keySize):
   # Step 1: Create two prime numbers, p and q. Calculate n = p * q.
   print('Generating p prime...')
   p = rabinMiller.generateLargePrime(keySize)
   print('Generating q prime...')
   q = rabinMiller.generateLargePrime(keySize)
   n = p * q
	
   # Step 2: Create a number e that is relatively prime to (p-1)*(q-1).
   print('Generating e that is relatively prime to (p-1)*(q-1)...')
   while True:
      e = random.randrange(2 ** (keySize - 1), 2 ** (keySize))
      if cryptomath.gcd(e, (p - 1) * (q - 1)) == 1:
         break
   
   # Step 3: Calculate d, the mod inverse of e.
   print('Calculating d that is mod inverse of e...')
   d = cryptomath.findModInverse(e, (p - 1) * (q - 1))
   publicKey = (n, e)
   privateKey = (n, d)
   print('Public key:', publicKey)
   print('Private key:', privateKey)
   return (publicKey, privateKey)

def makeKeyFiles(name, keySize):
   # Creates two files 'x_pubkey.txt' and 'x_privkey.txt' 
      (where x is the value in name) with the the n,e and d,e integers written in them,
   # delimited by a comma.
   if os.path.exists('%s_pubkey.txt' % (name)) or os.path.exists('%s_privkey.txt' % (name)):
      sys.exit('WARNING: The file %s_pubkey.txt or %s_privkey.txt already exists! Use a different name or delete these files and re-run this program.' % (name, name))
   publicKey, privateKey = generateKey(keySize)
   print()
   print('The public key is a %s and a %s digit number.' % (len(str(publicKey[0])), len(str(publicKey[1])))) 
   print('Writing public key to file %s_pubkey.txt...' % (name))
   
   fo = open('%s_pubkey.txt' % (name), 'w')
	fo.write('%s,%s,%s' % (keySize, publicKey[0], publicKey[1]))
   fo.close()
   print()
   print('The private key is a %s and a %s digit number.' % (len(str(publicKey[0])), len(str(publicKey[1]))))
   print('Writing private key to file %s_privkey.txt...' % (name))
   
   fo = open('%s_privkey.txt' % (name), 'w')
   fo.write('%s,%s,%s' % (keySize, privateKey[0], privateKey[1]))
   fo.close()
# If makeRsaKeys.py is run (instead of imported as a module) call
# the main() function.
if __name__ == '__main__':
   main()

उत्पादन

सार्वजनिक कुंजी और निजी कुंजियाँ संबंधित फ़ाइलों में उत्पन्न और सहेजी जाती हैं जैसा कि निम्नलिखित आउटपुट में दिखाया गया है।

इस अध्याय में, हम आरएसए सिफर एन्क्रिप्शन के विभिन्न कार्यान्वयन और उसी के लिए शामिल कार्यों पर ध्यान केंद्रित करेंगे। आप आरएसए सिफर एल्गोरिथ्म कार्यान्वयन को लागू करने के लिए इस अजगर फ़ाइल को संदर्भित या शामिल कर सकते हैं।

एन्क्रिप्शन एल्गोरिथ्म के लिए शामिल मॉड्यूल निम्नानुसार हैं -

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA512, SHA384, SHA256, SHA, MD5
from Crypto import Random
from base64 import b64encode, b64decode
hash = "SHA-256"

हमने बेहतर सुरक्षा उद्देश्य के लिए SHA-256 के रूप में हैश मूल्य को इनिशियलाइज़ किया है। हम निम्नलिखित कोड का उपयोग करके नई कुंजी या सार्वजनिक और निजी कुंजी की एक जोड़ी बनाने के लिए एक फ़ंक्शन का उपयोग करेंगे।

def newkeys(keysize):
   random_generator = Random.new().read
   key = RSA.generate(keysize, random_generator)
   private, public = key, key.publickey()
   return public, private
def importKey(externKey):
   return RSA.importKey(externKey)

एन्क्रिप्शन के लिए, निम्न फ़ंक्शन का उपयोग किया जाता है जो RSA एल्गोरिदम का अनुसरण करता है -

def encrypt(message, pub_key):
   cipher = PKCS1_OAEP.new(pub_key)
   return cipher.encrypt(message)

दो पैरामीटर अनिवार्य हैं: message तथा pub_keyजो सार्वजनिक कुंजी को संदर्भित करता है। एन्क्रिप्शन के लिए एक सार्वजनिक कुंजी का उपयोग किया जाता है और डिक्रिप्शन के लिए निजी कुंजी का उपयोग किया जाता है।

एन्क्रिप्शन प्रक्रिया के लिए पूरा कार्यक्रम नीचे उल्लिखित है -

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA512, SHA384, SHA256, SHA, MD5
from Crypto import Random
from base64 import b64encode, b64decode
hash = "SHA-256"

def newkeys(keysize):
   random_generator = Random.new().read
   key = RSA.generate(keysize, random_generator)
   private, public = key, key.publickey()
   return public, private

def importKey(externKey):
   return RSA.importKey(externKey)

def getpublickey(priv_key):
   return priv_key.publickey()

def encrypt(message, pub_key):
   cipher = PKCS1_OAEP.new(pub_key)
   return cipher.encrypt(message)

यह अध्याय पिछले अध्याय की एक निरंतरता है जहां हमने RSA एल्गोरिथ्म का उपयोग करते हुए एन्क्रिप्शन के चरणवार कार्यान्वयन का पालन किया और इसके बारे में विस्तार से चर्चा की।

सिफर पाठ को डिक्रिप्ट करने के लिए उपयोग किया जाने वाला कार्य इस प्रकार है -

def decrypt(ciphertext, priv_key):
   cipher = PKCS1_OAEP.new(priv_key)
   return cipher.decrypt(ciphertext)

सार्वजनिक कुंजी क्रिप्टोग्राफ़ी या असममित कुंजी क्रिप्टोग्राफ़ी के लिए, दो महत्वपूर्ण विशेषताओं को बनाए रखना महत्वपूर्ण है Authentication तथा Authorization।

प्राधिकार

प्राधिकरण यह पुष्टि करने की प्रक्रिया है कि प्रेषक केवल वही है जिसने संदेश प्रसारित किया है। निम्नलिखित कोड यह बताते हैं -

def sign(message, priv_key, hashAlg="SHA-256"):
   global hash
   hash = hashAlg
   signer = PKCS1_v1_5.new(priv_key)
   
   if (hash == "SHA-512"):
      digest = SHA512.new()
   elif (hash == "SHA-384"):
      digest = SHA384.new()
   elif (hash == "SHA-256"):
      digest = SHA256.new()
   elif (hash == "SHA-1"):
      digest = SHA.new()
   else:
      digest = MD5.new()
   digest.update(message)
   return signer.sign(digest)

प्रमाणीकरण

सत्यापन विधि द्वारा प्रमाणीकरण संभव है जिसे नीचे समझाया गया है -

def verify(message, signature, pub_key):
   signer = PKCS1_v1_5.new(pub_key)
   if (hash == "SHA-512"):
      digest = SHA512.new()
   elif (hash == "SHA-384"):
      digest = SHA384.new()
   elif (hash == "SHA-256"):
      digest = SHA256.new()
   elif (hash == "SHA-1"):
      digest = SHA.new()
   else:
      digest = MD5.new()
   digest.update(message)
   return signer.verify(digest, signature)

डिजिटल हस्ताक्षर को प्रेषक और प्राप्तकर्ता के विवरण के साथ सत्यापित किया गया है। यह सुरक्षा उद्देश्यों के लिए अधिक वजन आयु जोड़ता है।

RSA सिफर डिक्रिप्शन

आप आरएसए सिफर डिक्रिप्शन के लिए निम्न कोड का उपयोग कर सकते हैं -

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA512, SHA384, SHA256, SHA, MD5
from Crypto import Random
from base64 import b64encode, b64decode
hash = "SHA-256"

def newkeys(keysize):
   random_generator = Random.new().read
   key = RSA.generate(keysize, random_generator)
   private, public = key, key.publickey()
   return public, private

def importKey(externKey):
   return RSA.importKey(externKey)

def getpublickey(priv_key):
   return priv_key.publickey()

def encrypt(message, pub_key):
   cipher = PKCS1_OAEP.new(pub_key)
   return cipher.encrypt(message)

def decrypt(ciphertext, priv_key):
   cipher = PKCS1_OAEP.new(priv_key)
   return cipher.decrypt(ciphertext)

def sign(message, priv_key, hashAlg = "SHA-256"):
   global hash
   hash = hashAlg
   signer = PKCS1_v1_5.new(priv_key)
   
   if (hash == "SHA-512"):
      digest = SHA512.new()
   elif (hash == "SHA-384"):
      digest = SHA384.new()
   elif (hash == "SHA-256"):
      digest = SHA256.new()
   elif (hash == "SHA-1"):
      digest = SHA.new()
   else:
      digest = MD5.new()
   digest.update(message)
   return signer.sign(digest)

def verify(message, signature, pub_key):
   signer = PKCS1_v1_5.new(pub_key)
   if (hash == "SHA-512"):
      digest = SHA512.new()
   elif (hash == "SHA-384"):
      digest = SHA384.new()
   elif (hash == "SHA-256"):
      digest = SHA256.new()
   elif (hash == "SHA-1"):
      digest = SHA.new()
   else:
      digest = MD5.new()
   digest.update(message)
   return signer.verify(digest, signature)

आरएसए सिफर को हैक करना छोटे प्राइम नंबरों के साथ संभव है, लेकिन इसे बड़ी संख्या के साथ उपयोग करने पर असंभव माना जाता है। जिन कारणों से यह निर्दिष्ट करना मुश्किल है कि आरएसए सिफर को हैक करना निम्न हैं -

  • ब्रूट बल का हमला काम नहीं करेगा क्योंकि इसके माध्यम से काम करने के लिए बहुत अधिक संभावनाएं हैं। इसके अलावा, यह बहुत समय लेता है।

  • RSA अल्गोरिद्म में डिक्शनरी अटैक काम नहीं करेगा क्योंकि कुंजियाँ संख्यात्मक हैं और इसमें कोई भी वर्ण शामिल नहीं है।

  • वर्णों का बार-बार विश्लेषण करना बहुत मुश्किल है क्योंकि एक ही एन्क्रिप्टेड ब्लॉक विभिन्न वर्णों का प्रतिनिधित्व करता है।

  • RSA साइफर को हैक करने के लिए कोई विशेष गणितीय ट्रिक्स नहीं हैं।

RSA डिक्रिप्शन समीकरण है -

M = C^d mod n

छोटे प्राइम नंबरों की मदद से, हम आरएसए सिफर को हैक करने की कोशिश कर सकते हैं और उसी के लिए नमूना कोड नीचे उल्लिखित है -

def p_and_q(n):
   data = []
   for i in range(2, n):
      if n % i == 0:
         data.append(i)
   return tuple(data)

def euler(p, q):
   return (p - 1) * (q - 1)

def private_index(e, euler_v):
   for i in range(2, euler_v):
      if i * e % euler_v == 1:
         return i

def decipher(d, n, c):
   return c ** d % n
	def main():
      e = int(input("input e: "))
      n = int(input("input n: "))
      c = int(input("input c: "))
      
      # t = 123
      # private key = (103, 143)
      p_and_q_v = p_and_q(n)
      # print("[p_and_q]: ", p_and_q_v)
      euler_v = euler(p_and_q_v[0], p_and_q_v[1])
      
      # print("[euler]: ", euler_v)
      d = private_index(e, euler_v)
      plain = decipher(d, n, c)
      print("plain: ", plain)
if __name__ == "__main__":
   main()

उत्पादन

उपरोक्त कोड निम्नलिखित आउटपुट का उत्पादन करता है -

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved