Einfache Möglichkeit, einen String nach einem Passwort zu codieren?

Hat Python eine eingebaute, einfache Art der Codierung / Decodierung von Strings mit einem Passwort?

Etwas wie das:

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

So wird die Saite "John Doe" als 'sjkl28cn2sx0' verschlüsselt. Um die Original-String zu bekommen, würde ich diese Zeichenfolge mit dem Schlüssel 'mypass', was ein Passwort in meinem Quellcode ist, "entsperren". Ich möchte das so sein, wie ich ein Word-Dokument mit einem Passwort verschlüsseln / entschlüsseln kann.

Ich möchte diese verschlüsselten Zeichenfolgen als URL-Parameter verwenden. Mein Ziel ist Verschleierung, nicht starke Sicherheit; Nichts kritisch kritisiert wird. Ich weiß, ich könnte eine Datenbank-Tabelle verwenden, um Schlüssel und Werte zu speichern, aber ich versuche, minimalistisch zu sein.

14 Solutions collect form web for “Einfache Möglichkeit, einen String nach einem Passwort zu codieren?”

Angenommen, Sie sind nur auf der Suche nach einfachen Verschleierung, die Dinge aus dem sehr beiläufigen Beobachter zu verdecken, und Sie sind nicht auf der Suche nach Drittanbieter-Bibliotheken zu verwenden. Ich würde so etwas wie die Vigenere Chiffre empfehlen. Es ist einer der stärksten der einfachen alten Ziffern.

https://de.wikipedia.org/wiki/Vigenère_cipher

Es ist schnell und einfach zu implementieren. Etwas wie:

 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) 

Decode ist so ziemlich das gleiche, außer du subtrahierst den Schlüssel.

Es ist viel schwieriger zu brechen, wenn die Saiten, die du kodierst, kurz sind und / oder wenn es schwer ist, die Länge der verwendeten Passphrase zu erraten.

Wenn Sie nach etwas kryptografischem suchen, ist PyCrypto wahrscheinlich Ihre beste Wette, obwohl vorherige Antworten einige Details übersehen: EZB-Modus in PyCyrpto erfordert, dass Ihre Nachricht ein Vielfaches von 16 Zeichen lang ist. Also musst du auflegen. Wenn Sie sie auch als URL-Parameter verwenden base64.urlsafe_b64_encode() , verwenden Sie base64.urlsafe_b64_encode() und nicht den Standard. Dies ersetzt einige der Zeichen im base64 Alphabet mit URL-sicheren Zeichen (wie es der Name schon sagt).

Allerdings sollten Sie absolut sicher sein, dass diese sehr dünne Schicht der Verschleierung für Ihre Bedürfnisse genügt, bevor Sie diese verwenden. Der Wikipedia-Artikel, den ich verknüpft habe, liefert detaillierte Anweisungen für das Brechen der Chiffre, so dass jeder mit einer moderaten Menge an Entschlossenheit könnte leicht brechen.

Wie Sie ausdrücklich sagen, dass Sie Dunkelheit nicht Sicherheit wollen, werden wir vermeiden, Sie für die Schwäche von dem zu bereuen, was Sie vorschlagen 🙂

Also, mit 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() 

Wenn jemand einen Halt von Ihrer Datenbank und Ihrer Codebasis bekommt, können sie die verschlüsselten Daten entschlüsseln. Halten Sie Ihre Geheimschlüssel sicher!

Der "encoded_c", der in der Vigenere-Chiffre-Antwort von @ Smehmood erwähnt wird, sollte "key_c" sein.

Hier arbeiten Codier- / Decodierfunktionen.

 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) 

Wie bereits erwähnt, enthält die PyCrypto-Bibliothek eine Reihe von Ziffern. Die XOR-Chiffre kann verwendet werden, um die schmutzige Arbeit zu machen, wenn Sie es nicht selbst tun wollen:

 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)) 

Obwohl es nur minimale Sicherheit bietet, würde ich immer noch empfehlen, einen zufälligen aussehenden Schlüssel ohne Leerzeichen (wie XOR'ing ein ASCII [a-zA-Z] Zeichen mit einem Raum nur Flips den Fall).

Die Chiffre arbeitet wie folgt, ohne den Klartext aufzurufen:

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

Kredit zu https://stackoverflow.com/a/2490376/241294 für die base64 encode / decode Funktionen (Ich bin ein Python Newbie).

Hier ist eine Python 3 Version der Funktionen von @qneill 's Antwort :

 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) 

Die zusätzlichen Codier- / Decodierungen werden benötigt, da Python 3 Splits / Byte-Arrays in zwei verschiedene Konzepte aufgeteilt hat und ihre APIs aktualisiert hat, um das zu reflektieren.

Arbeiten codieren / decodieren Funktionen in python3 (angepasst sehr wenig von qneill Antwort):

 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) 

Hier ist eine Implementierung von URL Safe Verschlüsselung und Entschlüsselung mit AES (PyCrypto) und base64.

 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 

Ein einfacher Weg ist mit der Bibliothek, und PyCrypto ist die gute.

Das funktioniert aber die Passwortlänge sollte genau 8 . Das ist einfach und erfordert pyDes .

 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 

AUSGABE:

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

Externe Bibliotheken bieten Geheimschlüssel-Verschlüsselungsalgorithmen.

Zum Beispiel bietet das Cypher Modul in PyCrypto eine Auswahl vieler Verschlüsselungsalgorithmen:

  • 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 ist ein Python Wrapper für OpenSSL und bietet unter anderem eine vollfeste Allzweck-Kryptographie-Bibliothek. Inbegriffen sind symmetrische Ziffern (wie AES).

Wenn Sie eine sichere Verschlüsselung wünschen:

Für python 2, solltest du keyczar benutzen http://www.keyczar.org/

Für python 3, bis keyczar verfügbar ist, habe ich einfach-crypt http://pypi.python.org/pypi/simple-crypt geschrieben

Beide werden die Schlüsselverstärkung nutzen, die sie sicherer macht als die meisten anderen Antworten hier. Und da sie so einfach zu bedienen sind, können Sie sie auch nutzen, wenn die Sicherheit nicht kritisch ist …

Wenn Sie Passwörter verwenden, ist es am besten, es richtig zu machen (besonders wenn Sie mit Benutzerpasswörtern zu tun haben).

Was Sie tun möchten, ist "verschlüsseln" das Passwort, nicht verschlüsseln.

Sie haben zwei Möglichkeiten, wie Sie dies tun können, je nachdem, wer ist die Beifall die Verschlüsselung.

Wenn es eine vertrauenswürdige dritte Partei ist, verwenden Sie Public / Private Schlüsselverschlüsselung. RSA ist eine gute Wahl. Sie geben den öffentlichen Schlüssel zu Ihrer vertrauenswürdigen dritten Partei, und halten Sie den privaten Schlüssel sicher.

Wenn du die Verschlüsselung machst, und niemand hat Zugang zu deinem Code, dann ist die symmetrische Schlüsselverschlüsselung gut. Ich empfehle AES mit einem ausreichend starken Schlüssel (256bit).

Es gibt Bibliotheken für Python, die eines dieser Verschlüsselungsschemata machen.

Sie können 1/2 Ass Sicherheit, aber nicht. Es ist keine gute Idee. Je.

Sie können AES verwenden, um Ihre Zeichenfolge mit einem Passwort zu verschlüsseln. Obwohl du ein starkes Passwort wählen möchtest, kann man leicht nicht raten, was es ist (sorry ich kann mir nicht helfen.) Ich bin eine Möchtegern-Sicherheit weenie).

AES ist stark mit einer guten Schlüsselgröße, aber es ist auch einfach, mit PyCrypto zu verwenden.

Eine andere Implementierung von @qneill-Code, die die CRC-Prüfsumme der ursprünglichen Nachricht enthält, wird eine Ausnahme ausgelöst, wenn die Prüfung fehlschlägt:

 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 

Wenn du sicher sein willst, kannst du Fernet benutzen, das kryptographisch klingende Sie können ein statisches "Salz" verwenden, wenn Sie es nicht separat speichern möchten – Sie verlieren nur Wörterbuch und Regenbogenangriffsverhinderung. Ich wählte es, weil ich lange oder kurze Passwörter auswählen kann, was bei AES nicht so einfach ist.

 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 

Wenn das zu kompliziert ist, schlug jemand einfaches Verschlüsseln vor

 from simplecrypt import encrypt, decrypt ciphertext = encrypt('password', plaintext) plaintext = decrypt('password', ciphertext) 
  • Entschlüsseln Sie Chrome Linux BLOB verschlüsselte Cookies in Python
  • Python - GPG entschlüsselt funktioniert aber GNUPG nicht
  • Verwenden Sie RSA, um in JavaScript zu verschlüsseln und in Python3 zu entschlüsseln
  • Verschlüsseln von Passwörtern auf POST Django
  • Python gnupg.encrypt: keine Fehler, aber nicht verschlüsselnde Daten oder Dateien
  • Warum ist AES verschlüsselte Chiffre der gleichen Saite mit der gleichen Taste immer anders?
  • Python crypt in OSX
  • Entschlüsseln von Strings in Python, die mit MCRYPT_RIJNDAEL_256 in PHP verschlüsselt wurden
  • Wie benutzt man Bcrypt, um Passwörter in Django zu verschlüsseln
  • Wie kann ich in Python verschlüsseln und in Java entschlüsseln?
  • AES Python Verschlüsselung und Ruby Verschlüsselung - unterschiedliche Verhalten?
  • Python ist die beste Programmiersprache der Welt.