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

可逆暗号化アルゴリズム (対称暗号化)

暗号化アルゴリズムは、元のデータを暗号化されたデータに変換する方法です。暗号化アルゴリズムのさまざまな特性に応じて、暗号化アルゴリズムは可逆暗号化アルゴリズムと不可逆暗号化アルゴリズムに分類できます。

可逆暗号化アルゴリズムは対称暗号化アルゴリズムとも呼ばれ、暗号化処理と復号化処理に同じ鍵が使用されます。このアルゴリズムでは、暗号化されたデータを復号化アルゴリズムによって元のデータに復元できます。このアルゴリズムは、コンピューターのハード ドライブに保存されているファイルやネットワーク経由で送信されるデータなどのデータの機密性を保護するためによく使用されます。

平たく言えば、データ通信時の暗号化のことですが、実際にビジネスで利用する場合には、やはり平文が使われます。

たとえば、AES 暗号化アルゴリズムを使用してファイルを暗号化します:

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)

または 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())

ネットワーク伝送の分野では、一般に対称暗号化が使用されます。 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

実際のアプリケーションでは、暗号化を元に戻すことができるため、特定のシナリオに適した暗号化アルゴリズムとキーの長さを選択し、キーを保護するために適切なセキュリティ対策を講じる必要があります。秘密鍵が漏洩すると、壊滅的な結果が生じます。

不可逆暗号化アルゴリズム (ハッシュ)

不可逆暗号化 (ハッシュ アルゴリズムとも呼ばれる) は通常、パスワードまたはデータの暗号化または検証に使用され、パスワードまたはデータのセキュリティを確保します。対称暗号化や非対称暗号化と比較して、ハッシュ アルゴリズムは暗号化または復号化にキーを必要としないため、より便利で効率的ですが、復号化はサポートされておらず、暗号化結果が生成されると元のデータを復元することはできません。および不可逆暗号化アルゴリズム 最も一般的なアプリケーション シナリオは、ユーザーの平文パスワードを暗号文に暗号化することです。

たとえば、SHA-256 ハッシュ アルゴリズムを使用してデータを暗号化します:

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

または、bcrypt アルゴリズムを使用してパスワードを暗号化します:

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

または scrypt アルゴリズムを使用して、パスワードを暗号化する 暗号化:

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

インターネット上のいわゆるデータベースは「復号化された」ライブラリです」、実際に漏洩したのは暗号文であり、ハッカーは MD5 ハッシュ アルゴリズムを使用してパスワードを照合しようとしました。パスワードの一致が成功した場合は、一致したパスワードが出力されます。そうでない場合は、パスワードが見つかりません。もちろん、クリア テキストを使用してパスワードを保存する CSDN のような奇妙なパフォーマンス アートは、一般的な現象とは考えられません。

しかし、実際には、いわゆる「網羅的」というのは、本当の意味での「網羅的」ではありません。なぜなら、人間は生年月日や携帯電話番号などのルールに基づいてパスワードを設定するだけだからです。 、不可逆暗号化は簡単に試行できるため、ハッカーによる「試用」を避けるために、パスワードの可能性を最大限に高めるために、パスワードはまず長く、数字、大文字、小文字、記号を含む必要があります。数字の可能性は 10 個、小文字の可能性は 26 個、大文字の可能性は 26 個、記号の可能性は 34 個あります。長さが 16 桁で少しランダムな場合、可能なパスワードは 96 の 16 乗、つまり 6 になります。数兆の可能性があります。これを試したら、猿年になります:

最後に、非可逆暗号化アルゴリズムは、ソルト値を増やすことで暗号文を改善することもできます。反復回数の増加などの安全性。

非対称暗号化

非対称暗号化も暗号化アルゴリズムですが、上記の対称暗号化アルゴリズムとは異なり、公開鍵と秘密鍵のペア (公開鍵と秘密鍵) を使用して暗号化を行います。そしてデータを復号化します。非対称暗号化では、公開キーは公開されており、誰でもそれを使用してデータを暗号化できますが、秘密キーを保持している人だけがデータを復号化できます。

非対称暗号化アルゴリズムは、次のシナリオで広く使用されています。

安全な通信: HTTPS プロトコルで使用される非対称暗号化など、非対称暗号化により、ネットワーク送信中のデータのセキュリティを保護できます。 アルゴリズムはデータを保護します。ウェブサイトとユーザー間の通信。

デジタル署名: 非対称暗号化では、秘密キーを使用してファイルまたはデータに署名し、ファイルまたはデータの整合性と信頼性を検証できます。たとえば、非対称暗号化アルゴリズムはデジタル証明書で使用され、デジタル署名のセキュリティを保護します。 。

認証: 非対称暗号化では、SSH ログインやリモート デスクトップなどの認証に秘密キーを使用し、ID 認証と暗号化通信に公開キーを使用できます。

Python3.10 では、標準ライブラリの暗号化モジュールを使用して非対称暗号化を実装できます。次は、暗号化モジュールを使用して公開鍵と秘密鍵のペアを生成する例です:

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

ここでは rsa モジュールが使用されています。公開キーと秘密キーのペアが生成され、シリアル化モジュールを使用して公開キーと秘密キーをファイルに保存します。実際の使用では、公開キーは公的に使用できますが、秘密キーはデータのセキュリティを確保するために安全な場所に保管する必要があります。

決済システムでは、非対称暗号化が広く使用されています。この一連の暗号化アルゴリズムは主に、支払いプロセスのセキュリティを確保するために署名と署名検証操作を生成するために使用されます。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

公開キーは署名の生成に使用され、秘密キーは署名の検証に使用されます。

区块链与非对称加密

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

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

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

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

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

以上がPython の Rake-comb 暗号化アルゴリズム: 種類とアプリケーション シナリオの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。