devbox
在线问答5
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python加密与解密(一文搞定)

作者：在线问答5 | 2024-08-09 01:24:57

赞

踩

python加密与解密

前言

据记载，公元前400年，古希腊人发明了置换密码。1881年世界上的第一个电话

保密专利出现。在第二次世界大战期间，德国军方启用“恩尼格玛”密码机，

密码学在战争中起着非常重要的作用。

随着信息化和数字化社会的发展，人们对信息安全和保密的重要性认识不断提高，

于是在1997年，美国国家标准局公布实施了“美国数据加密标准（DES）”，

民间力量开始全面介入密码学的研究和应用中，采用的加密算法有DES、RSA、SHA等。

随着对加密强度需求的不断提高，近期又出现了AES、ECC等。

使用密码学可以达到以下目的：

保密性：防止用户的标识或数据被读取。

数据完整性：防止数据被更改。

身份验证：确保数据发自特定的一方。

加密算法分类

对称加密算法：

对称加密采用了对称密码编码技术，它的特点是文件加密和解密使用相同的密钥

发送方和接收方需要持有同一把密钥，发送消息和接收消息均使用该密钥。

相对于非对称加密，对称加密具有更高的加解密速度，但双方都需要事先知道密钥，密钥在传输过程中可能会被窃取，因此安全性没有非对称加密高。

常见的对称加密算法：DES，AES，3DES等等

非对称加密算法：

文件加密需要公开密钥（publickey）和私有密钥（privatekey）。

接收方在发送消息前需要事先生成公钥和私钥，然后将公钥发送给发送方。发送放收到公钥后，将待发送数据用公钥加密，发送给接收方。接收到收到数据后，用私钥解密。

在这个过程中，公钥负责加密，私钥负责解密，数据在传输过程中即使被截获，攻击者由于没有私钥，因此也无法破解。

非对称加密算法的加解密速度低于对称加密算法，但是安全性更高。

非对称加密算法：RSA、DSA、ECC等算法

消息摘要算法：

消息摘要算法可以验证信息是否被篡改。

在数据发送前，首先使用消息摘要算法生成该数据的签名，然后签名和数据一同发送给接收者。

接收者收到数据后，对收到的数据采用消息摘要算法获得签名，最后比较签名是否一致，以此来判断数据在传输过程中是否发生修改。

Python加密库

PyCryptodome是PyCrypto的一个分支。基于PyCrypto2.6.1

  • 1

pip install PyCryptodome

DES加密

全称为Data EncryptionStandard，即数据加密标准，是一种使用密钥加密的块算法

入口参数有三个：Key、Data、Mode

Key为7个字节共56位，是DES算法的工作密钥；

Data为8个字节64位，是要被加密或被解密的数据；

Mode为DES的工作方式,有两种:加密或解密

3DES（即Triple DES）是DES向AES过渡的加密算法，

使用两个密钥，执行三次DES算法，

加密的过程是加密-解密-加密

解密的过程是解密-加密-解密

import uuid
from Crypto.Cipher import DES
from Crypto.Util.Padding import pad, unpad


def get_key(len=8):
    """获取指定位数的动态密钥
    """
    key = str(uuid.uuid4()).replace('-', '')[4:4+len].upper()
    return key.encode('utf-8')

class My_DES_ECB():
    def __init__(self, key):
        # 密钥必须为8位
        self.key = key
        self.mode = DES.MODE_ECB
        self.cryptor = DES.new(self.key, self.mode)

    def encrypt(self, plain_text):
        encrypted_text = self.cryptor.encrypt(pad(plain_text.encode('utf-8'), DES.block_size))
        return encrypted_text

    def decrypt(self, encrypted_text):
        plain_text = self.cryptor.decrypt(encrypted_text)
        plain_text = unpad(plain_text, DES.block_size).decode()
        return plain_text


if __name__ == '__main__':
    key = get_key()
    pc = My_DES_ECB(key)  # 初始化密钥
    e = pc.encrypt("0123456789ABCDEF")
    d = pc.decrypt(e)
    print(e, d)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

输出

b’\xddW\xf6A\xf4Pa\xe1\xba\xbdih\x16\xbf{7N\x16\x1e\xc3}\xab\xc6\xb9’ 0123456789ABCDEF中国

MODE_ECB = 1
MODE_CBC = 2
MODE_CFB = 3
MODE_OFB = 5
MODE_CTR = 6
MODE_OPENPGP = 7
MODE_EAX = 9

# Size of a data block (in bytes)
block_size = 8
# Size of a key (in bytes)
key_size = 8

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

AES加密

高级加密标准（英语：Advanced EncryptionStandard，缩写：AES），这个标准用来替代原先的DES

AES的区块长度固定为128 比特，密钥长度则可以是128，192或256比特（16、24和32字节）

大致步骤如下：

1、密钥扩展（KeyExpansion），

2、初始轮（Initial Round），

3、重复轮（Rounds），每一轮又包括：SubBytes、ShiftRows、MixColumns、AddRoundKey，

4、最终轮（Final Round），最终轮没有MixColumns。

import uuid
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad


def get_key(len=16):
    """获取指定位数的动态密钥
    """
    key = str(uuid.uuid4()).replace('-', '')[0:len].upper()
    return key.encode()

class My_AES_ECB():
    def __init__(self, key):
        # 密钥必须为8位
        self.key = key
        self.mode = AES.MODE_ECB
        self.cryptor = AES.new(self.key, self.mode)

    def encrypt(self, plain_text):
        encrypted_text = self.cryptor.encrypt(pad(plain_text.encode('utf-8'), AES.block_size))
        return encrypted_text

    def decrypt(self, encrypted_text):
        plain_text = self.cryptor.decrypt(encrypted_text)
        plain_text = unpad(plain_text, AES.block_size).decode()
        return plain_text


if __name__ == '__main__':
    key = get_key()
    pc = My_AES_ECB(key)  # 初始化密钥
    e = pc.encrypt("0123456789ABCDEF中国")
    d = pc.decrypt(e)
    print(e, d)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

IV is not meaningful for the ECB mode

IV length (it must be 16 bytes long) for the CBC mode

decrypt() cannot be called after encrypt() for the CBC mode

import uuid
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad


def get_key(len=16):
    """获取指定位数的动态密钥
    """
    key = str(uuid.uuid4()).replace('-', '')[0:len].upper()
    return key.encode()

class My_AES_CBC():
    def __init__(self, key, iv):
        # 密钥必须为8位
        self.key = key
        self.mode = AES.MODE_CBC
        self.cryptor = AES.new(self.key, self.mode, iv)

    def encrypt(self, plain_text):
        encrypted_text = self.cryptor.encrypt(pad(plain_text.encode('utf-8'), AES.block_size))
        return encrypted_text

    def decrypt(self, encrypted_text):
        plain_text = self.cryptor.decrypt(encrypted_text)
        plain_text = unpad(plain_text, AES.block_size).decode()
        return plain_text


if __name__ == '__main__':
    key = get_key()
    e = My_AES_CBC(key, iv='1234567890123456'.encode('utf-8')).encrypt("0123456789ABCDEF中国")
    d = My_AES_CBC(key, iv='1234567890123456'.encode('utf-8')).decrypt(e)
    print(e, d)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
MODE_ECB = 1
MODE_CBC = 2
MODE_CFB = 3
MODE_OFB = 5
MODE_CTR = 6
MODE_OPENPGP = 7
MODE_CCM = 8
MODE_EAX = 9
MODE_SIV = 10
MODE_GCM = 11
MODE_OCB = 12

# Size of a data block (in bytes)
block_size = 16
# Size of a key (in bytes)
key_size = (16, 24, 32)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

PHP加解密

function Gen_aeskeyInfo(){
mt_srand((double)microtime()*10000);//optional for php 4.2.0 and up.
$charid = strtoupper(md5(uniqid(rand(), true)));
$uuid = substr($charid, 4, 16);
return $uuid;
}

function my_encode_string($privateKey, $text, $iv){
if (strlen($text)<16)
{
return "";
}
$encrypted = mcrypt_encrypt(MCRYPT_RIJNDAEL_128, $privateKey, $text, MCRYPT_MODE_CBC, $iv);
$encode_body = base64_encode($encrypted);
return $encode_body;
}

function my_decode_string($privateKey, $encryptstr, $iv){
$encryptedData = base64_decode($encryptstr);
$decrypted = mcrypt_decrypt(MCRYPT_RIJNDAEL_128, $privateKey,$encryptedData, MCRYPT_MODE_CBC, $iv);
return rtrim($decrypted, "\0");
}

// $privateKey = Gen_aeskeyInfo();
$privateKey = '5BD308AC0862393D';
$iv = '1234567890123456';
$text = '{"code":"qimen_store","type":"0","end_time":2147483647}';
$encryptstr = my_encode_string($privateKey, $text, $iv);
echo $encryptstr;
$text = my_decode_string($privateKey, $encryptstr, $iv);
echo "\n";
echo $text;

 

输出：

EHJel3udmy47ZpMGgFwYyUyp8JfCf8zoKdU+W5vIrQDZR4fTShyo1N3NtHKWbvH8+BL4TasNklnz9HlMjZnhDA==
{"code":"qimen_store","type":"0","end_time":2147483647}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

转化为python

import base64
from Crypto.Cipher import AES


class AES_CBC(object):
    def __init__(self, key, iv):
        self.key = key
        self.iv = iv.encode('utf-8')
        self.MODE = AES.MODE_CBC
        self.cryptor = AES.new(self.add_to_16(self.key), self.MODE, self.iv)

    def add_to_16(self, value):
        # 中文gbk时占2个字节，utf-8占3个字节
        value = value.encode('gbk')
        while len(value) % 16 != 0:
            value += '\0'.encode()
        return value

    def encrypt(self, plaintext):
        encrypted_text = self.cryptor.encrypt(self.add_to_16(plaintext))
        encrypted_text = str(base64.encodebytes(encrypted_text), encoding='utf-8').replace('\n', '')

        return encrypted_text

    def decrypt(self, ciphertext):
        # 优先逆向解密base64成bytes
        base64_decrypted = base64.decodebytes(ciphertext.encode())
        decrypted_text = self.cryptor.decrypt(base64_decrypted).decode('gbk')
        decrypted_code = decrypted_text.rstrip('\0')
        return decrypted_code

    @staticmethod
    def Gen_aeskeyInfo():
        import uuid

        r_uuid = str(uuid.uuid4()).replace('-', '')[4:20]
        print(r_uuid)


if __name__ == "__main__":
    # print(len('中'.encode('gbk')))
    # key = AES_CBC.Gen_aeskeyInfo()
    key = '5BD308AC0862393D'
    iv = '1234567890123456'
    text = '{"code":"qimen_store","type":"0","end_time":2147483647}'
    enc = AES_CBC(key, iv).encrypt(text)
    print(enc)
    text = AES_CBC(key, iv).decrypt(enc)
    print(text)


输出
EHJel3udmy47ZpMGgFwYyUyp8JfCf8zoKdU+W5vIrQDZR4fTShyo1N3NtHKWbvH8+BL4TasNklnz9HlMjZnhDA==
{"code":"qimen_store","type":"0","end_time":2147483647}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

RSA加密

公钥加密算法，一种非对称密码算法

公钥加密，私钥解密

3个参数：

rsa_n， rsa_e，message

rsa_n, rsa_e 用于生成公钥

message： 需要加密的消息

pip install rsa

  • 1
import rsa
from binascii import b2a_hex, a2b_hex


class rsacrypt():
    def __init__(self, pubkey, prikey):
        self.pubkey = pubkey
        self.prikey = prikey

    def encrypt(self, text):
        self.ciphertext = rsa.encrypt(text.encode(), self.pubkey)
        # 因为rsa加密时候得到的字符串不一定是ascii字符集的，输出到终端或者保存时候可能存在问题
        # 所以这里统一把加密后的字符串转化为16进制字符串
        return b2a_hex(self.ciphertext)

    def decrypt(self, text):
        decrypt_text = rsa.decrypt(a2b_hex(text), prikey)
        return decrypt_text.decode()


if __name__ == '__main__':
    pubkey, prikey = rsa.newkeys(256)
    rs_obj = rsacrypt(pubkey,prikey)
    text='hello中国'
    ency_text = rs_obj.encrypt(text)
    print(ency_text)
    print(rs_obj.decrypt(ency_text))
    print(pubkey)
    print(prikey)

"""
b'0be7e588fd8d093de48e1ff16f177273d771e0eb6b475458e31b879aebef18f6'
hello中国
PublicKey(73203632342415782735861635389738854293696902283956451011523986747143440837753, 65537)
PrivateKey(73203632342415782735861635389738854293696902283956451011523986747143440837753, 65537, 56404226961792114085368646753370507079134793768842910110408058154189894119761, 55914002491444170148907949791677664855437, 1309218247318589494605835772663699869)

"""

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

base64

import base64

plain_text = 'hello中国'
encrypt = str(base64.encodebytes(plain_text.encode()), encoding='utf-8').replace('\n', '')
print(encrypt)
plain_text = str(base64.decodebytes(encrypt.encode(encoding='utf-8')), encoding='utf-8')
print(plain_text)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

md5

import hashlib

def md5(str):
    md = hashlib.md5()
    md.update(str.encode(encoding='UTF-8'))
    return md.hexdigest().upper()

if __name__ == '__main__':
    s = 'hello中国'
    s_ = md5(s)
    print(s_)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

读者福利：知道你可能对Python感兴趣，便准备了这套python学习资料

对于0基础小白入门：

如果你是零基础小白，想快速入门Python是可以考虑的。

一方面是学习时间相对较短，学习内容更全面更集中。
二方面是可以找到适合自己的学习方案

包括：Python激活码+安装包、Python web开发，Python爬虫，Python数据分析，人工智能、机器学习等学习教程。带你从零基础系统性的学好Python！

零基础Python学习资源介绍

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/在线问答5/article/detail/950732

推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。