Rake-Comb-Verschlüsselungsalgorithmus in Python: Typen und Anwendungsszenarien

Reversibler Verschlüsselungsalgorithmus (Symmetrische Verschlüsselung)

Der Verschlüsselungsalgorithmus ist eine Methode zur Umwandlung von Originaldaten in verschlüsselte Daten. Entsprechend den unterschiedlichen Eigenschaften von Verschlüsselungsalgorithmen können sie in reversible Verschlüsselungsalgorithmen und irreversible Verschlüsselungsalgorithmen unterteilt werden.

Der reversible Verschlüsselungsalgorithmus wird auch als symmetrischer Verschlüsselungsalgorithmus bezeichnet und seine Verschlüsselungs- und Entschlüsselungsprozesse verwenden denselben Schlüssel. Bei diesem Algorithmus können die verschlüsselten Daten durch den Entschlüsselungsalgorithmus auf die ursprünglichen Daten zurückgesetzt werden. Dieser Algorithmus wird häufig verwendet, um die Vertraulichkeit von Daten zu schützen, beispielsweise von Dateien, die auf der Festplatte eines Computers gespeichert sind, oder von Daten, die über ein Netzwerk übertragen werden.

Um es ganz klar auszudrücken: Die Daten werden während des Übertragungsprozesses verschlüsselt. Bei der tatsächlichen geschäftlichen Nutzung wird immer noch Klartext verwendet.

Verwenden Sie beispielsweise den AES-Verschlüsselungsalgorithmus zum Verschlüsseln von Dateien:

from Crypto.Cipher import AES  
import os  
# 生成一个16字节的密钥  
key = os.urandom(16)  
# 初始化加密算法  
cipher = AES.new(key, AES.MODE_EAX)  
# 读取要加密的文件  
with open('plaintext.txt', 'rb') as f:  
    plaintext = f.read()  
# 对文件进行加密  
ciphertext, tag = cipher.encrypt_and_digest(plaintext)  
# 将加密后的文件保存到磁盘上  
with open('ciphertext.txt', 'wb') as f:  
    f.write(cipher.nonce)  
    f.write(tag)  
    f.write(ciphertext)

oder verwenden Sie den DES-Algorithmus:

from Crypto.Cipher import DES  
# 生成一个8字节的密钥  
key = b'secretke'  
# 初始化加密算法  
cipher = DES.new(key, DES.MODE_ECB)  
# 要加密的字符串  
plaintext = b'Hello, World!'  
# 对字符串进行加密  
ciphertext = cipher.encrypt(plaintext)  
# 将加密后的字符串转换为十六进制格式并输出  
print(ciphertext.hex())

Im Bereich der Netzwerkübertragung wird im Allgemeinen die symmetrische Verschlüsselung im JWT-Token-Verschlüsselungsprozess verwendet:

class MyJwt:  
    def __init__(self):  
        # 密钥  
        self.secret = "1234"  
    # 加密方法(加入生命周期)  
    def encode_time(self,userinfo,lifetime=300):  
        # 单独声明载荷playload  
        playload = {  
            'exp':(datetime.datetime.now()+datetime.timedelta(seconds=lifetime)).timestamp(),  
            'data':userinfo  
        }  
        res = jwt.encode(playload,self.secret,algorithm='HS256')  
        return res  
    # 加密方法  
    async def encode(self,userinfo):  
        res = jwt.encode(userinfo,self.secret,algorithm='HS256')  
        return res  
    # 解密算法  
    async def decode(self,jwt_str):  
        res = jwt.decode(jwt_str,self.secret,algorithms=['HS256'])  
        return res

In der Praxis Anwendungen In diesem Fall müssen Sie den Verschlüsselungsalgorithmus und die Schlüssellänge auswählen, die für das jeweilige Szenario geeignet sind, und geeignete Sicherheitsmaßnahmen zum Schutz des Schlüssels ergreifen, da bei reversiblen Verschlüsselungsalgorithmen die Folgen katastrophal sind, sobald der geheime Schlüssel durchgesickert ist.

Irversibler Verschlüsselungsalgorithmus (Hash)

Die irreversible Verschlüsselung (auch Hash-Algorithmus genannt) wird normalerweise zum Verschlüsseln oder Überprüfen von Passwörtern oder Daten verwendet, um die Sicherheit von Passwörtern oder Daten zu gewährleisten. Im Vergleich zur symmetrischen oder asymmetrischen Verschlüsselung benötigt der Hash-Algorithmus keinen Schlüssel zum Ver- oder Entschlüsseln, ist also bequemer und effizienter, unterstützt jedoch keine Entschlüsselung. Sobald das verschlüsselte Ergebnis generiert wurde, können die Originaldaten nicht wiederhergestellt werden. und der irreversible Verschlüsselungsalgorithmus Das häufigste Anwendungsszenario besteht darin, das Klartextkennwort des Benutzers in Chiffretext zu verschlüsseln.

Verwenden Sie zum Beispiel den SHA-256-Hash-Algorithmus, um Daten zu verschlüsseln:

import hashlib  
# 加密数据  
message = b'hello world'  
hash_object = hashlib.sha256(message)  
encrypted_data = hash_object.hexdigest()  
print(encrypted_data)

Oder verwenden Sie den bcrypt-Algorithmus, um das Passwort zu verschlüsseln:

import bcrypt  
# 加密密码  
password = b'mysecretpassword'  
salt = bcrypt.gensalt()  
hashed_password = bcrypt.hashpw(password, salt)  
# 验证密码  
password_to_check = b'mysecretpassword'  
if bcrypt.checkpw(password_to_check, hashed_password):  
    print("Password is valid!")  
else:  
    print("Invalid password.")

Oder verwenden Sie den Scrypt-Algorithmus, um das Passwort zu verschlüsseln:

import scrypt  
# 加密密码  
password = b'mysecretpassword'  
salt = b'saltsaltsalt'  
encrypted_password = scrypt.hash(password, salt, N=16384, r=8, p=1)  
# 验证密码  
password_to_check = b'mysecretpassword'  
if scrypt.hash(password_to_check, salt, N=16384, r=8, p=1) == encrypted_password:  
    print("Password is valid!")  
else:  
    print("Invalid password.")

Die Prinzipien sind ähnlich, Beide sind Die Originaldaten werden auf der Grundlage des Hash-Algorithmus einem Chiffretext fester Länge zugeordnet. Da es sich bei der irreversiblen Verschlüsselung (Hash-Algorithmus) um eine Einwegverschlüsselungsmethode handelt, können die Originaldaten nicht durch Entschlüsselung wiederhergestellt werden, sodass der Hash mit Brute-Force-Methode geknackt wird Hash-Algorithmen versuchen normalerweise, die Originaldaten abzugleichen, indem sie eine große Anzahl von Möglichkeiten erschöpfend ausschöpfen:

import hashlib  
# 加载包含密码列表的文件  
with open('passwords.txt', 'r') as f:  
    passwords = f.read().splitlines()  
# 加载哈希值  
hash_value = '5d41402abc4b2a76b9719d911017c592'  
# 尝试匹配密码  
for password in passwords:  
    if hashlib.md5(password.encode()).hexdigest() == hash_value:  
        print(f"Password found: {password}")  
        break  
else:  
    print("Password not found.")

Die sogenannten Datenbanken im Internet waren „de-datenbasiert“. Tatsächlich wurde Chiffretext durchgesickert, und dann haben Hacker den verwendet MD5-Hash-Algorithmus zum Ausprobieren des Match-Passworts. Bei erfolgreicher Passwortübereinstimmung wird das passende Passwort ausgegeben, andernfalls wird das Passwort nicht gefunden. Natürlich kann man seltsame Performance-Kunst wie CSDN, bei der Klartext zum Speichern von Passwörtern verwendet wird, nicht als ein häufiges Phänomen betrachten.

Aber tatsächlich ist die sogenannte „Erschöpfung“ nicht im eigentlichen Sinne erschöpfend, denn Menschen legen Passwörter auf der Grundlage dieser Regeln fest, wie zum Beispiel Geburtsdatum, Mobiltelefonnummer usw. Wenn es sich um Bekannte handelt, kann eine irreversible Verschlüsselung leicht passieren Um zu vermeiden, dass ein Hacker das Passwort „ausprobiert“, muss das Passwort zunächst lang sein und Zahlen, Groß- und Kleinbuchstaben sowie Symbole enthalten, um die Möglichkeiten des Passworts zu maximieren. Es gibt 10 Möglichkeiten für Zahlen, 26 Möglichkeiten für Kleinbuchstaben, 26 Möglichkeiten für Großbuchstaben und 34 Möglichkeiten für Symbole. Wenn die Länge 16 Ziffern und ein bisschen zufällig ist, kann das mögliche Passwort 96 hoch 16 sein, also 6 Billionen Möglichkeiten. Wenn dies versucht würde, wäre es das Jahr des Affen:

Schließlich kann der irreversible Verschlüsselungsalgorithmus auch die Sicherheit des Chiffretexts verbessern, indem er den Salt-Wert erhöht, die Anzahl der Iterationen erhöht usw .

Asymmetrische Verschlüsselung

Asymmetrische Verschlüsselung ist ebenfalls ein Verschlüsselungsalgorithmus. Im Gegensatz zum oben beschriebenen symmetrischen Verschlüsselungsalgorithmus verwendet sie jedoch ein Paar öffentlicher und privater Schlüssel (öffentlicher Schlüssel und privater Schlüssel) zum Ver- und Entschlüsseln von Daten. Bei der asymmetrischen Verschlüsselung ist der öffentliche Schlüssel öffentlich und jeder kann ihn zum Verschlüsseln von Daten verwenden, aber nur die Person, die den privaten Schlüssel besitzt, kann die Daten entschlüsseln.

Asymmetrische Verschlüsselungsalgorithmen werden häufig in den folgenden Szenarien verwendet:

Sichere Kommunikation: Asymmetrische Verschlüsselung kann die Sicherheit von Daten während der Netzwerkübertragung schützen. Beispielsweise wird der asymmetrische Verschlüsselungsalgorithmus im HTTPS-Protokoll verwendet, um die Kommunikation zwischen Websites zu schützen und der Benutzer.

Digitale Signatur: Asymmetrische Verschlüsselung kann einen privaten Schlüssel zum Signieren von Dateien oder Daten verwenden, um die Integrität und Authentizität der Datei oder Daten zu überprüfen. Beispielsweise werden asymmetrische Verschlüsselungsalgorithmen in digitalen Zertifikaten verwendet, um die Sicherheit digitaler Signaturen zu schützen.

Authentifizierung: Die asymmetrische Verschlüsselung kann private Schlüssel zur Authentifizierung verwenden, z. B. SSH-Anmeldung oder Remote-Desktop, und öffentliche Schlüssel zur Identitätsauthentifizierung und verschlüsselten Kommunikation verwenden.

In Python3.10 können Sie das Kryptografiemodul in der Standardbibliothek verwenden, um eine asymmetrische Verschlüsselung zu implementieren. Das Folgende ist ein Beispiel für die Verwendung des Kryptografiemoduls zum Generieren eines Paares aus öffentlichen und privaten Schlüsseln:

from cryptography.hazmat.primitives.asymmetric import rsa, padding  
from cryptography.hazmat.primitives import serialization  
# 生成公私钥  
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)  
public_key = private_key.public_key()  
# 将公钥和私钥保存到文件  
with open('private_key.pem', 'wb') as f:  
    f.write(private_key.private_bytes(  
        encoding=serialization.Encoding.PEM,  
        format=serialization.PrivateFormat.PKCS8,  
        encryption_algorithm=serialization.NoEncryption()))  
with open('public_key.pem', 'wb') as f:  
    f.write(public_key.public_bytes(  
        encoding=serialization.Encoding.PEM,  
        format=serialization.PublicFormat.SubjectPublicKeyInfo))

Hier das RSA-Modul wird verwendet, um ein Paar öffentlicher und privater Schlüssel zu generieren, und verwendet das Serialisierungsmodul, um die öffentlichen und privaten Schlüssel in Dateien zu speichern. Bei der tatsächlichen Verwendung kann der öffentliche Schlüssel öffentlich verwendet werden, während der private Schlüssel an einem sicheren Ort aufbewahrt werden sollte, um die Datensicherheit zu gewährleisten.

In Zahlungssystemen wird asymmetrische Verschlüsselung häufig verwendet, um Signaturen und Signaturüberprüfungsvorgänge zu generieren, um die Sicherheit des Zahlungsprozesses zu gewährleisten:

 def sign(self, unsigned_string):  
        # 开始计算签名  
        key = self.app_private_key  
        signer = PKCS1_v1_5.new(key)  
        signature = signer.sign(SHA256.new(unsigned_string))  
        # base64 编码，转换为unicode表示并移除回车  
        sign = encodebytes(signature).decode("utf8").replace("\n", "")  
        return sign  
    def _verify(self, raw_content, signature):  
        # 开始计算签名  
        key = self.alipay_public_key  
        signer = PKCS1_v1_5.new(key)  
        digest = SHA256.new()  
        digest.update(raw_content.encode("utf8"))  
        if signer.verify(digest, decodebytes(signature.encode("utf8"))):  
            return True  
        return False

Öffentlicher Schlüssel wird zum Generieren von Signaturen verwendet und der private Schlüssel wird zur Überprüfung von Signaturen verwendet.

区块链与非对称加密

非对称加密在区块链领域中的应用非常广泛。区块链是一个去中心化的分布式账本系统，由于其去中心化的特点，任何人都可以加入网络并参与交易，因此需要使用非对称加密来保护数据的隐私和安全性。

以下是一些非对称加密在区块链领域中的应用：

数字签名：在区块链中，数字签名用于验证交易的真实性和完整性。数字签名的过程是使用私钥对交易数据进行签名，然后在交易中包含签名和公钥，其他人可以使用公钥验证交易的真实性和完整性。
共识算法：区块链中的共识算法用于确定哪些交易应该被添加到区块中。共识算法通常需要参与者提供一定数量的加密学证据，如哈希值或数字签名，以证明他们有权参与共识。
区块链钱包：区块链钱包是用于存储和管理数字货币的介质。钱包通常使用非对称加密来保护用户的私钥，确保用户的数字货币不被盗窃或篡改。

加密货币交易所：加密货币交易所是用于买卖数字货币的平台。交易所通常使用非对称加密来保护用户的身份信息和交易数据的安全性。

可以使用Python3.10来完成区块链中的数字签名，同样使用Python的加密库 cryptography 来生成公私钥对、签名和验证签名。下面是一个简单的示例代码：

from cryptography.hazmat.primitives.asymmetric import ec  
from cryptography.hazmat.primitives import serialization, hashes  
from cryptography.hazmat.primitives.asymmetric.utils import encode_dss_signature, decode_dss_signature  
# 生成椭圆曲线公私钥对  
private_key = ec.generate_private_key(ec.SECP256K1())  
public_key = private_key.public_key()  
# 对数据进行签名  
data = b"hello, world"  
signature = private_key.sign(data, ec.ECDSA(hashes.SHA256()))  
# 将签名和数据一起传输  
signature_bytes = encode_dss_signature(*signature)  
data_with_signature = (data, signature_bytes)  
# 验证签名  
data, signature_bytes = data_with_signature  
signature = decode_dss_signature(signature_bytes)  
public_key.verify(signature, data, ec.ECDSA(hashes.SHA256()))

首先，我们使用 ec.generate_private_key(ec.SECP256K1()) 方法生成一个椭圆曲线私钥。然后，我们可以通过 private_key.public_key() 方法获取对应的公钥。

接着，我们使用私钥对数据进行签名。这里使用 SHA256 哈希算法来计算数据的哈希值，并使用 ECDSA 签名算法对哈希值进行签名。
随后，我们将签名和数据一起传输。在实际应用中，签名和数据通常都是以二进制数据的形式进行传输。
最后，我们可以使用公钥来验证签名。首先，我们需要将签名从字节数据解码为两个整数。然后，我们可以使用 public_key.verify() 方法来验证签名是否正确。如果签名正确，这个方法将不会抛出异常；否则，将会抛出 InvalidSignature 异常。

Das obige ist der detaillierte Inhalt vonRake-Comb-Verschlüsselungsalgorithmus in Python: Typen und Anwendungsszenarien. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!