日日操夜夜添-日日操影院-日日草夜夜操-日日干干-精品一区二区三区波多野结衣-精品一区二区三区高清免费不卡

加密簡介

數據加密有多種方法，勇哥能力有限，就介紹三種常見的數據加密方法：對稱加密、非對稱加密和單向加密。

編碼與解碼

常所說的加密方式，都是對二進制編碼的格式進行加密的。Python/ target=_blank class=infotextkey>Python 中進行加密時，要確保操作的是 Bytes，否則就會報錯。將字符串和 Bytes 互相轉換可以使用 encode()和 decode()方法。

• encode()：str 對象的方法，用于將字符串轉換為二進制數據（即 bytes），也稱為“編碼”。
• decode()：bytes 對象的方法，用于將二進制數據轉換為字符串，也稱為“解碼”。
• 在設置解碼采用的字符編碼時，需要與編碼時采用的字符編碼一致。使用 decode()方法時，同樣不會修改原字符串。

1. decode() | encode()案例：

def data_encode(st):
    """編碼 """
    return st.encode("utf-8")


def bs64_data_decode(st):
    """解碼"""
    return st.decode("utf8")

Base64 加/解密

base64 加密解密比較常見的就是圖片處理.

2. base64 案例：

"""base64信息轉圖片與圖片轉base64"""

def base64_to_img(byte_str, file_path):
    imgdata = base64.b64decode(byte_str)
    with open(file_path, 'wb') as f:
        f.write(imgdata)

def base64_to_str(byte_str):
    return base64.b64encode(byte_str.encode("utf-8")).decode('utf-8')

單向加密

單向加密是一種只能對數據進行加密，而不能進行解密的方法，也叫做散列函數或哈希函數。單向加密的目的是保證數據的完整性，即數據在傳輸或存儲過程中沒有被篡改或損壞。單向加密可以用來生成數據的摘要或簽名，用于驗證數據的來源和內容。單向加密有一個重要的特性，就是相同的輸入會產生相同的輸出，而不同的輸入會產生不同的輸出。常見的單向加密算法有：MD5、SHA 系列等。

1. MD5 加密示例：

def md5(st: str) -> str:
    """
    Args:
        st:待加密字符串
    Returns: 返回MD5 加密后的字符串
    """
    md = hashlib.md5()  # 創建MD5對象
    md.update(st.encode(encoding="utf-8"))
    return md.hexdigest()

2. sha1 加密示例：

SHA1 基于 MD5，加密后的數據長度更長，它對長度小于 264 的輸入，產生長度為 160bit 的散列值。比 MD5 多 32 位,因此，比 MD5 更加安全，但 SHA1 的運算速度就比 MD5 要慢.

def sha1_secret_str(st):
    """
    使用sha1加密算法，返回str加密后的字符串
    Args:
        st:

    Returns:

    """
    sha = hashlib.sha1(st.encode("utf-8"))
    return sha.hexdigest()

3. sha256 加密示例:

據說是比特幣挖礦就使用到。

SHA256是SHA-2下細分出的一種算法

SHA-2，名稱來自于安全散列算法2（英語：Secure Hash Algorithm 2）的縮寫，一種密碼散列函數算法標準（哈希算法），由美國國家安全局研發，屬于SHA算法之一，是SHA-1的后繼者。

SHA-2下又可再分為六個不同的算法標準，包括了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。這些變體除了生成摘要的長度 、循環運行的次數等一些微小差異外，

算法的基本結構是一致的。對于任意長度的消息，SHA256都會產生一個256bit長的哈希值，稱作消息摘要。這個摘要相當于是個長度為32個字節的數組，通常用一個長度為64的十六進制字符串來表示。

def sha256_single(st):
    """
    sha256加密
    Args:
        st: 加密字符串

    Returns:加密結果轉換為16進制字符串，并大寫

    """
    sha_obj = hashlib.sha256()
    sha_obj.update(st.encode("utf-8"))
    return sha_obj.hexdigest().upper()

對稱加密

對稱加密是一種使用相同的密鑰來進行數據加密和解密的方法，也叫做私鑰加密或共享密鑰加密。對稱加密的優點是速度快，適合加密大量的數據。對稱加密的缺點是需要雙方事先約定好并保管好密鑰，否則會導致數據泄露或丟失。對稱加密有兩種模式：分組密碼和流密碼。分組密碼是把明文分成固定長度的塊，然后對每個塊進行加密或解密，生成相同長度的密文或明文。流密碼是把明文分成單個字節，然后對每個字節進行加密或解密，生成單個字節的密文或明文。常見的對稱加密算法有：DES、AES、Blowfish 等。

1. AES（高級加密標準）：

AES 只有一個密鑰，這個密鑰既用來加密，也用于解密，

AES 加密方式有五種：ECB, CBC, CTR, CFB, OFB。

從安全性角度推薦 CBC 加密方法，本文介紹了 CBC,ECB 兩種加密方法的 python 實現。

CBC 和 ECB 模式的區別就是：

• CBC 加密需要一個十六位的 key(密鑰)和一個十六位 iv(偏移量)
• ECB 加密不需要 iv，只需要 key(密鑰)

class DoAES:
 """
 AES 加密
 """

 def __init__(self, key):
  self.key = key  # 將密鑰轉換為字符型數據
  self.mode = AES.MODE_ECB  # 操作模式選擇ECB

 def encrypt(self, text):
  """加密函數"""
  file_aes = AES.new(self.key, self.mode)  # 創建AES加密對象
  text = text.encode('utf-8')  # 明文必須編碼成字節流數據，即數據類型為bytes
  while len(text) % 16 != 0:  # 對字節型數據進行長度判斷
   text += b'x00'  # 如果字節型數據長度不是16倍整數就進行補充
  en_text = file_aes.encrypt(text)  # 明文進行加密，返回加密后的字節流數據
  return str(base64.b64encode(en_text), encoding='utf-8')  # 將加密后得到的字節流數據進行base64編碼并再轉換為unicode類型

 def decrypt(self, text):
  """解密函數"""
  file_aes = AES.new(self.key, self.mode)
  text = bytes(text, encoding='utf-8')  # 將密文轉換為bytes，此時的密文還是由basen64編碼過的
  text = base64.b64decode(text)  # 對密文再進行base64解碼
  de_text = file_aes.decrypt(text)  # 密文進行解密，返回明文的bytes
  return str(de_text, encoding='utf-8').strip()  # 將解密后得到的bytes型數據轉換為str型，并去除末尾的填充


if __name__ == '__mAIn__':
 # key = os.urandom(16)   #隨即產生n個字節的字符串，可以作為隨機加密key使用
 key = '2l4LoWczlWxlMZJAAp5N0g6EygZZd9C6'  # 隨即產生n個字節的字符串，可以作為隨機加密key使用
 text = '4534'  # 需要加密的內容
 aes_test = DoAES(key.encode('utf-8'))
 cipher_text = aes_test.encrypt(text)
 init_text = aes_test.decrypt(cipher_text)
 print('加密后：' + cipher_text)
 print('解密后：' + init_text)

輸出結果：

加密后：blhiuFNLSqBUMMDbWxUBBw==
解密后：4534

進程已結束,退出代碼0

2. DES 示例：

class Des:
    def __init__(self, text):
        self.text = text  # 原始字符串
        self.KEY = '2l4LoWcz'  # 這個key是固定問開發，
        # self.KEY  = os.urandom(8)  # 隨即產生n個字節的字符串，可以作為隨機加密key使用

    def des_encrypt(self):
        """DES 加密
        Returns:加密后字符串，16進制

        """
        secret_key = self.KEY  # 密碼
        iv = secret_key  # 偏移
        # secret_key:加密密鑰，CBC:加密模式，iv:偏移, padmode:填充
        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
        # 返回為字節
        secret_bytes = des_obj.encrypt(self.text.encode("utf-8"), padmode=PAD_PKCS5)
        # 返回為16進制
        return binascii.b2a_hex(secret_bytes)

    def des_decrypt(self):
        """
        DES 解密
        Returns:解密后的字符串

        """
        secret_key = self.KEY
        iv = secret_key
        des_obj = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
        decrypt_str = des_obj.decrypt(binascii.a2b_hex(self.text), padmode=PAD_PKCS5)
        return bytes.decode(decrypt_str)  # bytes.decode() 將bit轉為str

測試數據：

if __name__ == '__main__':
    text = 'TestingPlayer：測試玩家勇哥'  # 需要加密的內容
    d_encrypt = Des(text)
    cipher_text = d_encrypt.des_encrypt()
    d_decrypt = Des(cipher_text)
    init_text = d_decrypt.des_decrypt()
    print('加密后：', cipher_text)
    print('解密后：', init_text)

執行結果：

加密后：b'6a7e6bf7f34fcf0c4024e49b110cb6fe7924026e4c0477e5563599123358a3026ef1e81fd7445cb2'
解密后：TestingPlayer：測試玩家勇哥

非對稱加密

非對稱加密也叫做公鑰加密，是一種使用不同的兩個密鑰來進行數據加密和解密的方法。這兩個密鑰分別叫做公鑰和私鑰，它們之間有數學上的關聯，但不能相互推導。公鑰是公開的，可以用來給數據進行加密或驗證簽名；私鑰是保密的，可以用來給數據進行解密或生成簽名。非對稱加密的優點是安全性高，不需要雙方事先約定好并傳輸秘鑰。非對稱加密的缺點是速度慢，適合加密少量的數據。常見的非對稱加密算法有：RSA、DSA、ECC 等。

1. RSA（羅納德·李維斯特·沙米爾·阿迪曼）：

# 導入cryptography庫中的rsa模塊
from cryptography.hazmat.primitives.asymmetric import rsa

# 生成一對公鑰和私鑰，長度為2048位
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
public_key = private_key.public_key()
print("私鑰:", private_key)
print("公鑰:", public_key)

# 定義一個明文字符串
plaintext = "Hello, world!"

# 使用公鑰對明文進行加密，得到一個字節串類型的密文
ciphertext = public_key.encrypt(plaintext.encode(), rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))
print("密文:", ciphertext)

# 使用私鑰對密文進行解密，得到一個字節串類型的明文
decrypted = private_key.decrypt(ciphertext, rsa.OAEP(mgf=rsa.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))
print("解密后的明文:", decrypted.decode())

輸出結果：

私鑰: <cryptography.hazmat.backends.openssl.rsa._RSAPrivateKey object at 0x7f9a6a0f4d90>
公鑰: <cryptography.hazmat.backends.openssl.rsa._RSAPublicKey object at 0x7f9a6a0f4d60>
密文: b'x8bx9ex1ex1bx8fx9dx1ex8bx9cx9fx1fx8bx9dx1ex8bx9cx9fx1fx8bx9dx1ex8bx9cx9fx1fx8bx9dx1ex8bx9cx9fx1fxb3xe2xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xe3xc5xd2xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xf7xf6xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xb4xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0xa0'
解密后的明文: Hello, world!

2. RAS 封裝：

class Rsa:
 def __init__(self, st: str):
  self.st = st

 # rsa加密
 def rsa_encrypt(self):
  # 生成公鑰、私鑰
  (pubkey, privkey) = rsa.newkeys(1024)
  print("公鑰: ", pubkey)
  print("私鑰: ", privkey)
  # 明文編碼格式
  content = self.st.encode('utf-8')
  # 公鑰加密
  crypto = rsa.encrypt(content, pubkey)
  # # 一般加密的密文會以base64編碼的方式輸出
  b_res = base64.b64encode(crypto).decode()
  return b_res, privkey

 # rsa解密
 def rsa_decrypt(self, pk):
  # 私鑰解密
  st = base64.b64decode(self.st.encode())
  content = rsa.decrypt(st, pk)
  con = content.decode('utf-8')

  return con