Python の Rake-comb 暗号化アルゴリズム: 種類とアプリケーション シナリオ

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)

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

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

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

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

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

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

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

 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

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