Sicheres Hashing mit Python Hashlib

In diesem Tutorial erfahren Sie, wie Sie mithilfe der integrierten Funktionen des Hashlib-Moduls von Python sichere Hashes erstellen.

Es kann hilfreich sein, die Bedeutung von Hashing zu verstehen und sichere Hashes programmgesteuert zu berechnen – auch wenn Sie nicht in der Anwendungssicherheit arbeiten. Aber warum?

Nun, wenn Sie an Python-Projekten arbeiten, werden Sie wahrscheinlich auf Fälle stoßen, in denen Sie Bedenken haben, Passwörter und andere vertrauliche Informationen in Datenbanken oder Quellcodedateien zu speichern. In solchen Fällen ist es sicherer, den Hash-Algorithmus auf vertrauliche Informationen anzuwenden und den Hash anstelle der Informationen zu speichern.

In diesem Leitfaden behandeln wir, was Hashing ist und wie es sich davon unterscheidet Verschlüsselung. Wir werden auch die Eigenschaften von sicheren Hash-Funktionen durchgehen. Dann verwenden wir gängige Hash-Algorithmen, um den Hash des Klartexts in Python zu berechnen. Dazu verwenden wir das eingebaute Hashlib-Modul.

Für all dies und mehr, fangen wir an!

What Is Hashing?

Der Hashing-Prozess nimmt eine Nachrichtenzeichenfolge auf und gibt eine Ausgabe mit fester Länge namens the aus Hash-. Das bedeutet, dass die Länge des Ausgabe-Hashs für einen bestimmten Hash-Algorithmus festgelegt ist – unabhängig von der Länge der Eingabe. Aber wie unterscheidet es sich von der Verschlüsselung?

Bei der Verschlüsselung wird die Nachricht oder der Klartext mit einem Verschlüsselungsalgorithmus verschlüsselt, der eine verschlüsselte Ausgabe liefert. Wir können dann den Entschlüsselungsalgorithmus für die verschlüsselte Ausgabe ausführen, um die Nachrichtenzeichenfolge zurückzuerhalten.

Hashing funktioniert jedoch anders. Wir haben gerade erfahren, dass der Prozess der Verschlüsselung ist invertierbar , dass Sie von der verschlüsselten Nachricht zur unverschlüsselten Nachricht und umgekehrt wechseln können.

Im Gegensatz zur Verschlüsselung ist Hashing nicht ein umkehrbarer Prozess, also wir kann keine gehen Sie vom Hash zur Eingabenachricht.

Eigenschaften von Hash-Funktionen

Lassen Sie uns schnell einige Eigenschaften durchgehen, die Hash-Funktionen erfüllen sollten:

• Deterministisch: Hash-Funktionen sind deterministisch. Bei einer Nachricht m ist der Hash von m immer gleich.
• Preimage Resistent: Wir haben dies bereits behandelt, als wir sagten, dass Hashing keine umkehrbare Operation ist. Die Preimage-Widerstandseigenschaft besagt, dass es unmöglich ist, die Nachricht zu finden m aus dem Ausgabehash.
• KollisionsfestHinweis: Es sollte schwierig (oder rechnerisch nicht durchführbar) sein, zwei verschiedene Nachrichtenzeichenfolgen zu finden m1 funktioniert m2 so dass der Hash von m1 ist gleich dem Hash von m2. Diese Eigenschaft wird aufgerufen Kollisionsfestigkeit.
• Zweites Urbild resistent: Dies bedeutet eine Nachricht erhalten m1 und den dazugehörigen Hash m2, ist es unmöglich, eine andere Nachricht zu finden m2 so dass hash(m1) = hash(m2).

Python’s hashlib Module

Python ist eingebaut Hashlib -Modul bietet Implementierungen mehrerer Hashing- und Message Digest-Algorithmen, einschließlich des SHA funktioniert MD5 Algorithmen.

Um die Konstruktoren und eingebauten Funktionen aus dem Python-Hashlib-Modul zu verwenden, können Sie es folgendermaßen in Ihre Arbeitsumgebung importieren:

import hashlib

Das Hashlib-Modul stellt die algorithms_available funktioniert algorithms_guaranteed Konstanten, die den Satz von Algorithmen bezeichnen, deren Implementierungen verfügbar sind bzw. auf einer Plattform garantiert sind.

Deswegen, algorithms_guaranteed ist eine Teilmenge von algorithms_available.

Starten Sie eine Python-REPL, importieren Sie die Hashlib und greifen Sie auf die algorithms_available funktioniert algorithms_guaranteed Konstanten:

>>> hashlib.algorithms_available

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

>>> hashlib.algorithms_guaranteed

# Output
{'md5', 'shake_256', 'sha3_256', 'shake_128', 'blake2b', 'sha3_224', 'sha3_384', 
'sha384', 'sha256', 'sha1', 'sha3_512', 'sha512', 'blake2s', 'sha224'}

Wir sehen das algorithms_guaranteed ist tatsächlich eine Teilmenge von algorithms_available

Create Hash Objects in Python

Als nächstes lernen wir, wie man Hash-Objekte in Python erstellt. Wir berechnen den SHA256-Hash einer Nachrichtenzeichenfolge mit den folgenden Methoden:

• Das Generikum new() Konstruktor 
• Algorithmusspezifische Konstruktoren

Verwenden des new()-Konstruktors

Lassen Sie uns die initialisieren message Zeichenfolge:

>>> message = "Geekflare is awesome!"

Um das Hash-Objekt zu instanziieren, können wir die verwenden new() Konstruktor und übergeben Sie den Namen des Algorithmus wie gezeigt:

>>> sha256_hash = hashlib.new("SHA256")

Wir können jetzt anrufen update() Methode auf dem Hash-Objekt mit der message Zeichenfolge als Argument:

>>> sha256_hash.update(message)

Andernfalls tritt ein Fehler auf, da Hash-Algorithmen nur mit Byte-Strings arbeiten können.

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Unicode-objects must be encoded before hashing

Um die codierte Zeichenfolge zu erhalten, können Sie die aufrufen encode() -Methode für die Methodenzeichenfolge und verwenden Sie sie dann in der update() Methodenaufruf. Danach können Sie die anrufen hexdigest() -Methode, um den sha256-Hash abzurufen, der der Nachrichtenzeichenfolge entspricht.

sha256_hash.update(message.encode())
sha256_hash.hexdigest()
# Output:'b360c77de704ad8f02af963d7da9b3bb4e0da6b81fceb4c1b36723e9d6d9de3d'

Anstatt die Nachrichtenzeichenfolge mit dem encode() -Methode können Sie sie auch als eine Zeichenfolge von Bytes definieren, indem Sie der Zeichenfolge das Präfix voranstellen b so:

message = b"Geekflare is awesome!"
sha256_hash.update(message)
sha256_hash.hexdigest()
# Output: 'b360c77de704ad8f02af963d7da9b3bb4e0da6b81fceb4c1b36723e9d6d9de3d'

Der erhaltene Hash ist derselbe wie der vorherige Hash, was die deterministische Natur von Hash-Funktionen bestätigt.

Außerdem eine kleine Änderung in der message Zeichenfolge sollte dazu führen, dass sich der Hash drastisch ändert (auch bekannt als „Avalanche-Effekt“).

Um dies zu überprüfen, ändern wir das 'a' in 'awesome' in 'A' und berechnen den Hash:

message = "Geekflare is Awesome!"
h1 = hashlib.new("SHA256")
h1.update(message.encode())
h1.hexdigest()
# Output: '3c67f334cc598912dc66464f77acb71d88cfd6c8cba8e64a7b749d093c1a53ab'

Wir sehen, dass sich der Hash vollständig ändert.

Verwenden des algorithmusspezifischen Konstruktors

Im vorherigen Beispiel haben wir das Generikum verwendet new() Konstruktor und übergeben Sie „SHA256“ als Namen des Algorithmus zum Erstellen des Hash-Objekts.

Stattdessen können wir auch die verwenden sha256() Konstruktor wie gezeigt:

sha256_hash = hashlib.sha256()
message= "Geekflare is awesome!"
sha256_hash.update(message.encode())
sha256_hash.hexdigest()
# Output: 'b360c77de704ad8f02af963d7da9b3bb4e0da6b81fceb4c1b36723e9d6d9de3d'

Der Ausgabe-Hash ist identisch mit dem Hash, den wir zuvor für die erhalten haben message Zeichenfolge „Geekflare ist großartig!“.

Exploring Attributes of Hash Objects

Die Hash-Objekte haben einige nützliche Attribute:

• Das digest_size Das Attribut gibt die Größe des Digest in Byte an. Beispielsweise gibt der SHA256-Algorithmus einen 256-Bit-Hash zurück, was 32 Bytes entspricht 
• Das block_size Das Attribut bezieht sich auf die im Hash-Algorithmus verwendete Blockgröße.
• Das name Das Attribut ist der Name des Algorithmus, den wir in verwenden können new() Konstrukteur. Das Nachschlagen des Werts dieses Attributs kann hilfreich sein, wenn die Hash-Objekte keine aussagekräftigen Namen haben.

Wir können diese Attribute für die überprüfen sha256_hash Objekt, das wir zuvor erstellt haben:

>>> sha256_hash.digest_size
32
>>> sha256_hash.block_size
64
>>> sha256_hash.name
'sha256'

Sehen wir uns als Nächstes einige interessante Hashing-Anwendungen mit Pythons hashlib-Modul an.

Practical Examples of Hashing

Überprüfung der Integrität von Software und Dateien

Als Entwickler laden wir ständig Softwarepakete herunter und installieren sie. Dies gilt unabhängig davon, ob Sie an der arbeiten Linux-Distribution oder auf einem Windows oder einem Mac.

Allerdings einige Spiegel für Softwarepakete möglicherweise nicht vertrauenswürdig. Sie finden den Hash (oder die Prüfsumme) neben dem Download-Link. Und Sie können die Integrität der heruntergeladenen Software überprüfen, indem Sie den Hash berechnen und mit dem offiziellen Hash vergleichen.

Dies kann auch auf Dateien auf Ihrem Computer angewendet werden. Selbst die kleinste Änderung des Dateiinhalts ändert den Hash drastisch. Sie können überprüfen, ob eine Datei geändert wurde, indem Sie den Hash überprüfen.

Hier ist ein einfaches Beispiel. Erstellen Sie eine Textdatei „my_file.txt“ im Arbeitsverzeichnis und fügen Sie ihr etwas Inhalt hinzu.

$ cat my_file.txt
This is a sample text file.
We are  going to compute the SHA256 hash of this text file and also
check if the file has been modified by
recomputing the hash.

Sie können die Datei dann im Lesebinärmodus öffnen ('rb'), lesen Sie den Inhalt der Datei ein und berechnen Sie den SHA256-Hash wie gezeigt:

>>> import hashlib
>>> with open("my_file.txt","rb") as file:
...     file_contents = file.read()
...     sha256_hash = hashlib.sha256()
...     sha256_hash.update(file_contents)
...     original_hash = sha256_hash.hexdigest()

Hier ist die Variable original_hash ist der Hash von „my_file.txt“ in seinem aktuellen Zustand.

>>> original_hash
# Output: '53bfd0551dc06c4515069d1f0dc715d002d451c8799add29f3e5b7328fda9f8f'

Ändern Sie nun die Datei ‚my_file.txt‘. Sie können den zusätzlichen führenden Leerraum vor dem Wort „going“ entfernen. 🙂

Berechnen Sie den Hash noch einmal und speichern Sie ihn in der computed_hash variabel.

>>> import hashlib
>>> with open("my_file.txt","rb") as file:
...     file_contents = file.read()
...     sha256_hash = hashlib.sha256()
...     sha256_hash.update(file_contents)
...     computed_hash = sha256_hash.hexdigest()

Sie können dann eine einfache hinzufügen Aussage behaupten das behauptet, wenn die computed_hash ist gleich dem original_hash.

>>> assert computed_hash == original_hash

Wenn die Datei geändert wird (was in diesem Fall zutrifft), sollten Sie einen AssertionError erhalten:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

Sie können Hashing verwenden, wenn Sie vertrauliche Informationen wie Passwörter in Datenbanken speichern. Sie können Hashing auch bei der Kennwortauthentifizierung verwenden, wenn Sie sich mit Datenbanken verbinden. Validieren Sie den Hash des eingegebenen Passworts mit dem Hash des richtigen Passworts.

Fazit

Ich hoffe, dieses Tutorial hat Ihnen dabei geholfen, sichere Hashes mit Python zu generieren. Hier sind die wichtigsten Erkenntnisse:

• Das hashlib-Modul von Python bietet gebrauchsfertige Implementierungen mehrerer Hash-Algorithmen. Sie können die Liste der auf Ihrer Plattform garantierten Algorithmen abrufen hashlib.algorithms_guaranteed.
• Um ein Hash-Objekt zu erstellen, können Sie das generische verwenden new() Konstruktor mit der Syntax: hashlib.new("algo-name"). Alternativ können Sie die Konstruktoren verwenden, die den spezifischen Hash-Algorithmen entsprechen, wie folgt: hashlib.sha256() für den SHA 256-Hash.
• Nachdem Sie die zu hashende Nachrichtenzeichenfolge und das Hash-Objekt initialisiert haben, können Sie die aufrufen update() -Methode für das Hash-Objekt, gefolgt von der hexdigest() Methode, um den Hash zu erhalten.
• Hashing kann sich als nützlich erweisen, wenn Sie die Integrität von Softwareartefakten und Dateien überprüfen, vertrauliche Informationen in Datenbanken speichern und vieles mehr.

Als nächstes lernen Sie, wie man a Random Password Generator bei Python.