Algoritma penyulitan rake-comb dalam Python: jenis dan senario aplikasi

Algoritma Penyulitan Boleh Balik (Symmetric Encryption)

Algoritma penyulitan ialah kaedah menukar data asal kepada data yang disulitkan. Mengikut ciri-ciri berbeza algoritma penyulitan, ia boleh dibahagikan kepada algoritma penyulitan boleh balik dan algoritma penyulitan tidak boleh balik.

Algoritma penyulitan boleh balik juga dipanggil algoritma penyulitan simetri, yang menggunakan kunci yang sama untuk proses penyulitan dan penyahsulitan. Dalam algoritma ini, data yang disulitkan boleh dipulihkan kepada data asal melalui algoritma penyahsulitan. Algoritma ini sering digunakan untuk melindungi kerahsiaan data, seperti fail yang disimpan pada pemacu keras komputer atau data yang dihantar melalui rangkaian.

Secara terang-terangan, data disulitkan semasa penghantaran Apabila ia sebenarnya digunakan dalam perniagaan, plaintext masih digunakan.

Sebagai contoh, gunakan algoritma penyulitan AES untuk menyulitkan fail:

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)

atau gunakan algoritma 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())

Dalam bidang penghantaran rangkaian, penyulitan simetri biasanya digunakan dalam JWT Token Pautan penyulitan token menggunakan:

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

Dalam aplikasi sebenar, adalah perlu untuk memilih algoritma penyulitan dan panjang kunci yang sesuai untuk senario tertentu, dan mengambil langkah keselamatan yang sesuai untuk melindungi kunci, kerana untuk boleh diterbalikkan algoritma penyulitan, Setelah kunci rahsia dibocorkan, akibatnya akan menjadi malapetaka.

Algoritma penyulitan tidak boleh balik (cincang)

Penyulitan tidak boleh balik (juga dipanggil algoritma cincang) biasanya digunakan untuk menyulitkan atau mengesahkan kata laluan atau data untuk memastikan keselamatan kata laluan atau data. Berbanding dengan penyulitan simetri atau penyulitan asimetri, algoritma cincang tidak memerlukan kunci untuk penyulitan atau penyahsulitan, jadi ia lebih mudah dan cekap, tetapi ia tidak menyokong penyahsulitan Setelah hasil yang disulitkan dijana, data asal tidak boleh dipulihkan. dan algoritma penyulitan tidak boleh balik Senario aplikasi yang paling biasa ialah menyulitkan kata laluan teks biasa pengguna ke dalam teks sifir.

Sebagai contoh, gunakan algoritma cincang SHA-256 untuk menyulitkan data:

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

Atau gunakan algoritma bcrypt untuk menyulitkan kata laluan:

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

Atau gunakan algoritma scrypt untuk menyulitkan kata laluan Penyulitan:

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

Prinsipnya adalah serupa Semuanya berdasarkan algoritma cincang untuk memetakan data asal kepada teks sifir panjang tetap Memandangkan penyulitan tidak boleh balik (algoritma cincang) ialah Disulitkan sehala , data asal tidak boleh dipulihkan melalui penyahsulitan, jadi algoritma pencincangan brute-force biasanya cuba memadankan data asal dengan meletihkan sejumlah besar kemungkinan:

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

Pangkalan data yang dipanggil di Internet adalah Perpustakaan "disulitkan" ", apa yang sebenarnya dibocorkan ialah teks sifir, dan penggodam kemudian menggunakan algoritma pencincangan MD5 untuk cuba memadankan kata laluan. Jika padanan kata laluan berjaya, kata laluan yang sepadan akan dikeluarkan, jika tidak kata laluan tidak ditemui. Sudah tentu, seni persembahan pelik seperti CSDN, yang menggunakan teks yang jelas untuk menyimpan kata laluan, tidak boleh dianggap sebagai fenomena biasa.

Tetapi sebenarnya, apa yang dipanggil "exhaustive" itu tidak menyeluruh dalam erti kata sebenar, kerana manusia hanya menetapkan kata laluan berdasarkan peraturan tersebut, seperti tarikh lahir, nombor telefon bimbit, dll. Jika mereka kenalan. , penyulitan tidak boleh balik boleh dicuba dengan mudah, jadi untuk mengelakkan daripada "dicuba" oleh penggodam, kata laluan mestilah panjang dan mengandungi nombor, huruf besar dan huruf kecil, dan simbol, untuk memaksimumkan kemungkinan kata laluan. Terdapat 10 kemungkinan untuk nombor, 26 kemungkinan untuk huruf kecil, 26 kemungkinan untuk huruf besar, dan 34 kemungkinan untuk simbol Jika panjangnya adalah 16 digit dan sedikit rawak, kata laluan yang mungkin mungkin 96 hingga kuasa ke-16, iaitu 6. trilion kemungkinan , jika ini dicuba, ia akan menjadi Tahun Monyet:

Akhir sekali, algoritma penyulitan tidak boleh balik juga boleh meningkatkan teks sifir dengan meningkatkan nilai garam, meningkatkan bilangan lelaran, dsb. Keselamatan.

Penyulitan asimetri

Penyulitan asimetri juga merupakan algoritma penyulitan Walau bagaimanapun, tidak seperti algoritma penyulitan simetri yang dinyatakan di atas, ia menggunakan sepasang kunci awam dan peribadi (kunci awam dan kunci persendirian) untuk Menyulitkan. dan menyahsulit data. Dalam penyulitan asimetri, kunci awam adalah awam dan sesiapa sahaja boleh menggunakannya untuk menyulitkan data, tetapi hanya orang yang memegang kunci peribadi itu boleh menyahsulit data.

Algoritma penyulitan asimetri digunakan secara meluas dalam senario berikut:

Komunikasi selamat: Penyulitan asimetri boleh melindungi keselamatan data semasa penghantaran rangkaian, seperti penggunaan penyulitan asimetri dalam protokol HTTPS Algoritma melindungi penghantaran data antara laman web dan pengguna.

Tandatangan digital: Penyulitan asimetri boleh menggunakan kunci peribadi untuk menandatangani fail atau data untuk mengesahkan integriti dan ketulenan fail atau data Contohnya, algoritma penyulitan asimetri digunakan dalam sijil digital untuk melindungi keselamatan digital tandatangan.

Pengesahan: Penyulitan asimetri boleh menggunakan kunci peribadi untuk pengesahan, seperti log masuk SSH atau desktop jauh dan menggunakan kunci awam untuk pengesahan identiti dan komunikasi yang disulitkan.

Dalam Python 3.10, anda boleh menggunakan modul kriptografi dalam perpustakaan standard untuk melaksanakan penyulitan asimetri Berikut ialah contoh penggunaan modul kriptografi untuk menjana sepasang kunci awam dan peribadi:

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

<.>Modul rsa digunakan di sini Sepasang kunci awam dan peribadi dijana dan modul bersiri digunakan untuk menyimpan kunci awam dan peribadi pada fail. Dalam penggunaan sebenar, kunci awam boleh digunakan secara terbuka, manakala kunci peribadi harus disimpan di tempat yang selamat untuk memastikan keselamatan data.

Dalam sistem pembayaran, penyulitan asimetrik digunakan secara meluas Set algoritma penyulitan ini digunakan terutamanya untuk menjana tandatangan dan operasi pengesahan tandatangan untuk memastikan keselamatan proses pembayaran Ambil pembayaran Alipay sebagai contoh:

 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

Kunci awam digunakan untuk menjana tandatangan, dan kunci persendirian digunakan untuk mengesahkan tandatangan.

区块链与非对称加密

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

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

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

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

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

Atas ialah kandungan terperinci Algoritma penyulitan rake-comb dalam Python: jenis dan senario aplikasi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!