python अजगर में पासवर्ड के साथ पाठ को कैसे एन्क्रिप्ट करना है?




encryption cryptography (4)

आश्चर्यजनक रूप से मुश्किल है कि Google को इसका सीधे उत्तर मिल जाए।

मैं 1PWP7a6xgoYx81VZocrDr5okEEcnqKkyDc जैसे उपयोगकर्ता से एक पाठ का एक टुकड़ा और एक संदेश इकट्ठा करना चाहता हूँ hello world

तब मैं किसी तरह पाठ से संदेश को एन्क्रिप्ट / डिक्रिप्ट करने में सक्षम होना चाहता हूं ताकि मैं इसे अपने डेटाबेस में सहेज encrypt('1PWP7a6xgoYx81VZocrDr5okEEcnqKkyDc', 'hello world') और अगर मेरी वेबसाइट काट दिया जाए तो encrypt('1PWP7a6xgoYx81VZocrDr5okEEcnqKkyDc', 'hello world') बारे में चिंता न करें। decrypt('1PWP7a6xgoYx81VZocrDr5okEEcnqKkyDc', <encrypted_text>)

क्या अजगर के साथ इसे प्राप्त करने का कोई आसान तरीका है और कृपया कोई मुझे एक उदाहरण प्रदान कर सकता / निर्देशित कर सकता है।

शायद एक उदाहरण का प्रयोग कैसे करें जैसे कि '1PWP7a6xgoYx81VZocrDr5okEEcnqKkyDc' जैसे बीज का उपयोग करके सार्वजनिक / निजी कुंजी जोड़े बनाने के लिए?

अग्रिम में बहुत धन्यवाद :)

संपादित करें: बस स्पष्ट होने के लिए मैं अपने उपयोगकर्ताओं के डेटा को एक स्थैतिक तरीके से एन्क्रिप्ट करने का एक तरीका खोज रहा हूं जो संदेश को अस्पष्ट नहीं करता।

अगर इसका मतलब है कि मुझे उड़ने पर पीजीपी / जीपीजी पब / प्री कुंजी जोड़ी को पाठ 1PWP7a6xgoYx81VZocrDr5okEEcnqKkyDc को एक बीज के रूप में प्रयोग करना है, तो यह ठीक है लेकिन यह करने की विधि क्या है?


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

>>> ord('a')
    97

>>> ord('b')
    98

फिर, आपके पास और्ड के व्युत्क्रम कार्य भी है :) (chr) और जैसा कि आप कल्पना कर सकते हैं कि यह पूरी तरह से काम करता है: इसमें एक यूनिकोड कोड इनपुट (पूर्णांक) के रूप में होता है और इसी यूनिकोड वर्ण (स्ट्रिंग) मिलता है:

>>> chr(97)
    'a'

>>> chr(98)
    'b'

तो आप कुछ मनमानी पूर्णांक जोड़कर या जोड़कर एक साधारण एनक्रिप्शन कर सकते हैं ... इस मामले में, संख्या 2:

नोट: बहुत बड़े मूल्यों को न कहने पर ध्यान न दें या आपको एक त्रुटि आईडी मिलेगी, उदाहरण के लिए, आप एक नकारात्मक नम्बर तक पहुंच सकते हैं।

def encrypt(message):
    newS=''
    for car in message:
        newS=newS+chr(ord(car)+2)
    return newS


print(encrypt('hello world'))

और एक परिणाम के रूप में हो रही है:

jgnnq"yqtnf

अब आप उसी फ़ंक्शन को कॉपी और अतीत कर सकते हैं और डिक्रिप्ट फ़ंक्शन बना सकते हैं। इस मामले में, यह आवश्यक है कि, 2:

def decrypt(message):
    newS=''
    for car in message:
        newS=newS+chr(ord(car)-2)
    return newS


print(decrypt('jgnnq"yqtnf'))

और परिणाम मूल संदेश फिर से होगा:

'hello world'

यह गैर प्रोग्रामर को संदेश एन्क्रिप्ट करने का एक शानदार तरीका होगा। हालांकि, कुछ प्रोग्रामिंग ज्ञान वाले कोई भी प्रोग्राम उस प्रोग्राम को लिख सकता है जो कि पूर्णांक में भिन्नता है जब तक कि हमने पाया कि हमने कोड को एन्क्रिप्ट करने के लिए यूनिकोड वर्णों में बस (2) जोड़ा है ...

इससे बचने के लिए, मैं दो और जटिल विकल्पों का प्रस्ताव दूंगा

1. सबसे पहले एक सरल है: इसमें वर्ण की स्थिति के आधार पर सीआर फ़ंक्शन के लिए एक अलग राशि के मूल्य को लागू करने में होता है (उदाहरण के लिए, प्रत्येक यूनिकोड कोड में 2 से जोड़ते समय यह स्ट्रिंग में एक भी स्थान पर रहती है और 3 जब एक अजीब स्थिति पर बैठता है)

2. दूसरा एक अधिकतम सुरक्षा उत्पन्न करेगा। यह प्रत्येक यूनिकोड कोड को एक संख्या के लिए जोड़ना या उसके आधार पर विभाजित करना होगा जो प्रत्येक वर्ण के लिए बेतरतीब ढंग से उत्पन्न होगा। यह संदेश को वापस डीक्रिप्ट करने के लिए मूल्यों की एक सरणी को संग्रहित करने की आवश्यकता होगी। सुनिश्चित करें कि, मूल्यों का यह सरणी तीसरे पक्षों के लिए उपलब्ध नहीं है।

1 के लिए यह संभव समाधान है।

def encryptHard(message):
newS=''
for i in range(len(message)):
  if i%2==0:
    newS=newS+chr(ord(message[i])+2)
  else:
    newS=newS+chr(ord(message[i])-3)
return newS


print(encryptHard('hello world'))

और इसका परिणाम होगा:

jbniqyltif

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

अंत में, आइए हम दूसरे और जटिल विकल्प का गहराई से विश्लेषण करें। इस एक के साथ हम यह कह सकते हैं कि निषेध लगभग निरर्थक होगा। यह विचार है कि हम एक यूनिकोड कोड को 0 या 255 के बीच मिश्रित एक यूनिकोड कोड से जोड़ते हैं या घटाते हैं (यह सीआरआर () समारोह की संख्या की सीमा होती है, इसलिए अन्य नंबरों के साथ खेलने की कोशिश न करें। निश्चित रूप से एक त्रुटि मिलती है)।

इस मामले में, मेरा प्रस्ताव भी संचालन (राशि या घटाना) को यादृच्छिक बनाता है, और यह कि वह अंतिम संख्या 0 हो (यानी हमें एक मूल पात्र मिलेगा)। अंत में, यह भी उन संख्याओं के साथ एक सूची देता है जिन्हें इसे घटा दिया गया है, आपको संदेश को दोबारा डिक्रिप्ट करने की आवश्यकता होगी।

संभावना है कि आप एक ही एन्क्रिप्टेड संदेश प्राप्त करते हैं, यदि आप दो बार कॉल करते हैं, तो यह फ़ंक्शन लम्बी n का एक ही संदेश का उपयोग कर 255 ^ n के करीब है ... तो चिंता मत करो (मैं कुछ हद तक कहता हूं, जैसा कि एल्गोरिदम निर्मित होता है, वास्तव में उत्पन्न होता है उदाहरण के लिए, निम्न अंत या उच्च अंत श्रृंखला के अधिक दोहराए जाने वाले मान, यदि इस अंतर में यूनिकोड कैरचर सेट (0 से 255 तक) में सबसे अधिक लगातार वर्ण केंद्रित नहीं होते हैं, जो कि मामला है। हालांकि, कार्यक्रम , यद्यपि पूर्ण नहीं है, त्रुटिपूर्ण ढंग से काम करता है और जानकारी की रक्षा करता है

import random as r
def encryptSuperHard(message):
  newS=''
  l_trans=[]
  for car in message:
    code=ord(car)
    add_subtract=r.choice([True,False])
    if add_subtract:
      transpose=r.randint(0,code-1)
      newS=newS+chr(code-transpose)
      l_trans=l_trans+[-transpose]
    else:
      transpose=r.randint(code+1,255)
      newS=newS+chr(code+transpose)
      l_trans=l_trans+[transpose]
  return newS, l_trans

print(encryptSuperHard('hello world'))

इस मामले में, मैंने यह यादृच्छिक एन्क्रिप्ट करने वाली स्क्रिप्ट को इस दो मान ट्यूपल को वापस कर दिया है, जहां पहला मान एन्क्रिप्ट किया गया संदेश है और दूसरा वाला मूल्य है जो एपरेन्स के क्रम में प्रत्येक अक्षर को "ट्रांसकॉज़ किया गया" है।

('A0ŤłY\x10řG;,à', [-39, -53, 248, 214, -22, -16,     226, -40, -55, -64, 124])

डिक्रिप्टिंग, इस मामले में एन्क्रिप्टेड संदेश और सूची लेने और निम्नानुसार आगे बढ़ने की आवश्यकता होगी:

def decryptSuperHard(encriptedS,l):
  newS=''
  for i in range(len(l)):
    newS=newS+chr(ord(encriptedS[i])-l[i])
  return newS

print(decryptSuperHard('A0ŤłY\x10řG;,à', [-39,-53,248,214,-22,-16,226,-40,-55,-64,124]))

और परिणाम यहां वापस चला जाता है:

नमस्ते दुनिया

print(deccryptSuperHard('A0ŤłY\x10řG;,à', [-39, -53, 248, 214, -22, -16,     226, -40, -55, -64, 124])

  1. यदि आप उपयोगकर्ताओं को अधिकृत करने के लिए निर्दिष्ट डाटाबेस का उपयोग करने जा रहे हैं, तो आपको 2 तरीके एन्क्रिप्शन एल्गोरिदम के बजाय उपयोगकर्ता के पासवर्ड के हैश या संदेश डायजेस्ट का उपयोग करना चाहिए, जो डीबी रिसाव के मामले में भी आपके डेटा का उपयोग करना कठिन बनाता है।
  2. आप डेटा को किसी बिंदु पर डिक्रिप्ट करने की आवश्यकता रखने के लिए ऊपर विधि का उपयोग नहीं कर सकते हैं, लेकिन फिर भी आप कुछ निश्चित कुंजी (जो सबसे खराब विधि है) का उपयोग करके उपयोगकर्ता पासवर्ड को एन्क्रिप्ट करने से अधिक सुरक्षित तरीके का उपयोग कर सकते हैं। OWASP की पासवर्ड संग्रहण धोखा शीट पर एक नज़र डालें

जैसा कि आपने लिखा है, "मैं संदेश को एन्क्रिप्ट / डिक्रिप्ट करने में सक्षम होना चाहता हूं", मैं ब्लॉफ़िश का इस्तेमाल करते हुए एन्क्र / डीक्रर के लिए एक साधारण अजगर स्रोत (2.7 के तहत परीक्षण किया गया) को जोड़ रहा हूं।

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
import os
from Crypto.Cipher import Blowfish     # pip install pycrypto

BS = 8
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS) 
unpad = lambda s : s[0:-ord(s[-1])]

def doEncrypt(phrase, key):
    c1  = Blowfish.new(key, Blowfish.MODE_ECB)
    return c1.encrypt(pad(phrase))

def doDecrypt(phrase, key):
    c1  = Blowfish.new(key, Blowfish.MODE_ECB)
    return unpad(c1.decrypt(phrase))

def testing123(phrase, key):
    encrypted = doEncrypt(phrase, key)
    decrypted = doDecrypt(encrypted, key)
    assert phrase == decrypted, "Blowfish ECB enc/dec verification failed"
    print ("Blowfish ECB enc/dec verified ok")
    print ('phrase/key(hex)/enc+dec: {}/{}/{}'.format(phrase, key.encode('hex'), decrypted))

if __name__== "__main__":
    phrase= 'Ala ma kota, a kot ma AIDS.'
    key= os.urandom(32)
    testing123(phrase, key)

पीकेसीएस # 7 पैडिंग सहित सीबीसी मोड में इसे ठीक से कैसे करना है, यहां बताया गया है:

import base64
from Crypto.Cipher import AES
from Crypto.Hash import SHA256
from Crypto import Random

def encrypt(key, source, encode=True):
    key = SHA256.new(key).digest()  # use SHA-256 over our key to get a proper-sized AES key
    IV = Random.new().read(AES.block_size)  # generate IV
    encryptor = AES.new(key, AES.MODE_CBC, IV)
    padding = AES.block_size - len(source) % AES.block_size  # calculate needed padding
    source += bytes([padding]) * padding  # Python 2.x: source += chr(padding) * padding
    data = IV + encryptor.encrypt(source)  # store the IV at the beginning and encrypt
    return base64.b64encode(data).decode("latin-1") if encode else data

def decrypt(key, source, decode=True):
    if decode:
        source = base64.b64decode(source.encode("latin-1"))
    key = SHA256.new(key).digest()  # use SHA-256 over our key to get a proper-sized AES key
    IV = source[:AES.block_size]  # extract the IV from the beginning
    decryptor = AES.new(key, AES.MODE_CBC, IV)
    data = decryptor.decrypt(source[AES.block_size:])  # decrypt
    padding = data[-1]  # pick the padding value from the end; Python 2.x: ord(data[-1])
    if data[-padding:] != bytes([padding]) * padding:  # Python 2.x: chr(padding) * padding
        raise ValueError("Invalid padding...")
    return data[:-padding]  # remove the padding

यह bytes डेटा के साथ काम करने के लिए तैयार है, इसलिए यदि आप स्ट्रिंग्स को एन्क्रिप्ट करना चाहते हैं या स्ट्रिंग पासवर्ड का उपयोग करना चाहते हैं तो सुनिश्चित करें कि आप उन तरीकों से गुजरने से पहले एक उचित कोडेक के साथ इनको encode() करते हैं। यदि आप encode पैरामीटर को True को छोड़ते हैं तो encrypt() आउटपुट बेस 64 एन्कोडेड स्ट्रिंग होंगे, और decrypt() स्रोत भी बेस 64 स्ट्रिंग होना चाहिए।

अब अगर आप इसका परीक्षण करते हैं:

my_password = b"secret_AES_key_string_to_encrypt/decrypt_with"
my_data = b"input_string_to_encrypt/decrypt"

print("key:  {}".format(my_password))
print("data: {}".format(my_data))
encrypted = encrypt(my_password, my_data)
print("\nenc:  {}".format(encrypted))
decrypted = decrypt(my_password, encrypted)
print("dec:  {}".format(decrypted))
print("\ndata match: {}".format(my_data == decrypted))
print("\nSecond round....")
encrypted = encrypt(my_password, my_data)
print("\nenc:  {}".format(encrypted))
decrypted = decrypt(my_password, encrypted)
print("dec:  {}".format(decrypted))
print("\ndata match: {}".format(my_data == decrypted))

आपका आउटपुट समान होगा:

key:  b'secret_AES_key_string_to_encrypt/decrypt_with'
data: b'input_string_to_encrypt/decrypt'

enc:  7roSO+P/4eYdyhCbZmraVfc305g5P8VhDBOUDGrXmHw8h5ISsS3aPTGfsTSqn9f5
dec:  b'input_string_to_encrypt/decrypt'

data match: True

Second round....

enc:  BQm8FeoPx1H+bztlZJYZH9foI+IKAorCXRsMjbiYQkqLWbGU3NU50OsR+L9Nuqm6
dec:  b'input_string_to_encrypt/decrypt'

data match: True

उसी कुंजी और एक ही डेटा को साबित करना हर बार अलग-अलग सिफरटेक्स्ट का उत्पादन करता है।

अब, यह ईसीबी से काफी बेहतर है ... लेकिन अगर आप इसका इस्तेमाल संचार के लिए कर रहे हैं - नहीं! यह स्पष्ट करने के लिए अधिक है कि यह कैसे निर्माण किया जाना चाहिए, वास्तव में उत्पादन वातावरण में उपयोग नहीं किया जा सकता है और खासकर संचार के लिए नहीं क्योंकि यह एक महत्वपूर्ण घटक गायब है - संदेश प्रमाणीकरण इसके साथ खेलने के लिए बेझिझक है, लेकिन आपको अपना क्रिप्टो रोल नहीं करना चाहिए, अच्छी तरह से सत्यापित प्रोटोकॉल हैं जो आपको सामान्य नुकसान से बचने में मदद करेंगे और आपको उन लोगों का उपयोग करना चाहिए।


यहां रुचि रखने वाले किसी के लिए यहां मेरा समाधान है:

from Crypto.Cipher import AES  # pip install pycrypto
import base64

def cypher_aes(secret_key, msg_text, encrypt=True):
    # an AES key must be either 16, 24, or 32 bytes long
    # in this case we make sure the key is 32 bytes long by adding padding and/or slicing if necessary
    remainder = len(secret_key) % 16
    modified_key = secret_key.ljust(len(secret_key) + (16 - remainder))[:32]
    print(modified_key)

    # input strings must be a multiple of 16 in length
    # we achieve this by adding padding if necessary
    remainder = len(msg_text) % 16
    modified_text = msg_text.ljust(len(msg_text) + (16 - remainder))
    print(modified_text)

    cipher = AES.new(modified_key, AES.MODE_ECB)  # use of ECB mode in enterprise environments is very much frowned upon

    if encrypt:
        return base64.b64encode(cipher.encrypt(modified_text)).strip()

    return cipher.decrypt(base64.b64decode(modified_text)).strip()


encrypted = cypher_aes(b'secret_AES_key_string_to_encrypt/decrypt_with', b'input_string_to_encrypt/decrypt', encrypt=True)
print(encrypted)
print()
print(cypher_aes(b'secret_AES_key_string_to_encrypt/decrypt_with', encrypted, encrypt=False))

परिणाम:

b'secret_AES_key_string_to_encrypt'
b'input_string_to_encrypt/decrypt '
b'+IFU4e4rFWEkUlOU6sd+y8JKyyRdRbPoT/FvDBCFeuY='

b'secret_AES_key_string_to_encrypt'
b'+IFU4e4rFWEkUlOU6sd+y8JKyyRdRbPoT/FvDBCFeuY=    '
b'input_string_to_encrypt/decrypt'




cryptography