Pythonは一般的ないくつかの暗号化アルゴリズム（MD 5，SHA-1，HMAC，DES/AES，RSA，ECC）を実現する。
生活の中で私達はよくいくつかの暗号化アルゴリズムに出会います。今日はこれらの暗号化アルゴリズムのPythonの実現について話します。部分的によく使われている暗号化方法は基本的に対応するPythonライブラリがあります。基本的にコードで具体的なアルゴリズムを実現する必要はありません。
MD 5暗号化
全称：MD 5メッセージ要約アルゴリズム（英語：MD 5 Message-Digest Algorithm）は、広く使用されている暗号ハッシュ関数であり、情報伝達の完全一致を保証するために128ビット（16バイト）のハッシュ値を生成することができる。md 5暗号化アルゴリズムは可逆的ではないので、復号は一般的に暴力的に貧しい方法で、ウェブサイトのインターフェースを通じて復号されます。Pythonコード:
全称：セキュリティハッシュアルゴリズム（Secure Hash Algorithm）は、デジタル署名標準（Digital Signature Standard DSS）で定義されているデジタル署名アルゴリズム（Digital Signature Algorithm DSA）に主に適用され、SHA 1はMD 5よりも安全性が強い。2^64ビット未満の長さのメッセージに対して、SHA 1は160ビットのメッセージダイジェストを生成する。Pythonコード:
全称：ハッシュメッセージ識別コード（Hash Message Authentication Code）、HMAC暗号化アルゴリズムは、暗号化されたhash関数と共有鍵に基づくセキュアなメッセージ認証プロトコルである。インプリメンテーション原理は、この識別識別識別メッセージの完全性を用いて、公開関数と鍵で固定長の値を認証識別子として生成することである。鍵を使用して固定サイズの小さいデータブロック、すなわちMACを生成し、メッセージに加入して送信する。受信者は送信者と共有する鍵を用いて識別認証などを行う。Pythonコード:
全称：データ暗号化規格（Data Ecryption Standard）は、対称暗号化アルゴリズムです。DESはパケット暗号化アルゴリズムであり、典型的なDESは64ビットでパケット対データ暗号化、暗号化および復号化に使用されるのは同じアルゴリズムである。その鍵の長さは56ビット（各8ビットがパリティチェックとして使用されるため）であり、鍵は任意の56ビットの数であってもよく、任意の時に変更されてもよい。Pythonコード:
全称：高級暗号化規格（英語：Advanced Ecryption Standard）は、暗号学ではRijndel暗号化法とも呼ばれ、米連邦政府が採用しているブロック暗号化規格の一つです。この標準はもとのDESに取って代わるために用いて、すでに多方面に分析されてしかも全世界のために使われました。Pythonコード:
全称：Rivest-Shamir-Adleman、RSA暗号化アルゴリズムは非対称暗号化アルゴリズムです。公開鍵暗号化と電子商取引ではRSAが広く使われている。一般的には現在の比較的優れた公開鍵スキームの一つと考えられている。RSAは、暗号化とデジタル署名を同時に使用できる最初のアルゴリズムであり、これまでに知られているすべての暗号攻撃に抵抗することができる。Pythonコード:
全称：楕円曲線暗号化（Elliptic Curve Cryptgraphy）、ECC暗号化アルゴリズムは公開鍵暗号化技術で、楕円曲線理論に基づいています。限られた領域の楕円曲線の点からなるAbel群の離散対数難解性を利用して、暗号化、復号、デジタル署名を実現します。楕円曲線における加算を離散対数におけるモード演算に対応させることで、楕円曲線に基づく対応暗号体制を構築することができる。Pythonコード:
ここでPythonに関する一般的な暗号化アルゴリズムのいくつかの記事を紹介します。Python暗号化アルゴリズムの内容については以前の記事を検索したり、以下の関連記事を見たりしてください。これからもよろしくお願いします。
MD 5暗号化
全称：MD 5メッセージ要約アルゴリズム（英語：MD 5 Message-Digest Algorithm）は、広く使用されている暗号ハッシュ関数であり、情報伝達の完全一致を保証するために128ビット（16バイト）のハッシュ値を生成することができる。md 5暗号化アルゴリズムは可逆的ではないので、復号は一般的に暴力的に貧しい方法で、ウェブサイトのインターフェースを通じて復号されます。Pythonコード:
import hashlib
m = hashlib.md5()
m.update(str.encode("utf8"))
print(m.hexdigest())
全称：セキュリティハッシュアルゴリズム（Secure Hash Algorithm）は、デジタル署名標準（Digital Signature Standard DSS）で定義されているデジタル署名アルゴリズム（Digital Signature Algorithm DSA）に主に適用され、SHA 1はMD 5よりも安全性が強い。2^64ビット未満の長さのメッセージに対して、SHA 1は160ビットのメッセージダイジェストを生成する。Pythonコード:
import hashlib
sha1 = hashlib.sha1()
data = '2333333'
sha1.update(data.encode('utf-8'))
sha1_data = sha1.hexdigest()
print(sha1_data)
全称：ハッシュメッセージ識別コード（Hash Message Authentication Code）、HMAC暗号化アルゴリズムは、暗号化されたhash関数と共有鍵に基づくセキュアなメッセージ認証プロトコルである。インプリメンテーション原理は、この識別識別識別メッセージの完全性を用いて、公開関数と鍵で固定長の値を認証識別子として生成することである。鍵を使用して固定サイズの小さいデータブロック、すなわちMACを生成し、メッセージに加入して送信する。受信者は送信者と共有する鍵を用いて識別認証などを行う。Pythonコード:
import hmac
import hashlib
# key， ， hash
mac = hmac.new('key','hello',hashlib.md5)
mac.digest() # ascii
mac.hexdigest() #
全称：データ暗号化規格（Data Ecryption Standard）は、対称暗号化アルゴリズムです。DESはパケット暗号化アルゴリズムであり、典型的なDESは64ビットでパケット対データ暗号化、暗号化および復号化に使用されるのは同じアルゴリズムである。その鍵の長さは56ビット（各8ビットがパリティチェックとして使用されるため）であり、鍵は任意の56ビットの数であってもよく、任意の時に変更されてもよい。Pythonコード:
import binascii
from pyDes import des, CBC, PAD_PKCS5
# pip install pyDes
def des_encrypt(secret_key, s):
iv = secret_key
k = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
en = k.encrypt(s, padmode=PAD_PKCS5)
return binascii.b2a_hex(en)
def des_decrypt(secret_key, s):
iv = secret_key
k = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
de = k.decrypt(binascii.a2b_hex(s), padmode=PAD_PKCS5)
return de
secret_str = des_encrypt('12345678', 'I love YOU~')
print(secret_str)
clear_str = des_decrypt('12345678', secret_str)
print(clear_str)
全称：高級暗号化規格（英語：Advanced Ecryption Standard）は、暗号学ではRijndel暗号化法とも呼ばれ、米連邦政府が採用しているブロック暗号化規格の一つです。この標準はもとのDESに取って代わるために用いて、すでに多方面に分析されてしかも全世界のために使われました。Pythonコード:
import base64
from Crypto.Cipher import AES
'''
AES
'''
# ，str 16 16
def add_to_16(value):
while len(value) % 16 != 0:
value += '\0'
return str.encode(value) # bytes
#
def encrypt(key, text):
aes = AES.new(add_to_16(key), AES.MODE_ECB) #
encrypt_aes = aes.encrypt(add_to_16(text)) # aes
encrypted_text = str(base64.encodebytes(encrypt_aes), encoding='utf-8') # bytes
return encrypted_text
#
def decrypt(key, text):
aes = AES.new(add_to_16(key), AES.MODE_ECB) #
base64_decrypted = base64.decodebytes(text.encode(encoding='utf-8')) # base64 bytes
decrypted_text = str(aes.decrypt(base64_decrypted), encoding='utf-8').replace('\0', '') # str
return decrypted_text
全称：Rivest-Shamir-Adleman、RSA暗号化アルゴリズムは非対称暗号化アルゴリズムです。公開鍵暗号化と電子商取引ではRSAが広く使われている。一般的には現在の比較的優れた公開鍵スキームの一つと考えられている。RSAは、暗号化とデジタル署名を同時に使用できる最初のアルゴリズムであり、これまでに知られているすべての暗号攻撃に抵抗することができる。Pythonコード:
# -*- coding: UTF-8 -*-
# reference codes: https://www.jianshu.com/p/7a4645691c68
import base64
import rsa
from rsa import common
# rsa RSA
class RsaUtil(object):
PUBLIC_KEY_PATH = 'xxxxpublic_key.pem' #
PRIVATE_KEY_PATH = 'xxxxxprivate_key.pem' #
# key
def __init__(self,
company_pub_file=PUBLIC_KEY_PATH,
company_pri_file=PRIVATE_KEY_PATH):
if company_pub_file:
self.company_public_key = rsa.PublicKey.load_pkcs1_openssl_pem(open(company_pub_file).read())
if company_pri_file:
self.company_private_key = rsa.PrivateKey.load_pkcs1(open(company_pri_file).read())
def get_max_length(self, rsa_key, encrypt=True):
""" .
:param rsa_key: .
:param encrypt: .
"""
blocksize = common.byte_size(rsa_key.n)
reserve_size = 11 # 11
if not encrypt: #
reserve_size = 0
maxlength = blocksize - reserve_size
return maxlength
#
def encrypt_by_public_key(self, message):
""" .
:param message: .
base64
"""
encrypt_result = b''
max_length = self.get_max_length(self.company_public_key)
while message:
input = message[:max_length]
message = message[max_length:]
out = rsa.encrypt(input, self.company_public_key)
encrypt_result += out
encrypt_result = base64.b64encode(encrypt_result)
return encrypt_result
def decrypt_by_private_key(self, message):
""" .
:param message: .
，
"""
decrypt_result = b""
max_length = self.get_max_length(self.company_private_key, False)
decrypt_message = base64.b64decode(message)
while decrypt_message:
input = decrypt_message[:max_length]
decrypt_message = decrypt_message[max_length:]
out = rsa.decrypt(input, self.company_private_key)
decrypt_result += out
return decrypt_result
# base64
def sign_by_private_key(self, data):
""" .
:param data: .
SHA-1 （ MD5）
，
"""
signature = rsa.sign(str(data), priv_key=self.company_private_key, hash='SHA-1')
return base64.b64encode(signature)
def verify_by_public_key(self, message, signature):
""" .
:param message: .
:param signature: （ ， b64encode ， ）.
"""
signature = base64.b64decode(signature)
return rsa.verify(message, signature, self.company_public_key)
全称：楕円曲線暗号化（Elliptic Curve Cryptgraphy）、ECC暗号化アルゴリズムは公開鍵暗号化技術で、楕円曲線理論に基づいています。限られた領域の楕円曲線の点からなるAbel群の離散対数難解性を利用して、暗号化、復号、デジタル署名を実現します。楕円曲線における加算を離散対数におけるモード演算に対応させることで、楕円曲線に基づく対応暗号体制を構築することができる。Pythonコード:
# -*- coding:utf-8 *-
# author: DYBOY
# reference codes: https://blog.dyboy.cn/websecurity/121.html
# description: ECC
"""
K=kG ， K、G Ep(a,b) ，n G （nG=O∞ ），k n 。
k G， ， K ， K G， k 。
ECC p ，n ， n 。
G （base point）
k（k<n） （privte key）
K （public key)
"""
def get_inverse(mu, p):
"""
y
"""
for i in range(1, p):
if (i*mu)%p == 1:
return i
return -1
def get_gcd(zi, mu):
"""
"""
if mu:
return get_gcd(mu, zi%mu)
else:
return zi
def get_np(x1, y1, x2, y2, a, p):
"""
n*p， +p， np=-p
"""
flag = 1 # （+/-）
# p=q k=(3x2+a)/2y1mod p
if x1 == x2 and y1 == y2:
zi = 3 * (x1 ** 2) + a # 【 】
mu = 2 * y1 #
# P≠Q， k=(y2-y1)/(x2-x1) mod p
else:
zi = y2 - y1
mu = x2 - x1
if zi* mu < 0:
flag = 0 # 0 -（ ）
zi = abs(zi)
mu = abs(mu)
#
gcd_value = get_gcd(zi, mu) # s
zi = zi // gcd_value #
mu = mu // gcd_value
# ： ∀a ∈G ，ョb∈G ab = ba = e
# P(x,y) (x,-y mod p)= (x,p-y) ， P+(-P)= O∞
inverse_value = get_inverse(mu, p)
k = (zi * inverse_value)
if flag == 0: # flag==0
k = -k
k = k % p
# x3,y3 P+Q
"""
x3≡k2-x1-x2(mod p)
y3≡k(x1-x3)-y1(mod p)
"""
x3 = (k ** 2 - x1 - x2) % p
y3 = (k * (x1 - x3) - y1) % p
return x3,y3
def get_rank(x0, y0, a, b, p):
"""
"""
x1 = x0 #-p x
y1 = (-1*y0)%p #-p y
tempX = x0
tempY = y0
n = 1
while True:
n += 1
# p+q ， n*p，
p_x,p_y = get_np(tempX, tempY, x0, y0, a, p)
# == -p, +1，
if p_x == x1 and p_y == y1:
return n+1
tempX = p_x
tempY = p_y
def get_param(x0, a, b, p):
"""
p -p
"""
y0 = -1
for i in range(p):
# ， Ep(a,b)，p ，x,y∈[0,p-1]
if i**2%p == (x0**3 + a*x0 + b)%p:
y0 = i
break
# y0 ， false
if y0 == -1:
return False
# -y（ ）
x1 = x0
y1 = (-1*y0) % p
return x0,y0,x1,y1
def get_graph(a, b, p):
"""
"""
x_y = []
#
for i in range(p):
x_y.append(['-' for i in range(p)])
for i in range(p):
val =get_param(i, a, b, p) #
if(val != False):
x0,y0,x1,y1 = val
x_y[x0][y0] = 1
x_y[x1][y1] = 1
print(" ：")
for i in range(p): # i= 0-> p-1
temp = p-1-i #
# 1/2 ，y
if temp >= 10:
print(temp, end=" ")
else:
print(temp, end=" ")
# ，
for j in range(p):
print(x_y[j][temp], end=" ")
print("") #
# x
print(" ", end="")
for i in range(p):
if i >=10:
print(i, end=" ")
else:
print(i, end=" ")
print('
')
def get_ng(G_x, G_y, key, a, p):
"""
nG
"""
temp_x = G_x
temp_y = G_y
while key != 1:
temp_x,temp_y = get_np(temp_x,temp_y, G_x, G_y, a, p)
key -= 1
return temp_x,temp_y
def ecc_main():
while True:
a = int(input(" a(a>0) ："))
b = int(input(" b(b>0) ："))
p = int(input(" p(p ) ：")) #
#
if (4*(a**3)+27*(b**2))%p == 0:
print(" ， ！！！
")
else:
break
#
get_graph(a, b, p)
# G
print("user1： G ")
G_x = int(input("user1： x ："))
G_y = int(input("user1： y ："))
#
n = get_rank(G_x, G_y, a, b, p)
# user1 ， key
key = int(input("user1： key（<{}）：".format(n)))
# user1 ， KEY
KEY_x,kEY_y = get_ng(G_x, G_y, key, a, p)
# user2
# user2 user1 KEY，Ep(a,b) n，
#
k = int(input("user2： k（<{}） kG kQ：".format(n)))
k_G_x,k_G_y = get_ng(G_x, G_y, k, a, p) # kG
k_Q_x,k_Q_y = get_ng(KEY_x, kEY_y, k, a, p) # kQ
#
plain_text = input("user2： :")
plain_text = plain_text.strip()
#plain_text = int(input("user1： ："))
c = []
print(" ：",end="")
for char in plain_text:
intchar = ord(char)
cipher_text = intchar*k_Q_x
c.append([k_G_x, k_G_y, cipher_text])
print("({},{}),{}".format(k_G_x, k_G_y, cipher_text),end="-")
# user1
# user2
# k_G_x,k_G_y，key ， k_Q_x,k_Q_y ， plain_text = cipher_text/k_Q_x
print("
user1 ：",end="")
for charArr in c:
decrypto_text_x,decrypto_text_y = get_ng(charArr[0], charArr[1], key, a, p)
print(chr(charArr[2]//decrypto_text_x),end="")
if __name__ == "__main__":
print("*************ECC *************")
ecc_main()
ここでPythonに関する一般的な暗号化アルゴリズムのいくつかの記事を紹介します。Python暗号化アルゴリズムの内容については以前の記事を検索したり、以下の関連記事を見たりしてください。これからもよろしくお願いします。