Algorithme de chiffrement Rake-comb en Python : types et scénarios d'application

Algorithme de cryptage réversible (cryptage symétrique)

L'algorithme de cryptage est une méthode de conversion des données originales en données cryptées. Selon les différentes caractéristiques des algorithmes de chiffrement, ils peuvent être divisés en algorithmes de chiffrement réversibles et algorithmes de chiffrement irréversibles.

L'algorithme de cryptage réversible est également appelé algorithme de cryptage symétrique, et ses processus de cryptage et de déchiffrement utilisent la même clé. Dans cet algorithme, les données cryptées peuvent être restaurées aux données d'origine grâce à l'algorithme de décryptage. Cet algorithme est souvent utilisé pour protéger la confidentialité des données, telles que les fichiers stockés sur le disque dur d'un ordinateur ou les données transmises sur un réseau.

Pour parler franchement, les données sont cryptées pendant le processus de transmission. Lorsqu'elles sont réellement utilisées dans l'entreprise, le texte en clair est toujours utilisé.

Par exemple, utilisez l'algorithme de cryptage AES pour crypter des fichiers :

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)

ou utilisez l'algorithme DES :

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

Dans le domaine de la transmission réseau, le cryptage symétrique est généralement utilisé dans le processus de cryptage du Token JWT :

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

En pratique applications Dans ce cas, vous devez choisir l'algorithme de cryptage et la longueur de clé adaptés au scénario spécifique, et prendre les mesures de sécurité appropriées pour protéger la clé, car pour les algorithmes de cryptage réversibles, une fois la clé secrète divulguée, les conséquences seront catastrophiques.

Algorithme de cryptage irréversible (hachage)

Le cryptage irréversible (également appelé algorithme de hachage) est généralement utilisé pour crypter ou vérifier des mots de passe ou des données afin d'assurer la sécurité des mots de passe ou des données. Comparé au cryptage symétrique ou asymétrique, l'algorithme de hachage ne nécessite pas de clé pour le cryptage ou le déchiffrement, il est donc plus pratique et efficace, mais il ne prend pas en charge le décryptage. Une fois le résultat crypté généré, les données originales ne peuvent pas être récupérées. et l'algorithme de chiffrement irréversible. Le scénario d'application le plus courant consiste à chiffrer le mot de passe en clair de l'utilisateur en texte chiffré.

Par exemple, utilisez l'algorithme de hachage SHA-256 pour crypter les données :

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

Ou utilisez l'algorithme bcrypt pour crypter le mot de passe :

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

Ou utilisez l'algorithme scrypt pour crypter le mot de passe :

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

Les principes sont similaires, les deux sont Les données originales sont mappées sur un texte chiffré de longueur fixe basé sur l'algorithme de hachage. Étant donné que le cryptage irréversible (algorithme de hachage) est une méthode de cryptage unidirectionnelle, les données originales ne peuvent pas être restaurées par décryptage, de sorte que le hachage est craqué par force brute. Les algorithmes de hachage tentent généralement de faire correspondre les données originales en épuisant de manière exhaustive un grand nombre de possibilités :

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

Les soi-disant bases de données sur Internet ont été "dé-basées sur les données". En fait, ce qui a été divulgué était du texte chiffré, puis les pirates ont utilisé le. Algorithme de hachage MD5 pour essayer de faire correspondre le mot de passe. Si la correspondance du mot de passe réussit, le mot de passe correspondant est affiché, sinon le mot de passe n'est pas trouvé. Bien sûr, des performances artistiques étranges comme CSDN, qui utilisent du texte clair pour stocker les mots de passe, ne peuvent pas être considérées comme un phénomène courant.

Mais en fait, ce qu'on appelle « exhaustif » n'est pas exhaustif au sens propre du terme, car les humains définissent des mots de passe en fonction de ces règles, comme la date de naissance, le numéro de téléphone portable, etc. S'il s'agit de connaissances, un cryptage irréversible peut facilement être essayé, donc afin d'éviter que les mots de passe ne soient « essayés » par des pirates, le mot de passe doit d'abord être long et contenir des chiffres, des lettres majuscules et minuscules et des symboles, afin de maximiser les possibilités du mot de passe. Il existe 10 possibilités de chiffres, 26 possibilités de lettres minuscules, 26 possibilités de lettres majuscules et 34 possibilités de symboles. Si la longueur est de 16 chiffres et un peu aléatoire, le mot de passe possible peut être 96 à la puissance 16, soit 6. mille milliards de possibilités. , si cela était essayé, ce serait l'Année du Singe :

Enfin, l'algorithme de chiffrement irréversible peut également améliorer la sécurité du texte chiffré en augmentant la valeur du sel, en augmentant le nombre d'itérations, etc. .

Cryptage asymétrique

Le cryptage asymétrique est également un algorithme de cryptage. Cependant, contrairement à l'algorithme de cryptage symétrique décrit ci-dessus, il utilise une paire de clés publiques et privées (clé publique et clé privée) pour crypter et déchiffrer les données. Dans le chiffrement asymétrique, la clé publique est publique et n’importe qui peut l’utiliser pour chiffrer des données, mais seule la personne détenant la clé privée peut déchiffrer les données.

Les algorithmes de cryptage asymétriques sont largement utilisés dans les scénarios suivants :

Communication sécurisée : le cryptage asymétrique peut protéger la sécurité des données lors de la transmission réseau. Par exemple, l'algorithme de cryptage asymétrique est utilisé dans le protocole HTTPS pour protéger la communication entre le site Web. et l'utilisateur.

Signature numérique : le cryptage asymétrique peut utiliser une clé privée pour signer des fichiers ou des données afin de vérifier l'intégrité et l'authenticité du fichier ou des données. Par exemple, des algorithmes de cryptage asymétriques sont utilisés dans les certificats numériques pour protéger la sécurité des signatures numériques.

Authentification : le cryptage asymétrique peut utiliser des clés privées pour l'authentification, telles que la connexion SSH ou le bureau à distance, et utiliser des clés publiques pour l'authentification de l'identité et la communication cryptée.

Dans Python3.10, vous pouvez utiliser le module de cryptographie de la bibliothèque standard pour implémenter le chiffrement asymétrique. Voici un exemple d'utilisation du module de cryptographie pour générer une paire de clés publiques et privées :

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

Ici, le module rsa. est utilisé pour générer une paire de clés publiques et privées, et utiliser le module de sérialisation pour enregistrer les clés publiques et privées dans des fichiers. En utilisation réelle, la clé publique peut être utilisée publiquement, tandis que la clé privée doit être conservée dans un endroit sûr pour garantir la sécurité des données.

Dans les systèmes de paiement, le cryptage asymétrique est largement utilisé. Cet ensemble d'algorithmes de cryptage est principalement utilisé pour générer des signatures et des opérations de vérification de signature afin de garantir la sécurité du processus de paiement. Prenons l'exemple du paiement Alipay :

 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

Clé publique C'est. utilisé pour générer des signatures et la clé privée est utilisée pour vérifier les signatures.

区块链与非对称加密

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

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

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

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

可以使用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 异常。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!