[Zusammenfassung gängiger Verschlüsselungsmethoden] Python implementiert die Verschlüsselung von drei Elementen

Normalerweise müssen wir häufig Daten übertragen, und die Übertragung einiger sensibler Informationen muss verschlüsselt werden, um Datenlecks zu verhindern.

Beispielsweise die Übermittlung von Name, Mobiltelefonnummer, Ausweisnummer (die drei Elemente genannt) usw.

Jetzt wollen wir die Drei-Parteien-Daten testen. Wir müssen der anderen Partei die drei Elemente zur Verfügung stellen, und die andere Partei gibt uns die entsprechenden Etiketten zurück.

Zu diesem Zeitpunkt müssen die drei Elemente verschlüsselt werden, und verschiedene Drittorganisationen haben unterschiedliche Anforderungen an die Verschlüsselungsmethoden, und die Daten müssen gemäß den Anforderungen der Organisation bereitgestellt werden.

In diesem Artikel werden die gängigen Verschlüsselungsmethoden für Datentests von Drittanbietern erläutert. Ganz gleich, welche Methode das Unternehmen benötigt, sie kann schnell implementiert werden.

Inhalt dieses Artikels

1. Gängige Verschlüsselungsmethoden in Python

2. Installationspaket

3. Implementierung verschiedener Verschlüsselungsmethoden

   3.1 Drei-Faktor-Daten generieren

   3.2 MD5-Verschlüsselung von drei Elementen

   3.3 SHA256-Verschlüsselung von drei Elementen

   3.4 AES-Verschlüsselung von drei Elementen

1. Gängige Verschlüsselungsmethoden in Python

Zu den gängigen Verschlüsselungsmethoden in Python gehören die folgenden:

1. Hash-Verschlüsselung: wie MD5, SHA1, SHA256 usw. Diese Verschlüsselungsmethode wandelt Rohdaten (normalerweise eine Zeichenfolge) in einen Hashwert fester Länge um. Dies ist ein einseitiger Prozess, d. h. sobald die Daten gehasht wurden, können sie nicht mehr in die Originaldaten „entschlüsselt“ werden.

2. Symmetrische Verschlüsselung : wie AES, DES usw. Diese Verschlüsselungsmethode verwendet denselben Schlüssel für die Verschlüsselung und Entschlüsselung.

3. Asymmetrische Verschlüsselung : wie RSA, DSA usw. Diese Verschlüsselungsmethode verwendet ein Schlüsselpaar, einen für die Verschlüsselung und einen für die Entschlüsselung. Normalerweise handelt es sich bei dem einen um einen öffentlichen Schlüssel, der öffentlich geteilt werden kann, und beim anderen um einen privaten Schlüssel, der geheim gehalten werden muss.

4. Base64-Kodierung : Streng genommen ist Base64 kein Verschlüsselungsalgorithmus, sondern eher eine Kodierungsmethode. Da es jedoch Informationen in eine Folge scheinbar zufälliger Zeichen umwandeln kann, wird es manchmal zur einfachen „Verschlüsselung“ verwendet.

In diesem Artikel wird die MD5-, SHA256- und AES-Verschlüsselung vorgestellt, die häufig bei Datentests von Drittanbietern verwendet wird.

2. Installationspaket

Für die AES-Verschlüsselung muss das Pycryptodome-Paket installiert sein. Öffnen Sie cmd und die Installationsanweisung lautet wie folgt:

pip install pycryptodome  -i https://pypi.tuna.tsinghua.edu.cn/simple

Bei erfolgreicher Installation wird Folgendes angezeigt:

3. Implementierung verschiedener Verschlüsselungsmethoden

1Generieren Sie Drei-Faktor-Daten

首先生成三要素数据(纯虚构)进行测试，具体代码如下：  

Pandas als PD importieren date = pd.DataFrame([['Yang Mi', '43052219980512', '13166456975'], ['Yang Zi', '43052219940413', '13166456976'], ['Liu Shiwen', '43052220010318' , ' 13166456977']], columns=['Name', 'ID-Nummer', 'Mobiltelefonnummer'])``Datum

habe die Antwort bekommen:

2 MD5-Verschlüsselung von drei Elementen

接着对三要素进行MD5加密，代码如下：

Hashlib importieren als hb method = 'md5' column_list = ['姓名', '身份证号', '手机号']df = date.copy() for i in column_list:` `if method == 'md5':` `df[i + '_MD5'] = df[i].map(lambda x: hb.md5(str(x).encode('utf-8')).hexdigest())` `if method == 'sha256':` `df[i + '_SHA256'] = df[i].map(lambda x:hb.sha256(str(x).encode('utf-8')).hexdigest())df

其中，method中填入想加密的方式，选md5。

column\_list中填入数据框中想用method方法加密的列。

得到结果：

![](https://mmbiz.qpic.cn/mmbiz_png/A1m5qEMvXvJI7Xq2o5R6fAB8PDnWQhzJ2dTibrwIlNmNFGQ1f919LoQRa8ISBricjhJwpK8RFEz0jQzekphLiaRZw/640?wx_fmt=png)

从结果知数据框中新增了对应加密的列。

**********************3**   **对三要素进行SHA256加密**********************

Führen Sie dann die SHA256-Verschlüsselung für die drei Elemente durch. Der Code lautet wie folgt:

import hashlib as hb``   ``method = 'sha256'``column_list = ['姓名', '身份证号', '手机号']``df = date.copy()``for i in column_list:`    `if method == 'md5':`        `df[i + '_MD5'] = df[i].map(lambda x: hb.md5(str(x).encode('utf-8')).hexdigest())`    `if method == 'sha256':`        `df[i + '_SHA256'] = df[i].map(lambda x:hb.sha256(str(x).encode('utf-8')).hexdigest())``df

Geben Sie die Methode ein, die Sie verschlüsseln möchten, und wählen Sie sha256 aus.

Füllen Sie „column_list“ mit den Spalten im Datenrahmen, die Sie mit der Methode „method“ verschlüsseln möchten.

habe die Antwort bekommen:

Aus den Ergebnissen wissen wir, dass dem Datenrahmen eine neue Spalte hinzugefügt wurde, die der Verschlüsselung entspricht, und dass die Datenlänge länger ist als bei der MD5-Verschlüsselung.

Laut Datenstatistik beträgt die Länge der MD5-Verschlüsselung 32 und die Länge der SHA256-Verschlüsselung 64.

**********************4**   **对三要素进行AES加密**********************

Die am häufigsten verwendeten Modi für die AES-Verschlüsselung sind der ECB-Modus und der CBC-Modus. Der Unterschied zwischen den beiden besteht darin, dass ECB im Gegensatz zu CBC keinen iv-Offset erfordert.

1. Verschlüsselung im ECB-Modus, der Code lautet wie folgt:

from Crypto.Cipher import AES``   ``password = b'1234567812345678'` `text = b'abcdefghijklmnop'``aes = AES.new(password, AES.MODE_ECB)` `en_text = aes.encrypt(text)` `print("密文：",en_text)` `den_text = aes.decrypt(en_text)` `print("明文：",den_text)

Passwort: Schlüssel, b bedeutet, dass das Passwort in den Byte-Typ konvertiert wird.

text: Zu verschlüsselnder Inhalt.

aes: Erstellen Sie ein AES-Objekt und geben Sie den Verschlüsselungsmodus als ECB an.

aes.encrypt: Text verschlüsseln.

aes.decrypt: Verschlüsselte Inhalte entschlüsseln.

habe die Antwort bekommen:

密文：b"^\x14\xf4nfb)\x10\xbf\xe9\xa9\xec'r\x85&"``明文：b'abcdefghijklmnop'

这里有两个需要注意的点，大家可以自行测试。  

**注1：**密钥必须为16字节或16字节倍数的字节型数据。

**注2：**明文必须为16字节或者16字节倍数的字节型数据，如果不够16字节需要进行补全。

2.CBC-Modus-Verschlüsselung, der Code lautet wie folgt:

aus Crypto.Cipher importieren AES- Passwort = b'1234567812345678' iv = b'1234567812345678' text = b'abcdefghijklmnop' aes = AES.new(password, AES.MODE_CBC, iv) en_text = aes.encrypt(text) print(“密文：“,en_text) aes = AES.new(password,AES.MODE_CBC, iv) den_text = aes.decrypt(en_text)``print(“明文：“,den_text)

password：密钥，b表示转换密码为bytes类型。

iv：偏移量。

text：需加密的内容。

aes.encrypt：对text进行加密。  

aes.decrypt：对加密内容进行解密。  

得到结果：

Verschlüsselter Text: b't\xe6\xbfy\xef\xd7\x83\x11G\x95\x9d_\xcd\xab\xc7\xf8'' Klartext: b'abcdefghijklmnop'

**3.对三要素进行aes加密**

首先定义加密函数，代码如下：

from Crypto.Cipher import AES``import base64``import binascii``   ``# 数据类``class MData():`    `def __init__(self, data = b"",characterSet='utf-8'):`        `# data肯定为bytes`        `self.data = data`        `self.characterSet = characterSet`  `    def saveData(self,FileName):`        `with open(FileName,'wb') as f:`            `f.write(self.data)``   `    `def fromString(self,data):`        `self.data = data.encode(self.characterSet)`        `return self.data``   `    `def fromBase64(self,data):`        `self.data = base64.b64decode(data.encode(self.characterSet))`        `return self.data``   `    `def fromHexStr(self,data):`        `self.data = binascii.a2b_hex(data)`        `return self.data``   `    `def toString(self):`        `return self.data.decode(self.characterSet)``   `    `def toBase64(self):`        `return base64.b64encode(self.data).decode()``   `    `def toHexStr(self):`        `return binascii.b2a_hex(self.data).decode()``   `    `def toBytes(self):`        `return self.data``   `    `def __str__(self):`        `try:`            `return self.toString()`        `except Exception:`            `return self.toBase64()``   ``   ``### 封装类``class AEScryptor():`    `def __init__(self,key,mode,iv = '',paddingMode= "NoPadding",characterSet ="utf-8"):`        `'''`        `构建一个AES对象`        `key: 秘钥，字节型数据`        `mode: 使用模式，只提供两种，AES.MODE_CBC, AES.MODE_ECB`        `iv：iv偏移量，字节型数据`        `paddingMode: 填充模式，默认为NoPadding, 可选NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding`        `characterSet: 字符集编码`        `'''`        `self.key = key`        `self.mode = mode`        `self.iv = iv`        `self.characterSet = characterSet`        `self.paddingMode = paddingMode`        `self.data = ""``   `    `def __ZeroPadding(self,data):`        `data += b'\x00'`        `while len(data) % 16 != 0:`            `data += b'\x00'`        `return data``   `    `def __StripZeroPadding(self,data):`        `data = data[:-1]`        `while len(data) % 16 != 0:`            `data = data.rstrip(b'\x00')`            `if data[-1] != b"\x00":`                `break`        `return data``   `    `def __PKCS5_7Padding(self,data):`        `needSize = 16-len(data) % 16`        `if needSize == 0:`            `needSize = 16`        `return data + needSize.to_bytes(1,'little')*needSize``   `    `def __StripPKCS5_7Padding(self,data):`        `paddingSize = data[-1]`        `return data.rstrip(paddingSize.to_bytes(1,'little'))``   `    `def __paddingData(self,data):`        `if self.paddingMode == "NoPadding":`            `if len(data) % 16 == 0:`                `return data`            `else:`                `return self.__ZeroPadding(data)`        `elif self.paddingMode == "ZeroPadding":`            `return self.__ZeroPadding(data)`        `elif self.paddingMode == "PKCS5Padding" or self.paddingMode == "PKCS7Padding":`            `return self.__PKCS5_7Padding(data)`        `else:`            `print("不支持Padding")``   `    `def __stripPaddingData(self,data):`        `if self.paddingMode == "NoPadding":`            `return self.__StripZeroPadding(data)`        `elif self.paddingMode == "ZeroPadding":`            `return self.__StripZeroPadding(data)``   `        `elif self.paddingMode == "PKCS5Padding" or self.paddingMode == "PKCS7Padding":`            `return self.__StripPKCS5_7Padding(data)`        `else:`            `print("不支持Padding")``   `    `def setCharacterSet(self,characterSet):`        `'''`        `设置字符集编码`        `characterSet: 字符集编码`        `'''`        `self.characterSet = characterSet``   `    `def setPaddingMode(self,mode):`        `'''`        `设置填充模式`        `mode: 可选NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding`        `'''`        `self.paddingMode = mode``   `    `def decryptFromBase64(self,entext):`        `'''`        `从base64编码字符串编码进行AES解密`        `entext: 数据类型str`        `'''`        `mData = MData(characterSet=self.characterSet)`        `self.data = mData.fromBase64(entext)`        `return self.__decrypt()``   `    `def decryptFromHexStr(self,entext):`        `'''`        `从hexstr编码字符串编码进行AES解密`        `entext: 数据类型str`        `'''`        `mData = MData(characterSet=self.characterSet)`        `self.data = mData.fromHexStr(entext)`        `return self.__decrypt()``   `    `def decryptFromString(self,entext):`        `'''`        `从字符串进行AES解密`        `entext: 数据类型str`        `'''`        `mData = MData(characterSet=self.characterSet)`        `self.data = mData.fromString(entext)`        `return self.__decrypt()``   `    `def decryptFromBytes(self,entext):`        `'''`        `从二进制进行AES解密`        `entext: 数据类型bytes`        `'''`        `self.data = entext`        `return self.__decrypt()``   `    `def encryptFromString(self,data):`        `'''`        `对字符串进行AES加密`        `data: 待加密字符串，数据类型为str`        `'''`        `self.data = data.encode(self.characterSet)`        `return self.__encrypt()``   `    `def __encrypt(self):`        `if self.mode == AES.MODE_CBC:`            `aes = AES.new(self.key,self.mode,self.iv)``        elif self.mode == AES.MODE_ECB:`            `aes = AES.new(self.key,self.mode)``        else:`            `print("不支持这种模式")``return`           `   `        `data = self.__paddingData(self.data)`        `enData = aes.encrypt(data)`        `return MData(enData)``   `    `def __decrypt(self):`        `if self.mode == AES.MODE_CBC:`            `aes = AES.new(self.key,self.mode,self.iv)``        elif self.mode == AES.MODE_ECB:`            `aes = AES.new(self.key,self.mode)``        else:`            `print("不支持这种模式")``             return            ``        data = aes.decrypt(self.data)`        `mData = MData(self.__stripPaddingData(data),characterSet=self.characterSet)`        `return mData

Rufen Sie dann die Funktion auf, um die drei Elemente zu verschlüsseln. Der Code lautet wie folgt:

password = b"1234567812345678"``iv = b'1111111122222222'` `aes = AEScryptor(password, AES.MODE_CBC, iv, paddingMode= "ZeroPadding", characterSet='utf-8')``df = date.copy()``def str_ase(wd):`    `wd = wd`    `rData = aes.encryptFromString(wd)`    `return rData.toBase64()``df['姓名_ase'] = df['姓名'].apply(str_ase)``df['身份证号_ase'] = df['身份证号'].apply(str_ase)``df['手机号_ase'] = df['手机号'].apply(str_ase)``df

password：密钥，可自行更改。

iv：偏移量。

str\_aes：对字符进行ase加密的函数。

得到结果：

![](https://mmbiz.qpic.cn/mmbiz_png/A1m5qEMvXvJI7Xq2o5R6fAB8PDnWQhzJUoeB5icmzulMyMWrZCR04LOfXKlq6wdGdtIhp2NXC5kgFqVXjKbLLKg/640?wx_fmt=png)

可以发现和MD5、SHA256一样，都在后面增加了aes加密的列。

最后测试对aes加密的姓名进行解密，看是否和明文一致，代码如下：

rData = aes.decryptFromBase64(df['Name_ase'][0])``print("Klartext:",rData)

得到结果：  

Klartext: Yang Mi

可以发现结果是一致的。