दिलचस्प पोस्ट
नकल के साथ नुकीले सरणी असाइनमेंट सूचक को पॉइंटर्स कैसे सी में काम करते हैं? पोस्ट पैरामीटर हमेशा रिक्त है पर्यावरण चर तक पहुंचने में सी ++ इंडेंटेशन त्रुटि: unindent किसी भी बाहरी इंडेंटेशन स्तर से मेल नहीं खाता है मोबाइल डेटा को सक्रिय करने और अक्षम करने के बारे में नवीनतम अपडेट प्रोग्राम Android में संदर्भ मेनू रंगों को ओवरराइड करें दूरस्थ सर्वर में सॉफ्टवेअर्स स्थापित करते समय आवे-कमांड के साथ समस्याएं मैं यह कैसे सुनिश्चित कर सकता हूं कि पूर्णांक का विभाजन हमेशा गोल हो गया है? किसी वेब पेज से क्रोम एक्सटेंशन पर संदेश भेजना Java String.equals बनाम == जब मैं जेसनॉन को फ़ायरबेज से जावा ऑब्जेक्ट में बदल देता हूं, तो मुझे "टाइप करने के लिए बाउंस करने में असफल" क्यों मिलता है? कॉल में अल्मॉफर स्विफ्ट 3.0 अतिरिक्त तर्क क्या है "= नल" और "आईएस नल" स्ट्रक्चर घोषणा में बृहदान्त्र का क्या अर्थ है, जैसे: 1,: 7,: 16, या: 32?

एक पासवर्ड के अनुसार स्ट्रिंग को एन्कोड करने का आसान तरीका?

क्या पायथन में एक पासवर्ड का उपयोग करके एन्कोडिंग / डिकोडिंग स्ट्रिंग का एक अंतर्निहित, आसान तरीका है?

कुछ इस तरह:

>>> encode('John Doe', password = 'mypass') 'sjkl28cn2sx0' >>> decode('sjkl28cn2sx0', password = 'mypass') 'John Doe' 

इसलिए स्ट्रिंग "जॉन डो" को एन्क्रिप्ट किया गया है 'sjkl28cn2sx0' मूल स्ट्रिंग पाने के लिए, मैं उस स्ट्रिंग को 'अनलॉक' करूँगा जो 'माइओपास' कुंजी के साथ है, जो कि मेरे स्रोत कोड में एक पासवर्ड है मैं इसे एक पासवर्ड के साथ Word दस्तावेज़ को एन्क्रिप्ट / डिक्रिप्ट कर सकता हूं।

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

वेब के समाधान से एकत्रित समाधान "एक पासवर्ड के अनुसार स्ट्रिंग को एन्कोड करने का आसान तरीका?"

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

Vigenère सिफर

यह त्वरित और लागू करने में आसान है कुछ इस तरह:

 import base64 def encode(key, string): encoded_chars = [] for i in xrange(len(string)): key_c = key[i % len(key)] encoded_c = chr(ord(string[i]) + ord(key_c) % 256) encoded_chars.append(encoded_c) encoded_string = "".join(encoded_chars) return base64.urlsafe_b64encode(encoded_string) 

डिकोड बहुत ही वही है, सिवाय आपके कुंजी को घटाना

यदि आप एन्कोडिंग स्ट्रिंग कम हैं तो इसे तोड़ने के लिए बहुत मुश्किल है, और / या यदि इस्तेमाल किया पासफ़्रेज की लंबाई अनुमानित करना मुश्किल है

यदि आप कुछ क्रिप्टोग्राफिक की तलाश कर रहे हैं, तो शायद PyCrypto आपकी सबसे अच्छी शर्त है, हालांकि पिछले उत्तर में कुछ विवरण नजर आते हैं: ईसीबी मोड में PyCrypto को आपके संदेश की लंबाई 16 अक्षरों में से एक के बराबर होना चाहिए। तो, आपको पैड चाहिए। इसके अलावा, यदि आप उन्हें यूआरएल मापदंडों के रूप में उपयोग करना चाहते हैं, तो base64.urlsafe_b64_encode() प्रयोग करें, बजाय एक मानक। यह यूआरएल-सुरक्षित अक्षरों के साथ बेस 64 वर्णमाला में कुछ वर्णों को बदल देता है (जैसा कि इसका नाम सुझाता है)।

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

जैसा कि आप स्पष्ट रूप से कहते हैं कि आप चाहते हैं कि अस्पष्टता से सुरक्षा न हो, हम आपको जो सुझाव देते हैं, उसकी कमजोरी के लिए आपको तंग करने से बचना होगा 🙂

तो, PyCrypto का उपयोग कर:

 from Crypto.Cipher import AES import base64 msg_text = 'test some plain text here'.rjust(32) secret_key = '1234567890123456' # create new & store somewhere safe cipher = AES.new(secret_key,AES.MODE_ECB) # never use ECB in strong systems obviously encoded = base64.b64encode(cipher.encrypt(msg_text)) # ... decoded = cipher.decrypt(base64.b64decode(encoded)) print decoded.strip() 

अगर किसी को आपके डेटाबेस और आपके कोड आधार की पकड़ हो, तो वे एन्क्रिप्ट किए गए डेटा को डीकोड करने में सक्षम होंगे। अपने secret_key सुरक्षित रखें!

@ स्माहमुड के विगेंनेर सिफर उत्तर में उल्लिखित "एन्कोडेड सीक" को "कीका" होना चाहिए

यहाँ काम कर रहे हैं सांकेतिक शब्दों में बदलना / व्याख्यान कार्यों

 import base64 def encode(key, clear): enc = [] for i in range(len(clear)): key_c = key[i % len(key)] enc_c = chr((ord(clear[i]) + ord(key_c)) % 256) enc.append(enc_c) return base64.urlsafe_b64encode("".join(enc)) def decode(key, enc): dec = [] enc = base64.urlsafe_b64decode(enc) for i in range(len(enc)): key_c = key[i % len(key)] dec_c = chr((256 + ord(enc[i]) - ord(key_c)) % 256) dec.append(dec_c) return "".join(dec) 

यहां @ क्नील के उत्तर से फ़ंक्शन के एक पायथन 3 संस्करण है:

 import base64 def encode(key, clear): enc = [] for i in range(len(clear)): key_c = key[i % len(key)] enc_c = chr((ord(clear[i]) + ord(key_c)) % 256) enc.append(enc_c) return base64.urlsafe_b64encode("".join(enc).encode()).decode() def decode(key, enc): dec = [] enc = base64.urlsafe_b64decode(enc).decode() for i in range(len(enc)): key_c = key[i % len(key)] dec_c = chr((256 + ord(enc[i]) - ord(key_c)) % 256) dec.append(dec_c) return "".join(dec) 

अतिरिक्त सांकेतिक शब्दों में बदलना / डीकोड की आवश्यकता होती है क्योंकि पायथन 3 ने अलग-अलग अवधारणाओं में विभाजित तार / बाइट सरणियों को बांट दिया है, और उनके एपीआई को अद्यतन करने के लिए अद्यतन किया है ..

जैसा कि उल्लेख किया गया है PyCrypto पुस्तकालय में साइफर्स का एक सूट है XOR साइफर का इस्तेमाल गंदे काम करने के लिए किया जा सकता है अगर आप इसे स्वयं नहीं करना चाहते हैं:

 from Crypto.Cipher import XOR import base64 def encrypt(key, plaintext): cipher = XOR.new(key) return base64.b64encode(cipher.encrypt(plaintext)) def decrypt(key, ciphertext): cipher = XOR.new(key) return cipher.decrypt(base64.b64decode(ciphertext)) 

हालांकि यह केवल न्यूनतम सुरक्षा प्रदान करता है, फिर भी मैं किसी भी स्पेस वर्णों के बिना यादृच्छिक दिखने वाली कुंजी का उपयोग करने की सलाह देता हूं (जैसा कि एक एएससीआईआई [ए-जेडए-जेड] वर्ण के साथ अंतरिक्ष के साथ XOR'ing करना)।

साइफर काम करता है, बिना सादा पाठ पैड करने के लिए:

 >>> encrypt('notsosecretkey', 'Attack at dawn!') 'LxsAEgwYRQIGRRAKEhdP' >>> decrypt('notsosecretkey', encrypt('notsosecretkey', 'Attack at dawn!')) 'Attack at dawn!' 

Base64 encode / decode फ़ंक्शंस के लिए https://stackoverflow.com/a/2490376/241294 पर क्रेडिट (मैं एक अजगर नौसिखिया हूं)।

यहां एईएस (पायक्रिप्टो) और बेस 64 का उपयोग कर यूआरएल सेफ़ एन्क्रिप्शन और डिक्रिप्शन का कार्यान्वयन है।

 import base64 from Crypto import Random from Crypto.Cipher import AES AKEY = 'mysixteenbytekey' # AES key must be either 16, 24, or 32 bytes long iv = Random.new().read(AES.block_size) def encode(message): obj = AES.new(AKEY, AES.MODE_CFB, iv) return base64.urlsafe_b64encode(obj.encrypt(message)) def decode(cipher): obj2 = AES.new(AKEY, AES.MODE_CFB, iv) return obj2.decrypt(base64.urlsafe_b64decode(cipher)) In [13]: encode("Hello World") Out[13]: b'67jjg-8_RyaJ-28=' In [14]: %timeit encode("Hello World") 100000 loops, best of 3: 13.9 µs per loop In [15]: decode(b'67jjg-8_RyaJ-28=') Out[15]: b'Hello World' In [16]: %timeit decode(b'67jjg-8_RyaJ-28=') 100000 loops, best of 3: 15.2 µs per loop 

पायथन 3 में कार्यान्वित एन्कोड / डीकोड फ़ंक्शन (qneill के उत्तर से बहुत कम अनुकूलित):

 def encode(key, clear): enc = [] for i in range(len(clear)): key_c = key[i % len(key)] enc_c = (ord(clear[i]) + ord(key_c)) % 256 enc.append(enc_c) return base64.urlsafe_b64encode(bytes(enc)) def decode(key, enc): dec = [] enc = base64.urlsafe_b64decode(enc) for i in range(len(enc)): key_c = key[i % len(key)] dec_c = chr((256 + enc[i] - ord(key_c)) % 256) dec.append(dec_c) return "".join(dec) 

सरल तरीका पुस्तकालय का उपयोग कर रहा है, और PyCrypto अच्छा है

यह काम करता है लेकिन पासवर्ड की लंबाई बिल्कुल 8 होनी चाहिए। यह सरल है और पीयडी की आवश्यकता है

 from pyDes import * def encode(data,password): k = des(password, CBC, "\0\0\0\0\0\0\0\0", pad=None, padmode=PAD_PKCS5) d = k.encrypt(data) return d def decode(data,password): k = des(password, CBC, "\0\0\0\0\0\0\0\0", pad=None, padmode=PAD_PKCS5) d = k.decrypt(data) return d x = encode('John Doe', 'mypass12') y = decode(x,'mypass12') print x print y 

उत्पादन:

 ³.\Þ\åS¾+æÅ`;Ê John Doe 

बाहरी पुस्तकालय गुप्त-कुंजी एन्क्रिप्शन एल्गोरिदम प्रदान करते हैं।

उदाहरण के लिए, PyCrypto में Cypher मॉड्यूल कई एन्क्रिप्शन एल्गोरिदम का एक चयन प्रदान करता है:

  • Crypto.Cipher.AES
  • Crypto.Cipher.ARC2
  • Crypto.Cipher.ARC4
  • Crypto.Cipher.Blowfish
  • Crypto.Cipher.CAST
  • Crypto.Cipher.DES
  • Crypto.Cipher.DES3
  • Crypto.Cipher.IDEA
  • Crypto.Cipher.RC5
  • Crypto.Cipher.XOR

MeTooCrypto ओपनएसएसएल के लिए एक Python आवरण है, और (अन्य कार्यों के बीच) पूर्ण-ताकत सामान्य प्रयोजन क्रिप्टोग्राफी लाइब्रेरी प्रदान करता है सममित सिफर (जैसे एईएस) शामिल हैं

यदि आप सुरक्षित एन्क्रिप्शन चाहते हैं:

अजगर 2 के लिए, आपको केकजार http://www.keyczar.org/ का उपयोग करना चाहिए

अजगर 3 के लिए, जब तक किकेज़ार उपलब्ध न हो, मैंने लिखा है सरल-क्रिप्ट http://pypi.python.org/pypi/simple-crypt

ये दोनों महत्वपूर्ण सुदृढ़ीकरण का उपयोग करेंगे, जो यहां अधिकांश अन्य उत्तरों से उन्हें अधिक सुरक्षित बनाती हैं। और जब से वे उपयोग करने में इतना आसान हो जाते हैं, तब भी आप उनका उपयोग करना चाहेंगे, भले ही सुरक्षा गंभीर न हो …

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

 from cryptography.fernet import Fernet from cryptography.hazmat.backends import default_backend from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC import base64 #set password password = "mysecretpassword" #set message message = "secretmessage" kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt="staticsalt", iterations=100000, backend=default_backend()) key = base64.urlsafe_b64encode(kdf.derive(password)) f = Fernet(key) #encrypt encrypted = f.encrypt(message) print encrypted #decrypt decrypted = f.decrypt(encrypted) print decrypted 

अगर यह बहुत जटिल है, तो किसी ने सरलक्रिप्ट का सुझाव दिया

 from simplecrypt import encrypt, decrypt ciphertext = encrypt('password', plaintext) plaintext = decrypt('password', ciphertext) 

कुछ महान उत्तरों के लिए धन्यवाद जोड़ने के लिए कुछ भी मूल नहीं है, लेकिन यहां कुछ उपयोगी पायथन सुविधाओं का उपयोग करते हुए qneill के उत्तर के कुछ प्रगतिशील पुनरीलेख दिए गए हैं। मुझे आशा है कि आप सहमत हैं कि वे कोड को सरल और स्पष्ट करते हैं।

 import base64 def qneill_encode(key, clear): enc = [] for i in range(len(clear)): key_c = key[i % len(key)] enc_c = chr((ord(clear[i]) + ord(key_c)) % 256) enc.append(enc_c) return base64.urlsafe_b64encode("".join(enc)) def qneill_decode(key, enc): dec = [] enc = base64.urlsafe_b64decode(enc) for i in range(len(enc)): key_c = key[i % len(key)] dec_c = chr((256 + ord(enc[i]) - ord(key_c)) % 256) dec.append(dec_c) return "".join(dec) 

enumerate() – आइटम को उनके सूचकांक के साथ एक सूची में जोड़ दें

एक स्ट्रिंग में वर्णों पर पुनरावृत्त

 def encode_enumerate(key, clear): enc = [] for i, ch in enumerate(clear): key_c = key[i % len(key)] enc_c = chr((ord(ch) + ord(key_c)) % 256) enc.append(enc_c) return base64.urlsafe_b64encode("".join(enc)) def decode_enumerate(key, enc): dec = [] enc = base64.urlsafe_b64decode(enc) for i, ch in enumerate(enc): key_c = key[i % len(key)] dec_c = chr((256 + ord(ch) - ord(key_c)) % 256) dec.append(dec_c) return "".join(dec) 

एक सूची समझ का उपयोग कर सूची बनाएं

 def encode_comprehension(key, clear): enc = [chr((ord(clear_char) + ord(key[i % len(key)])) % 256) for i, clear_char in enumerate(clear)] return base64.urlsafe_b64encode("".join(enc)) def decode_comprehension(key, enc): enc = base64.urlsafe_b64decode(enc) dec = [chr((256 + ord(ch) - ord(key[i % len(key)])) % 256) for i, ch in enumerate(enc)] return "".join(dec) 

अक्सर अजगर में सूची इंडेक्स पर सभी की कोई ज़रूरत नहीं है। ज़िप और चक्र का उपयोग करके पूरी तरह से पाश सूचकांक चर को हटा दें:

 from itertools import cycle def encode_zip_cycle(key, clear): enc = [chr((ord(clear_char) + ord(key_char)) % 256) for clear_char, key_char in zip(clear, cycle(key))] return base64.urlsafe_b64encode("".join(enc)) def decode_zip_cycle(key, enc): enc = base64.urlsafe_b64decode(enc) dec = [chr((256 + ord(enc_char) - ord(key_char)) % 256) for enc_char, key_char in zip(enc, cycle(key))] return "".join(dec) 

और कुछ परीक्षण …

 msg = 'The quick brown fox jumps over the lazy dog.' key = 'jMG6JV3QdtRh3EhCHWUi' print('cleartext: {0}'.format(msg)) print('ciphertext: {0}'.format(encode_zip_cycle(key, msg))) encoders = [qneill_encode, encode_enumerate, encode_comprehension, encode_zip_cycle] decoders = [qneill_decode, decode_enumerate, decode_comprehension, decode_zip_cycle] # round-trip check for each pair of implementations matched_pairs = zip(encoders, decoders) assert all([decode(key, encode(key, msg)) == msg for encode, decode in matched_pairs]) print('Round-trips for encoder-decoder pairs: all tests passed') # round-trip applying each kind of decode to each kind of encode to prove equivalent from itertools import product all_combinations = product(encoders, decoders) assert all(decode(key, encode(key, msg)) == msg for encode, decode in all_combinations) print('Each encoder and decoder can be swapped with any other: all tests passed') >>> python crypt.py cleartext: The quick brown fox jumps over the lazy dog. ciphertext: vrWsVrvLnLTPlLTaorzWY67GzYnUwrSmvXaix8nmctybqoivqdHOic68rmQ= Round-trips for encoder-decoder pairs: all tests passed Each encoder and decoder can be swapped with any other: all tests passed 

यदि आप पासवर्ड का उपयोग कर रहे हैं, तो इसे सही करने के लिए सबसे अच्छा है (विशेषकर यदि आप उपयोगकर्ता पासवर्ड से काम कर रहे हैं)

आप क्या करना चाहते हैं "एन्क्रिप्ट" पासवर्ड है, एन्कोड नहीं।

एन्क्रिप्ट करने वाले लोगों के आधार पर आपके पास यह दो विकल्प हैं कि आप यह कैसे कर सकते हैं।

अगर इसकी एक विश्वसनीय तीसरी पार्टी, सार्वजनिक / निजी कुंजी एन्क्रिप्शन का उपयोग करें आरएसए एक अच्छा विकल्प है आप अपने विश्वस्त तीसरे पक्ष के लिए सार्वजनिक कुंजी देते हैं, और निजी कुंजी सुरक्षित रखें

यदि आप अपने आप को एन्क्रिप्ट कर रहे हैं, और किसी के पास आपके कोड तक पहुंच नहीं है, तो सममित कुंजी एन्क्रिप्शन अच्छा है। मैं एईएस को एक पर्याप्त मजबूत कुंजी (256 बिट) के साथ सुझाता हूं।

अजगर के लिए लाइब्रेरीज़ हैं जो इनमें से किसी भी एन्क्रिप्शन योजनाओं को करते हैं।

आप 1/2 गधा सुरक्षा कर सकते हैं, लेकिन नहीं। यह एक अच्छा विचार नहीं है कभी।

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

एईएस एक अच्छी कुंजी आकार के साथ मजबूत है, लेकिन यह भी PyCrypto के साथ प्रयोग करना आसान है।

@ क्नील कोड का एक अन्य कार्यान्वयन जिसमें मूल संदेश के सीआरसी चेकसम शामिल है, यह एक अपवाद फेंकता है अगर चेक असफल हो:

 import hashlib import struct import zlib def vigenere_encode(text, key): text = '{}{}'.format(text, struct.pack('i', zlib.crc32(text))) enc = [] for i in range(len(text)): key_c = key[i % len(key)] enc_c = chr((ord(text[i]) + ord(key_c)) % 256) enc.append(enc_c) return base64.urlsafe_b64encode("".join(enc)) def vigenere_decode(encoded_text, key): dec = [] encoded_text = base64.urlsafe_b64decode(encoded_text) for i in range(len(encoded_text)): key_c = key[i % len(key)] dec_c = chr((256 + ord(encoded_text[i]) - ord(key_c)) % 256) dec.append(dec_c) dec = "".join(dec) checksum = dec[-4:] dec = dec[:-4] assert zlib.crc32(dec) == struct.unpack('i', checksum)[0], 'Decode Checksum Error' return dec