Python-Passwort-Hashing

1. Salt- und Hash-Passwort mit der bcrypt-Bibliothek in Python
2. Hashen Sie ein Passwort mit der hashlib-Bibliothek

Wir werden etwas über Passwort-Hashing lernen und wie man ein Salt- und Hash-Passwort mit einer Drittanbieter-Bibliothek namens bcrypt verschlüsselt. Wir betrachten auch verschiedene Hashing-Algorithmen aus der hashlib-Bibliothek in Python.

Salt- und Hash-Passwort mit der bcrypt-Bibliothek in Python

Beim Hashing wird eine Zeichenfolge genommen und in eine scheinbar zufällige Zeichenfolge mit fester Länge umgewandelt, und dieser Vorgang ist irreversibel. Es ist eine Einwegfunktion, sodass Sie den Hash nicht wie bei der Verschlüsselung auf seine ursprüngliche Zeichenfolge zurücksetzen können, bei der Sie eine Nachricht verschlüsseln und dann entschlüsseln können.

Hashing wird in der Benutzerverwaltung verwendet; Zum Beispiel, wenn wir eine Datenbankverletzung haben oder Daten verlieren oder jemand unser System hackt, wenn wir ein Klartext-Passwort verwenden. Hashing gibt uns eine gewisse Schutzschicht; Das gehashte Passwort kann jedoch nicht leicht geknackt werden, wenn wir es ordnungsgemäß pflegen.

In diesem Abschnitt werden wir sehen, wie man mit gehashten Passwörtern unter Verwendung des bcrypt-Moduls arbeitet; Lassen Sie uns weitermachen und in den Code springen. Wir werden eine Bibliothek eines Drittanbieters namens bcrypt verwenden, bei der es sich um einen Hash-Algorithmus handelt.

bcrypt ist ein zuverlässiger, robuster und empfohlener Algorithmus zum Hashen von Passwörtern; Es gibt uns einige nette und einfach zu bedienende Funktionen, mit denen wir Dinge schnell erledigen können.

Zuerst installieren wir diese Bibliothek mit dem folgenden Befehl.

pip install bcrypt

Jetzt müssen wir bcrypt importieren, ein Passwort erstellen und es in einer Variablen speichern, und das Passwort muss ein Byte-String sein. Um dieses Passwort zu hashen, erstellen wir eine neue Variable namens hashed_pswd und rufen die Methode hashpw() von bcrypt auf.

Es braucht zwei Argumente; Das erste ist ein Passwort, und das zweite ist etwas namens gensalt(), das zufällig eine Zahl oder ein Salt- und Hash-Passwort generiert.

import bcrypt

My_pswd = b"Mypassword111"

hashed_pswd = bcrypt.hashpw(My_pswd, bcrypt.gensalt())
print(hashed_pswd)

Ausgang:

b'$2b$12$KEW01pYNDc3ee9U0wZpmgOBpUvvjkig/qxs593hGh/aZ2AvvGTyWu'

Hashen Sie ein Passwort mit der hashlib-Bibliothek

In diesem Abschnitt wird die Bibliothek hashlib verwendet, um ein Salt- und Hash-Passwort zu erstellen. Wenn Sie sichere Daten wie Passwörter und andere Dinge von einem Ort zum anderen weitergeben, ist es eine gute Idee sicherzustellen, dass jemand sie nicht lesen kann.

Es gibt zwei Arten von Dingen, die Sie tun können, wenn Sie etwas verbergen oder für den Benutzer unlesbar machen möchten. Das erste ist Hashing und das zweite ist Verschlüsselung; Verschlüsselung wird in Passwörtern meistens nicht verwendet.

Wenn wir Dateien von unserem Computer auf einen anderen übertragen oder eine Datei versenden möchten, verwenden wir Verschlüsselung. Aber wenn wir überprüfen wollen, ob das Passwort korrekt ist oder nicht, oder um Passwörter auf unserem Server zu speichern, dann wird meistens Hashing verwendet.

Das Beste an der hashlib-Bibliothek ist, dass wir nichts installieren müssen; es kommt mit Python 3 oder einer neueren Version. Nach dem Import von hashlib erstellen wir ein Objekt namens MD5_Algo und rufen md5() aus hashlib auf.

md5 ist nur eine Art Hashing-Algorithmus, md steht für message-digest und 5 ist die Version. Jetzt brauchen wir den String, den wir wollen, um Klartext in Hashing umzuwandeln, und dafür rufen wir die Methode update() auf und schreiben den String, den wir hashen wollen.

Dann rufen wir innerhalb der Funktion print() die Methode hexdigest() auf; Nach der Umwandlung der Dehnung in das tatsächliche md5 wird es in eine Hex-Form umgewandelt.

import hashlib

MD5_Algo = hashlib.md5()
MD5_Algo.update("hello")
print(MD5_Algo.hexdigest())

Dieses Stück Code wirft einen Fehler (Unicode-Objekte müssen vor dem Hashing codiert werden), und im obigen Abschnitt haben wir bereits besprochen, dass wir eine Zeichenfolge in Bytes umwandeln müssen.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_4064/2416014515.py in <module>
      2
      3 MD5_Algo=hashlib.md5()
----> 4 MD5_Algo.update('hello')
      5 print(MD5_Algo.hexdigest())

TypeError: Unicode-objects must be encoded before hashing

Nachdem wir die Zeichenfolge in Bytes konvertiert haben, sehen wir, dass sie uns ein md5-verschlüsseltes gehashtes Passwort gibt.

import hashlib

MD5_Algo = hashlib.md5()
MD5_Algo.update(b"hello")
print(MD5_Algo.hexdigest())

Ausgang:

5d41402abc4b2a76b9719d911017c592

hashlib.sha512()

Es gibt auch andere Arten von verschlüsseltem Hash; Lassen Sie uns herausfinden, welche Art von Hashing-Zeug sich tatsächlich in Python befindet. Wir können verfügbare Algorithmen mit dem Attribut algorithms_available ausdrucken.

print(hashlib.algorithms_available)

Ausgang:

{'md4', 'md5', 'shake_256', 'shake_128', 'sha512_224', 'md5-sha1', 'sha224', 'sha3_512', 'sha1', 'sha3_384', 'sha512', 'sha3_224', 'sha512_256', 'sha384', 'sha256', 'blake2b', 'sha3_256', 'blake2s', 'ripemd160', 'whirlpool', 'sm3', 'mdc2'}

Wie wir sehen können, gibt es viele coole Algorithmen, und offensichtlich haben alle diese Objekte die gleiche Art von Struktur, sie haben die gleichen Funktionen und Variablen, aber es ist nur ein anderer Algorithmus.

sha512 ist derjenige, den wir verwenden und in einem String übergeben werden; Danach verwenden wir hexdigest() für diese Zeichenfolge, die gehasht wird.

import hashlib

MD5_Algo = hashlib.sha512(b"hello")
print(MD5_Algo.hexdigest())

Wenn wir diesen Code ausführen, erhalten wir eine lange Masse von Zeichen.

9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043

sha512 ist stärker und irgendwie besser als sha1; es hängt alles von dem Szenario ab, das Sie unter Ihren Umständen als besser oder am besten einschätzen.

Salzen und Haschen

Das Problem mit dieser Art von alten Algorithmen ist, dass sie Brute-Force oder Reverse-Engineering sein können, und es ist nicht so sicher, weil jeder diesen verschlüsselten Hash leicht entschlüsseln kann. Unser verschlüsselter Hash ist hello; Was ist, wenn wir einen Wörterbuchangriff durchführen und es aus dem sha512-Wörterbuch entschlüsseln?

Der Untergang von sha512 ist, dass viele Leute ihre Passwörter auf Facebook oder anderen Anwendungen verwenden; Normalerweise verwenden sie ihre Geburtstage, die bereits umgekehrt und in sha512 angesehen wurden, weshalb dies kein sicherer Weg ist.

Eine der sichersten Methoden ist das Salzen; Salting fügt etwas Charakter vor Ihrer ursprünglichen Zeichenfolge hinzu. Nehmen wir an, wenn wir "a" vor "hello" einfügen, haben wir das Zeichen "a" als Salz vor unserer ursprünglichen Zeichenfolge hinzugefügt.

hashlib.sha512(b"helloa")

Jetzt haben wir diesen Hash mit diesem zusätzlichen Salz verschlüsselt, weshalb es für Hacker und andere Leute, die versuchen, herauszufinden, wie sie den Hash entschlüsseln können, sehr schwierig sein wird, also kommt das Salz ins Spiel.

hashlib.pbkdf2_hmac()

In Python hat die hashlib-Bibliothek eine etwas langsame, aber ziemlich gute Funktion namens pbkdf2_hmac(). Wir werden diese Funktion verwenden und die zweite Bibliothek dient eigentlich zum Konvertieren der Binärzeichen in ASCII-Zeichen.

Das pbkdf2_hmac() benötigt einige Parameter; Der erste Parameter ist der Name des Algorithmus, den wir verwenden werden, also verwenden wir in diesem Fall sha512. Das nächste ist das Passwort oder der Text, den wir hashen möchten; in diesem Fall wird es "hello" sein.

Das nächste heißt Salt, das Salt wird zu diesem Passwort hinzugefügt und dann werden sie mit sha512 verschlüsselt. Und der letzte ist die Anzahl der Iterationen; Wenn wir diese Iteration hunderttausendmal durchführen, wird es sehr schwierig, sie zum Entschlüsseln zu finden.

In der letzten Codezeile wandeln wir den verschlüsselten Hash mit der Methode hexlify() aus der Bibliothek binascii in ein ASCII-Zeichen um.

import hashlib
import binascii

Enc_Salt = hashlib.pbkdf2_hmac("sha512", b"hello", b"a", 100000)
print(binascii.hexlify(Enc_Salt))

Ausgang:

b'40b5957a2d2f5aebcdd878a04e644215d4f3aba3f11c00a1f24e75f8ea2efa11611b2a923a9050832cb768a3a3ad282011cab524b741d392c664b8efbb5f389f'

Jetzt können wir sehen, dass das Wörterbuch sha512 nicht entschlüsselt werden kann.