点个赞留个关注吧！！
《《请先安装这几个模块》》
# Python 3.11.0
import hashlib
import binascii
import google_crc32c
import zlib
import base64
import urllib.parse
import opencc
import time
from Crypto.Cipher import AES
from Crypto.Cipher import DES
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5
import random
# 安装方法如下
# 打开cmd 输入如下代码回车即可
pip install hashlib
pip install binascii
pip install google_crc32c
pip install zlib
pip install base64
pip install urllib.parse
pip install opencc
# 安装 Crypto.Cipher
pip install pycryptodome
一、加密(不含解密)📰
1、MD2
# MD2加密
# 此md2加密从 bejson.com 网站逆向解析出的代码，无需模块
def md2_encrypt(o):
# 定义常量
d = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
i = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
n = [41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6, 19, 98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188, 76, 130, 202, 30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24, 138, 23, 229, 18, 190, 78, 196, 214, 218, 158, 222, 73, 160, 251, 245, 142, 187, 47, 238, 122, 169, 104, 121, 145, 21, 178, 7, 63, 148, 194, 16, 137, 11, 34, 95, 33, 128, 127, 93, 154, 90, 144, 50, 39, 53, 62, 204, 231, 191, 247, 151, 3, 255, 25, 48, 179, 72, 165, 181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56, 210, 150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157, 112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27, 96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15, 85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197, 234, 38, 44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65, 129, 77, 82, 106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123, 8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99, 232, 109, 233, 203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88, 208, 228, 166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237, 31, 26, 219, 153, 141, 51, 159, 17, 131, 20]
s = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
t = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
# 定义
a = 0
b = 0
l = 1
m = len(o)
e = 0
r = 0
f = 0
c = 0
p = 0
u = 0
_ = 0
v = 0
while 1 == l:
d[0] = d[16]
d[1] = d[17]
d[2] = d[18]
d[16] = d[17] = d[18] = d[3] = d[4] = d[5] = d[6] = d[7] = d[8] = d[9] = d[10] = d[11] = d[12] = d[13] = d[14] = \
d[15] = 0
r = v
while m > _ and 16 > r:
e = ord(o[_]) # javascript中的charCodeAt函数，ord和charCodeAt暂未实现同一【不可加密表情】
if 128 > e:
d[r] = e
r += 1
else:
if 2048 > e:
d[r] = 192 | e >> 6
r += 1
d[r] = 128 | 63 & e
r += 1
else:
if 55296 > e or e >= 57344:
d[r] = 224 | e >> 12
r += 1
d[r] = 128 | e >> 6 & 63
r += 1
d[r] = 128 | 63 & e
r += 1
else:
_ += 1
65536 + ((1023 & e) << 10 | 1023 & ord(o[_]))
d[r] = 240 | e >> 18
r += 1
d[r] = 128 | e >> 12 & 63
r += 1
d[r] = 128 | e >> 6 & 63
r += 1
d[r] = 128 | 63 & e
r += 1
_ += 1
b += r - v
v = r - 16
if _ == m and 16 > r:
l = 2
p = 16 - (15 & b)
while 16 > r:
d[r] = p
r += 1
r = 0
while 16 > r:
s[r] ^= n[d[r] ^ a]
a = s[r]
r += 1
r = 0
while l > r:
if 0 == r:
u = d
else:
u = s
i[16] = u[0]
i[32] = i[16] ^ i[0]
i[17] = u[1]
i[33] = i[17] ^ i[1]
i[18] = u[2]
i[34] = i[18] ^ i[2]
i[19] = u[3]
i[35] = i[19] ^ i[3]
i[20] = u[4]
i[36] = i[20] ^ i[4]
i[21] = u[5]
i[37] = i[21] ^ i[5]
i[22] = u[6]
i[38] = i[22] ^ i[6]
i[23] = u[7]
i[39] = i[23] ^ i[7]
i[24] = u[8]
i[40] = i[24] ^ i[8]
i[25] = u[9]
i[41] = i[25] ^ i[9]
i[26] = u[10]
i[42] = i[26] ^ i[10]
i[27] = u[11]
i[43] = i[27] ^ i[11]
i[28] = u[12]
i[44] = i[28] ^ i[12]
i[29] = u[13]
i[45] = i[29] ^ i[13]
i[30] = u[14]
i[46] = i[30] ^ i[14]
i[31] = u[15]
i[47] = i[31] ^ i[15]
p = 0
f = 0
while 18 > f:
c = 0
while 48 > c:
i[c] = p = i[c] ^ n[p]
c += 1
p = p + f & 255
f += 1
r += 1
r = 0
w = ""
while 16 > r:
w += t[i[r] >> 4 & 15] + t[15 & i[r]]
r += 1
return w
# 输入
print(md2_encrypt('1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM！@#￥%……&*（）——{}+：“》《~~》《？：你好大哥，点赞'))
# 输出：b3da79788744f12464d14364625c281d2、MD4
import hashlib
def md4_encrypt(string):
md4 = hashlib.new('md4')
md4.update(string.encode('utf-8'))
return md4.hexdigest()
# 输入
print(md4_encrypt("你好"))
# 输出：a7f1196539fd1f85f754ffd185b16e6e3、MD5
import hashlib
def md5_encrypt(string):
md5 = hashlib.md5()
md5.update(string.encode('utf-8'))
return md5.hexdigest()
# 输入
print(md5_encrypt("你好"))
# 输出：7eca689f0d3389d9dea66ae112e5cfd74、blake2b
import hashlib
def blake2b_encrypt(string):
blake2b = hashlib.blake2b()
blake2b.update(string.encode('utf-8'))
return blake2b.hexdigest()
# 输入
print(blake2b_encrypt("你好"))
# 输出：8eadb63a9f823c4e8eac400247995c69ab714dd54cc33bbf0583e269e3aa9077ad8c0069ffb2fec634a1dd913196c0e459f987a1e5d3c9997e9fd556b38604a45、blake2s
import hashlib
def blake2s_encrypt(string):
blake2s = hashlib.blake2s()
blake2s.update(string.encode('utf-8'))
return blake2s.hexdigest()
# 输入
print(blake2s_encrypt("你好"))
# 输出：b834cce099cfa370b999ebfa3bb8a6a87fa09b45a1a83d038d8957cbb88c98966、SHA1
import hashlib
def sha1_encrypt(string):
sha1 = hashlib.sha1()
sha1.update(string.encode('utf-8'))
return sha1.hexdigest()
# 输入
print(sha1_encrypt("你好"))
# 输出：440ee0853ad1e99f962b63e459ef992d7c2117227、SHA224
import hashlib
def sha224_encrypt(string):
sha224 = hashlib.sha224()
sha224.update(string.encode('utf-8'))
return sha224.hexdigest()
# 输入
print(sha224_encrypt("你好"))
# 输出：e91f006ed4e0882de2f6a3c96ec228a6a5c715f356d00091bce842b58、SHA256
import hashlib
def sha256_encrypt(string):
sha256 = hashlib.sha256()
sha256.update(string.encode('utf-8'))
return sha256.hexdigest()
# 输入
print(sha256_encrypt("你好"))
# 输出：670d9743542cae3ea7ebe36af56bd53648b0a1126162e78d81a32934a711302e9、SHA384
import hashlib
def sha384_encrypt(string):
sha384 = hashlib.sha384()
sha384.update(string.encode('utf-8'))
return sha384.hexdigest()
# 输入
print(sha384_encrypt("你好"))
# 输出：05f076c7d180e91d80a56d70b226fca01e2353554c315ac1e8caaaeca2ce0dc0d9d84e206a2bf1143a0ae1b9be9bcfa810、SHA512
import hashlib
def sha512_encrypt(string):
sha512 = hashlib.sha512()
sha512.update(string.encode('utf-8'))
return sha512.hexdigest()
# 输入
print(sha512_encrypt("你好"))
# 输出：5232181bc0d9888f5c9746e410b4740eb461706ba5dacfbc93587cecfc8d068bac7737e92870d6745b11a25e9cd78b55f4ffc706f73cfcae5345f1b53fb8f6b511、SHA3_224
import hashlib
def sha3_224_encrypt(string):
sha3_224 = hashlib.sha3_224()
sha3_224.update(string.encode('utf-8'))
return sha3_224.hexdigest()
# 输入
print(sha3_224_encrypt("你好"))
# 输出：d6e2200b43a6997075692b6dde5ca9f91cae1d15f72546d3c9a9d8c412、SHA3_256
import hashlib
def sha3_256_encrypt(string):
sha3_256 = hashlib.sha3_256()
sha3_256.update(string.encode('utf-8'))
return sha3_256.hexdigest()
# 输入
print(sha3_224_encrypt("你好"))
# 输出：0100e69a7157f3a814a3cf6895f4fccd6b610b9947224b2aaa7aa11dd0dca83313、SHA3_384
import hashlib
def sha3_384_encrypt(string):
sha3_384 = hashlib.sha3_384()
sha3_384.update(string.encode('utf-8'))
return sha3_384.hexdigest()
# 输入
print(sha3_384_encrypt("你好"))
# 输出：bdc0b2e622a1d79abae4cabbf86bd88192dead3b90c8332ac4bac08e9a2c06d5c685f46101ac0c14980849f39a7b0ebf14、SHA3_512
import hashlib
def sha3_512_encrypt(string):
sha3_512 = hashlib.sha3_512()
sha3_512.update(string.encode('utf-8'))
return sha3_512.hexdigest()
# 输入
print(sha3_512_encrypt("你好"))
# 输出：d673e4b36755b938359fa394cf920b4430a34f447ea5cb10485d9d46a7d6682eef6d7459b4dac9019d908e08a1e7aaab3accde4f59e862dbb99f906d85e5c66d15、shake_128
import hashlib
def shake_128_encrypt(data):
data = data.encode('utf-8')
shake_128 = hashlib.shake_128()
shake_128.update(data)
return shake_128.hexdigest(32)
# 输入
print(shake_128_encrypt("你好"))
# 输出：2c8206e6e29e0e3c9d64e9455629cd354548a15761d3bafcb941769ed464953816、shake_256
import hashlib
def shake_256_encrypt(data):
data = data.encode('utf-8')
shake_256 = hashlib.shake_256()
shake_256.update(data)
return shake_256.hexdigest(32)
# 输入
print(shake_256_encrypt("你好"))
# 输出：d13a972c4c06e0cbb67af0af4b1a92d296b709e36cccbeed30db6c9d2853cd1c17、crc32 十进制
import binascii
def crc32_10(data):
return binascii.crc32(data.encode()) & 0xffffffff
# 输入
print(crc32_10("你好"))
# 输出：135284128118、crc32 十六进制
import binascii
def crc32_16(data):
return hex(binascii.crc32(data.encode()) & 0xffffffff)
# 输入
print(crc32_16("你好"))
# 输出：0x50a2b84119、CRC32C十进制
import google_crc32c
def crc32c_10(data):
return google_crc32c.value(data.encode())
# 输入
print(crc32c_10("你好"))
# 输出：138394497220、CRC32C十六进制
import google_crc32c
def crc32c_16(data):
return hex(google_crc32c.value(data.encode()))
# 输入
print(crc32c_16("你好"))
# 输出：0x527d530c21、Adler32十进制
import zlib
def adler32_10(data):
return zlib.adler32(data.encode()) & 0xffffffff
# 输入
print(adler32_10("你好"))
# 输出：27295860122、Adler32十六进制
import zlib
def adler32_16(data):
return hex(zlib.adler32(data.encode()) & 0xffffffff)
# 输入
print(adler32_16("你好"))
# 输出：0x10450489二、加密&解密📅
1、IDEA 加密解密
# IDEA【加密算法】
def IDEA_encrypt(string, key): # string要加密的字符串 key只能为数字,5位数内
result = ''
for i in range(len(string)):
result += chr(ord(string[i]) + int(key))
return result
# 输入
print(IDEA_encrypt("你好",443322))
# 输出：# IDEA【解密算法】
def IDEA_decrypt(string, key): # string要加密的字符串 key只能为数字,5位数内
result = ''
for i in range(len(string)):
result += chr(ord(string[i]) - int(key))
return result
# 输入
print(IDEA_decrypt("",443322))
# 输出：你好2、ASCLL 加密解密
# ASCLL【加密】
def decrypt_ASCLL(string):
result = ""
for char in string:
result += chr(ord(char) + 1000)
return result
# 输入
print(decrypt_ASCLL('你好'))
# 输出：午嵥# ASCLL【解密】
def encrypt_ASCLL(string):
result = ""
for char in string:
result += chr(ord(char) - 1000)
return result
# 输入
print(encrypt_ASCLL('午嵥'))
# 输出：你好3、AES_ECB 加密解密
# AES 【ECB加密】
# AES 【加密】 加密模式(不可改)：ECB key(默认)：0000000000000000 填充模式(默认)：NoPadding 子集编码(默认)：UTF-8 字节(不可改)：128字节
from Crypto.Cipher import AES
import base64
def AES_ECB_encode(data,key=b'0000000000000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密内容【加密】
# key：密钥，长度为16字节或32字节
# paddingMode：填充模式，默认为NoPadding 可选【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：编码，默认为UTF-8 可选【UTF-8，UTF-16_LE，GBK】
'''
# 检测密钥的长度是否是16或32字节长度
if len(key) in [16,32]:
data = data.encode(characterSet)
AESS = AES.new(key, AES.MODE_ECB)
enData = ''
if paddingMode == 'NoPadding':
if len(data) % 16 == 0:
enData = AESS.encrypt(data) # AES加密
else:
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = AESS.encrypt(data) # AES加密
if paddingMode == 'ZeroPadding':
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = AESS.encrypt(data) # AES加密
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
needSize = 16 - len(data) % 16
if needSize == 0:
needSize = 16
data = data + needSize.to_bytes(1, 'little') * needSize
enData = AESS.encrypt(data) # AES加密
return base64.b64encode(enData).decode()
else:
return '密钥或iv字节长度错误！！！'
# 输入
print(AES_ECB_encode('你好 Abc',key=b'1234567890123456',paddingMode='PKCS5Padding'))
# 输出：3ZJEr/p5lexy81r+IRGGoQ==# AES 【ECB解密】
# AES 【解密】 加密模式(不可改)：ECB key(默认)：0000000000000000 填充模式(默认)：NoPadding 子集编码(默认)：UTF-8 字节(不可改)：128字节
from Crypto.Cipher import AES
import base64
def AES_ECB_decode(data,key=b'0000000000000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密内容【解密】
# key：密钥，长度为16字节或32字节
# paddingMode：填充模式，默认为NoPadding 可选【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：编码，默认为UTF-8 可选【UTF-8，UTF-16_LE，GBK】
'''
if len(key) in [16, 32]:
data = base64.b64decode(data.encode(characterSet))
data = AES.new(key, AES.MODE_ECB).decrypt(data)
if paddingMode in ['NoPadding','ZeroPadding']:
data = data[:-1]
while len(data) % 16 != 0:
data = data.rstrip(b'\x00')
if data[-1] != b"\x00":
break
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
paddingSize = data[-1]
data = data.rstrip(paddingSize.to_bytes(1, 'little'))
return data.decode(characterSet)
else:
return '密钥或iv字节长度错误！！！'
# 输入
print(AES_ECB_decode('3ZJEr/p5lexy81r+IRGGoQ==',key=b'1234567890123456',paddingMode='PKCS5Padding'))
# 输出：你好 Abc4、AES_CBC 加密解密
# AES 【CBC加密】
# AES 【加密】 加密模式(不可改)：CBC key/iv(默认)：0000000000000000 填充模式(默认)：NoPadding 子集编码(默认)：UTF-8 字节(不可改)：128字节
from Crypto.Cipher import AES
import base64
def AES_CBC_encode(data,key=b'0000000000000000',iv=b'0000000000000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密内容【加密】
# key：密钥，长度为16字节或32字节
# iv：偏移量，长度为16字节
# paddingMode：填充模式，默认为NoPadding 可选【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：编码，默认为UTF-8 可选【UTF-8，UTF-16_LE，GBK】
'''
# 检测密钥的长度是否是16或32字节长度，iv偏移量的字节长度是否是16字节
if (len(key) in [16,32]) and (len(iv) in [16]) == True:
data = data.encode(characterSet)
AESS = AES.new(key, AES.MODE_CBC, iv)
enData = ''
if paddingMode == 'NoPadding':
if len(data) % 16 == 0:
enData = AESS.encrypt(data) # AES加密
else:
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = AESS.encrypt(data) # AES加密
if paddingMode == 'ZeroPadding':
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = AESS.encrypt(data) # AES加密
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
needSize = 16 - len(data) % 16
if needSize == 0:
needSize = 16
data = data + needSize.to_bytes(1, 'little') * needSize
enData = AESS.encrypt(data) # AES加密
return base64.b64encode(enData).decode()
else:
return '密钥或iv字节长度错误！！！'
# 输入
print(AES_CBC_encode('你好 Abc',key=b'1234567890123456',paddingMode='PKCS5Padding'))
# 输出：VzrFG9/TsFTW+yup4/tr4g==# AES 【CBC解密】
# AES 【解密】 加密模式(不可改)：CBC key/iv(默认)：0000000000000000 填充模式(默认)：NoPadding 子集编码(默认)：UTF-8 字节(不可改)：128字节
from Crypto.Cipher import AES
import base64
def AES_CBC_decode(data,key=b'0000000000000000',iv=b'0000000000000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密内容【解密】
# key：密钥，长度为16字节或32字节
# iv：偏移量，长度为16字节
# paddingMode：填充模式，默认为NoPadding 可选【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：编码，默认为UTF-8 可选【UTF-8，UTF-16_LE，GBK】
'''
if (len(key) in [16, 32]) and (len(iv) in [16]) == True:
data = base64.b64decode(data.encode(characterSet))
data = AES.new(key, AES.MODE_CBC, iv).decrypt(data)
if paddingMode in ['NoPadding','ZeroPadding']:
data = data[:-1]
while len(data) % 16 != 0:
data = data.rstrip(b'\x00')
if data[-1] != b"\x00":
break
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
paddingSize = data[-1]
data = data.rstrip(paddingSize.to_bytes(1, 'little'))
return data.decode(characterSet)
else:
return '密钥或iv字节长度错误！！！'
# 输入
print(AES_CBC_decode('VzrFG9/TsFTW+yup4/tr4g==',key=b'1234567890123456',paddingMode='PKCS5Padding'))
# 输出：你好 Abc
5、AES_CFB 加密解密
# AES 【CFB加密】
# AES 【加密】 加密模式(不可改)：CFB key/iv(默认)：0000000000000000 块大小(bits)(默认)：16 填充模式(默认)：NoPadding 子集编码(默认)：UTF-8 字节(不可改)：128字节
from Crypto.Cipher import AES
import base64
def AES_CFB_encode(data,key=b'0000000000000000',iv=b'0000000000000000',segment_size=16,paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密内容【加密】
# key：密钥，长度为16字节或32字节
# iv：偏移量，长度为16字节
# segment_size：块大小(bits) 默认为 8 最小值为 8 最大值为128 只能是8的倍数，如：8，16，24，32，40，48，56，64...
# paddingMode：填充模式，默认为NoPadding 可选【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：编码，默认为UTF-8 可选【UTF-8，UTF-16_LE，GBK】
'''
# 检测密钥的长度是否是16或32字节长度
if (len(key) in [16,32]) and (len(iv) in [16]) == True:
data = data.encode(characterSet)
AESS = AES.new(key, AES.MODE_CFB,iv,segment_size=segment_size)
enData = ''
if paddingMode == 'NoPadding':
if len(data) % 2 == 0:
enData = AESS.encrypt(data) # AES加密
else:
if len(data) % 2 != 0:
data += b'\x00'
while len(data) % 2 != 0:
data += b'\x00'
data = data
enData = AESS.encrypt(data) # AES加密
if paddingMode == 'ZeroPadding':
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = AESS.encrypt(data) # AES加密
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
needSize = 16 - len(data) % 16
if needSize == 0:
needSize = 16
data = data + needSize.to_bytes(1, 'little') * needSize
enData = AESS.encrypt(data) # AES加密
return base64.b64encode(enData).decode()
else:
return '密钥或iv字节长度错误！！！'
# 输入
print(AES_CFB_encode('你好 Abc',key=b'1234567890123456',iv=b'1111111111111111',paddingMode='NoPadding'))
# 输出：QiLUCMq9uwxjUw==# AES 【CFB解密】
# AES 【解密】 加密模式(不可改)：CFB key/iv(默认)：0000000000000000 块大小(bits)(默认)：16 填充模式(默认)：NoPadding 子集编码(默认)：UTF-8 字节(不可改)：128字节
from Crypto.Cipher import AES
import base64
def AES_CFB_decode(data,key=b'0000000000000000',iv=b'0000000000000000',segment_size=16,paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密内容【解密】
# key：密钥，长度为16字节或32字节
# iv：偏移量，长度为16字节
# segment_size：块大小(bits) 默认为 8 最小值为 8 最大值为128 只能是8的倍数，如：8，16，24，32，40，48，56，64...
# paddingMode：填充模式，默认为NoPadding 可选【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：编码，默认为UTF-8 可选【UTF-8，UTF-16_LE，GBK】
'''
if (len(key) in [16,32]) and (len(iv) in [16]) == True:
data = base64.b64decode(data.encode(characterSet))
data = AES.new(key, AES.MODE_CFB,iv,segment_size=segment_size).decrypt(data)
if paddingMode in ['NoPadding']:
while len(data) % 2 != 0:
data = data.rstrip(b'\x00')
if data != b"\x00":
break
if paddingMode in ['ZeroPadding']:
data = data[:-1]
while len(data) % 16 != 0:
data = data.rstrip(b'\x00')
if data[-1] != b"\x00":
break
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
paddingSize = data[-1]
data = data.rstrip(paddingSize.to_bytes(1, 'little'))
return data.decode(characterSet)
else:
return '密钥或iv字节长度错误！！！'
# 输入
print(AES_CFB_decode('QiLUCMq9uwxjUw==',key=b'1234567890123456',iv=b'1111111111111111',paddingMode='NoPadding'))
# 输出：你好 Abc
6、DES_ECB 加密解密
# DES 【ECB加密】
# DES 【加密】 加密模式(不可改)：ECB key(默认)：00000000 填充模式(默认)：NoPadding 子集编码(默认)：UTF-8
from Crypto.Cipher import DES
import base64
def DES_ECB_encode(data,key=b'00000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密内容【加密】
# key：密钥，长度为8字节
# paddingMode：填充模式，默认为NoPadding 可选【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：编码，默认为UTF-8 可选【UTF-8，UTF-16_LE，GBK】
'''
if [(len(key))] == [8]:
DESS = DES.new(key, DES.MODE_ECB)
data = data.encode(characterSet)
enData = ''
if paddingMode in ['NoPadding','ZeroPadding']:
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = DESS.encrypt(data) # DES加密
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
needSize = 16 - len(data) % 16
if needSize == 0:
needSize = 16
data = data + needSize.to_bytes(1, 'little') * needSize
enData = DESS.encrypt(data) # DES加密
return base64.b64encode(enData).decode()
else:
return '密钥或iv字节长度错误！！！'
# 输入
print(DES_ECB_encode('你好 Abc',key=b'12345678',paddingMode='ZeroPadding'))
# 输出：f5c0sPQmxvZOj8ufCG/zBA==# DES 【ECB解密】
# DES 【解密】 加密模式(不可改)：ECB key(默认)：00000000 填充模式(默认)：NoPadding 子集编码(默认)：UTF-8
from Crypto.Cipher import DES
import base64
def DES_ECB_decode(data,key=b'00000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密内容【解密】
# key：密钥，长度为8字节
# paddingMode：填充模式，默认为NoPadding 可选【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：编码，默认为UTF-8 可选【UTF-8，UTF-16_LE，GBK】
'''
if [(len(key))] == [8]:
data = base64.b64decode(data.encode(characterSet))
data = DES.new(key, DES.MODE_ECB).decrypt(data)
if paddingMode in ['NoPadding','ZeroPadding']:
data = data[:-1]
while len(data) % 16 != 0:
data = data.rstrip(b'\x00')
if data[-1] != b"\x00":
break
if paddingMode in ['PKCS5Padding', 'PKCS7Padding']:
paddingSize = data[-1]
data = data.rstrip(paddingSize.to_bytes(1, 'little'))
return data.decode(characterSet)
else:
return '密钥或iv字节长度错误！！！'
# 输入
print(DES_ECB_decode('f5c0sPQmxvZOj8ufCG/zBA==',key=b'12345678',paddingMode='ZeroPadding'))
# 输出：你好 Abc7、DES_CBC 加密解密
# DES 【CBC加密】
# DES 【加密】 加密模式(不可改)：CBC key/iv(默认)：00000000 填充模式(默认)：NoPadding 子集编码(默认)：UTF-8
from Crypto.Cipher import DES
import base64
def DES_CBC_encode(data,key=b'00000000',iv=b'00000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密内容【加密】
# key：密钥，长度为8字节
# iv：偏移量，长度为8字节
# paddingMode：填充模式，默认为NoPadding 可选【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：编码，默认为UTF-8 可选【UTF-8，UTF-16_LE，GBK】
'''
if [(len(key)),len(iv)] == [8,8]:
DESS = DES.new(key, DES.MODE_CBC,iv)
data = data.encode(characterSet)
enData = ''
if paddingMode in ['NoPadding','ZeroPadding']:
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = DESS.encrypt(data) # DES加密
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
needSize = 16 - len(data) % 16
if needSize == 0:
needSize = 16
data = data + needSize.to_bytes(1, 'little') * needSize
enData = DESS.encrypt(data) # DES加密
return base64.b64encode(enData).decode()
else:
return '密钥或iv字节长度错误！！！'
# 输入
print(DES_CBC_encode('你好 Abc',key=b'12345678',iv=b'88888888',paddingMode='ZeroPadding'))
# 输出：4jaMYjQEe5FW1JJyDhCliQ==# DES 【CBC解密】
# DES 【解密】 加密模式(不可改)：CBC key/iv(默认)：00000000 填充模式(默认)：NoPadding 子集编码(默认)：UTF-8
from Crypto.Cipher import DES
import base64
def DES_CBC_decode(data,key=b'00000000',iv=b'00000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密内容【解密】
# key：密钥，长度为8字节
# iv：偏移量，长度为8字节
# paddingMode：填充模式，默认为NoPadding 可选【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：编码，默认为UTF-8 可选【UTF-8，UTF-16_LE，GBK】
'''
if [(len(key)),len(iv)] == [8,8]:
data = base64.b64decode(data.encode(characterSet))
data = DES.new(key, DES.MODE_CBC, iv).decrypt(data)
if paddingMode in ['NoPadding','ZeroPadding']:
data = data[:-1]
while len(data) % 16 != 0:
data = data.rstrip(b'\x00')
if data[-1] != b"\x00":
break
if paddingMode in ['PKCS5Padding', 'PKCS7Padding']:
paddingSize = data[-1]
data = data.rstrip(paddingSize.to_bytes(1, 'little'))
return data.decode(characterSet)
else:
return '密钥或iv字节长度错误！！！'
# 输入
print(DES_CBC_decode('4jaMYjQEe5FW1JJyDhCliQ==',key=b'12345678',iv=b'88888888',paddingMode='ZeroPadding'))
# 输出：你好 Abc8、DES_CFB 加密解密
# DES 【CFB加密】
# DES 【加密】 加密模式(不可改)：CFB key/iv(默认)：00000000 填充模式(默认)：NoPadding 子集编码(默认)：UTF-8
from Crypto.Cipher import DES
import base64
def DES_CFB_encode(data,key=b'00000000',iv=b'00000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密内容【加密】
# key：密钥，长度为8字节
# iv：偏移量，长度为8字节
# paddingMode：填充模式，默认为NoPadding 可选【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：编码，默认为UTF-8 可选【UTF-8，UTF-16_LE，GBK】
'''
if [(len(key)),len(iv)] == [8,8]:
DESS = DES.new(key, DES.MODE_CFB,iv)
data = data.encode(characterSet)
enData = ''
if paddingMode in ['NoPadding']:
if len(data) % 2 == 0:
enData = DESS.encrypt(data) # AES加密
else:
if len(data) % 2 != 0:
data += b'\x00'
while len(data) % 2 != 0:
data += b'\x00'
data = data
enData = DESS.encrypt(data) # AES加密
if paddingMode in ['ZeroPadding']:
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = DESS.encrypt(data) # DES加密
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
needSize = 16 - len(data) % 16
if needSize == 0:
needSize = 16
data = data + needSize.to_bytes(1, 'little') * needSize
enData = DESS.encrypt(data) # DES加密
return base64.b64encode(enData).decode()
else:
return '密钥或iv字节长度错误！！！'
# 输入
print(DES_CFB_encode('你好 Abc',key=b'12345678',iv=b'12345678',paddingMode='ZeroPadding'))
# 输出：cm33fNn2EfuyJIZBZ1uYfg==# DES 【CFB解密】
# DES 【解密】 加密模式(不可改)：CFB key/iv(默认)：00000000 填充模式(默认)：NoPadding 子集编码(默认)：UTF-8
from Crypto.Cipher import DES
import base64
def DES_CFB_decode(data,key=b'00000000',iv=b'00000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密内容【解密】
# key：密钥，长度为8字节
# iv：偏移量，长度为8字节
# paddingMode：填充模式，默认为NoPadding 可选【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：编码，默认为UTF-8 可选【UTF-8，UTF-16_LE，GBK】
'''
if [(len(key)),len(iv)] == [8,8]:
data = base64.b64decode(data.encode(characterSet))
data = DES.new(key, DES.MODE_CFB,iv).decrypt(data)
if paddingMode in ['NoPadding']:
while len(data) % 2 != 0:
data = data.rstrip(b'\x00')
if data != b"\x00":
break
if paddingMode in ['ZeroPadding']:
data = data[:-1]
while len(data) % 16 != 0:
data = data.rstrip(b'\x00')
if data[-1] != b"\x00":
break
if paddingMode in ['PKCS5Padding', 'PKCS7Padding']:
paddingSize = data[-1]
data = data.rstrip(paddingSize.to_bytes(1, 'little'))
return data.decode(characterSet)
else:
return '密钥或iv字节长度错误！！！'
# 输入
print(DES_CFB_decode('cm33fNn2EfuyJIZBZ1uYfg==',key=b'12345678',iv=b'12345678',paddingMode='ZeroPadding'))
# 输出：你好 Abc9、RSA_PKCS1 公钥加密 私钥解密
生成RSA密钥对，在下面第六个大标题有！！！！
公钥加密 需要用私钥进行解密(已实现)
私钥加密 需要用公钥进行解密(未实现)
# RSA 【公钥加密】
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5
import base64
def RSA_pkcs1_encrypt(file='',message=''): '''
file: 公钥密钥文件 路径
message: 要加密的字符串
'''
if message == '':
return '请输入要加密的内容！'
with open(file) as key:
rsakey = RSA.importKey(key.read())
cipher = Cipher_pkcs1_v1_5.new(rsakey)
cipher_text = base64.b64encode(cipher.encrypt(message.encode('utf-8')))
return cipher_text.decode('utf-8')
# 输入
print(RSA_pkcs1_encrypt(file='公钥_pub_key.pem',message='你好Abc @100'))
# 输出：UKiqRfIJbpdxGOqaI+5jCPpN+sPUWs3RY5bGZHNnEtiEN+HVz3ky4QfnXU+4cfPj7PH81trMHFxYBzZVJEvpBeoYa1Kbv6aWdUB30t8rW4Tv+2YGxF6JjEW1gH03beXlUoN+fLJBGJucXfOgjRhqTs9TqWSBmP5VI1gbTjx9wLs=# RSA 【私钥解密】
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5
import base64
def RSA_pkcs1_decode(file='',password=None,message=''):
'''
file: 私钥密钥文件 路径
password: 证书密码 在生成密钥对的时候，如果添加了证书密码，使用私钥则需要输入证书密码才可以加密或解密
message: 要解密的内容
'''
with open(file) as key:
rsakey = RSA.importKey(key.read(),passphrase=password)
cipher = Cipher_pkcs1_v1_5.new(rsakey)
text = cipher.decrypt(base64.b64decode(message.encode('utf-8')),'')
return text.decode('utf-8')
# 输入
print(RSA_pkcs1_decode(file='私钥_priv_key.pem',password='123abc',message='UKiqRfIJbpdxGOqaI+5jCPpN+sPUWs3RY5bGZHNnEtiEN+HVz3ky4QfnXU+4cfPj7PH81trMHFxYBzZVJEvpBeoYa1Kbv6aWdUB30t8rW4Tv+2YGxF6JjEW1gH03beXlUoN+fLJBGJucXfOgjRhqTs9TqWSBmP5VI1gbTjx9wLs='))
# 输出：你好Abc @100三、编码&解码📃
1、base64 编码解码（文字）
# base64 【编码】
import base64
def base64_encode(str):
return base64.b64encode(str.encode('utf-8')).decode('utf-8')
# 输入
print(base64_encode("你好"))
# 输出：5L2g5aW9# base64 【解码】
import base64
def base64_decode(str):
return base64.b64decode(str).decode('utf-8')
# 输入
print(base64_decode("5L2g5aW9"))
# 输出：你好2、base64 编码解码（文件）
# base64 【编码】
import base64
def base64_encode_file(file_name):
with open(file_name, 'rb') as f:
return base64.b64encode(f.read()).decode('utf-8')
# 输入
print(base64_encode_file("1.txt"))
# 输出：/9j/4QAYRXhpZgAASUkqAAgAAAAAAAAAAAAAAP/sABFEdWNreQABAAQAAABkAAD/4QMbaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLwA8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/PiA8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA3LjEtYzAwMCA3OS5jY2Y4NGUwLCAyMDIyLzA2LzIyLTIyOjEzOjI2ICAgICAgICAiPiA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPiA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIgeG1wTU06RG9jdW1lbnRJRD0ieG1wLmRpZDpDQjkzRDc0NDhENzExMUVEODI5QkFGQTc4NzM0QjcxRiIgeG1wTU06SW5zdGFuY2VJRD0ieG1wLmlpZDpDQjkzRDc0MzhENzExMUVEODI5QkFGQTc4NzM0QjcxRiIgeG1wOkNyZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgMjAyMSBXaW5kb3dzIj4gPHhtcE1NOkRlcml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9IjJFQ0Y3OEY5OEY3MjIxRUMzREU3ODE0MDQyMDNCMjM1IiBzdFJlZjpkb2N1bWVudElEPSIyRUNGNzhGOThGNzIyMUVDM0RFNzgxNDA0MjAzQjIzNSIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/Pv/uAA5BZG9iZQBkwAAAAAH/2wCEAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECAgICAgICAgICAgMDAwMDAwMDAwMBAQEBAQEBAgEBAgICAQICAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDA//AABEIAGQAZAMBEQACEQEDEQH/xAB/AAACAwEBAAMBAAAAAAAAAAAICQUGBwoEAAELAwEBAAAAAAAAAAAAAAAAAAAAABAAAAYCAQEHAgUCAwQLAAAAAwQFBgcIAQIJExESFBUWFxgAGSEiIyQKJhoxMkNBQiUnYZE0NYXWZ5dIKVkRAQAAAAAAAAAAAAAAAAAAAAD/2gAMAwEAAhEDEQA/AF3UuorxXrfFmucoPKJJ90Rld0W+kGGDyjDb50VTaisDjeYIoplJUm0sqZ0+fyWUDZ9RNqGciCZxj/PnXGwFfQyhP8Z3kjnbatlapM5LNpPMMhzvgoG93SkthH3R2tgjqq7BKmWSqAYPgaqWggYYumoYmNNsd7t7Ndgab/GmtPHFSeFCwc2WblFxpMI15uVLzaMupbKu59jtFpmysKIyMmJaC201wLuCBx4u/IuSxAnsFoaPjD501xsJv9Bgt0GKy66xPbpwWOsBK8aWnlheuHYWnUeIFv7aqUNv6p0gvuHTZh/v1XajCWTUXupDIZHwltsoKEGT27oeoO2owuwQQ/J3GTQqFrFRtp2HlnPyEqpcazTnxK11Lclgk1zOliRH48lHeGGxFfsjpByX02TQFPoqBXI++2mne2zjAORrtX6lMDWYoE4XJam3By0lmUOYrAwnES7PE1yTCb/UXPX5khzCQMllZqaowjEY7YBCUW4VcZogaCOC7D6aiD9gQQMqM2/ITuxbjtuiCoyJbs7VRzOiHFRjyYSfDIYCXYFHSQ1EizXU4TSQkCqCFnYbXAx5HGMFs9mddTGv+bAc88PW6v3Bji5TJmYKDU90+zEpyC+LqFpMsDaJ7teCXazqvhu9Ab8Xto80i+E1omZWBOlDxRvaqOmUkDTAfd30CFwDY4wet+rwULs4oyOwa8t7awlV0I/TZZgaXpVafrsSY6+jKiifdrxWE0m84s0KvpcLhJR8qVBUSpLbIggWBgcbiAtriZ+cUWWkn6DGinxNIGIzkClsa3eKyLaex0xOeGmykVdH0NHYo2kdupDaPutTdxczgYUgOeCVgwtBDmA9tQxNQTeXo9Ti7HID/IjsvyLyVZfSNaIzL54nbxE+fDKqew/Hy2GoJgKcooDlNKeiGix4QJJBEvuVLlws7aZ/L3chhgteYQ/ir2bnSJK8RpJvKL7hzU/2zGjI1cCumpaII6XeqF0ZDAVFMFont08mYUTQYe4+QttAsbd7fs0xttgAA+Bca/f1+0d7mz38QPl36M8m9yBPVPgPQnm/m3i/K/THqrw/7DzPynxHgvy/4/j9A2+oVBLE8kf8Y4CvFXktqLkmk+SN8SEKnO11kminbt1tljxBVyErHwxCeFAIRxFxNQRMh98Lv51znbGuuwEp/Hs4BuRXjq5CitkLONGL29GJGE5QZghxsymgu5XFXnVqghJJYFJSQ9xultgkLuILvtoHppp/jnbOuuQzTjjXgm5/GB5LVvdz4aIJW7z67XLrJzqh/CfoZelVi3fDkVjoDpcqHk1gbpa6liI2DuRPCiZDCG3F0CKdsn1oVa2XcdD8uvKRC1DXla7yBCEWJt37HrUWuOMMO2AQ5GUXa/DMJCHGMvMTUztqkIxXfBfXO+uoWBcGBdgAZTCtL+VdgSuj2fjiKEyYS5FwW/kOLG7MPItIkhxU8mvOMZRckRAXcLGcLTTQxG4sYIHhyqUJsWCQzAeo+dg9ttc7ACF/GxaCtksuxfs28TkKOWbB+S6a48QE/kdngFHLM1VguMBNtmGjNSMVss0202XFoaCTUjYQtlFBxjJbUTG3bkOnKoz8vuYpJITnTYMgBTfyXGDBUKSiBTS4nYm2PbIkPNU01XrOcgrCWjOAo4XIp7fujpgEqaNaZ6gugWc9TYBCipor/Lw+7FsGzz3Wa2Pqkr4d0IuJs0Dsc+GuC4HBP0CEG1JYM5irLJLkXU4o8VQTHpM4V2GCJjhCCbdTGNsDBN8g7ujqiUrcL6A6p0d7WhyDFaZk52Od/wA8SYmup6R3Cle0MRScEgNpjstdK2CWiCIjbHjoSnqS/diZyX032Ob66AGLksDSiTuSWqEoU5upKMrLVgbtxS6pvj9xT5OEeMBshuKtPnETN+N4tFilPQna3Hqyh9lI2jKB7w2p3XQIYUDffcMIBTqvAkgWmmn+X7XKJwkc1JkyyFowmOTXVUNFSjTiXj1lCiYAfVBQxtE8qOZzjTI2+vT0ztjO2cY7c4BbnHB/GG5Xq3X5p1YCU2FDiXG8M2KimTHyoJ00tlYUSjXZruTF1ZET0pPCHOKJ/wAES31BB01/UFzrjO2uuc76hTu+H/eXd7qB9352dzvd/Tu9T2t6fT73b2dTq/l7v+Pe/D/H8PoGmm+DrgVQ4GlO37U5H7kRrVlsTQvx88HQ0ZaLJ7GZkmCPZPZRpmYJCwOZdR4VOcauTTwzYoZzIgOwYu5kUPGRvoMRXONz+OehFHEMu8y91iZJuF3hs4tjEwGRASJdkPtGi924Ma6VzEwNonvdxk0/u6Y38Tkfqg4FAxuJqDiYppNWclwo2zppwzv5+WKHCmlaa62vCTlmHpAUJ+b79iM9KCKZlw8wERCaRhvMREJaa6EkfVPPEwtQdRdhDYhnIZ+oWEGXoFtJyar4ETJUi8YkoWEp+nQGkWJMKFTpfLH1uJGmtu21++8W6KRyagRnNuLpgvruCMfAI7Z3z1sZCD2BRHzCuGv9wY4YUIKy6ybkyXYma2ZJ5PkmHCkGOW46kOMV+BUCurnMtEiNEcdOg2WUS4CLgDOiOS12wIIDgfGdg1296vO8eWv4jmiwW+gydZAtVe2yUh13lO1ozXacyySh18aQKs232mHGMfR5t1KGShocRYOnkjUMYHJvu573d+gpB6FuZ0gybpx4g1wN7I9v3POLi2XdORvwrlgUI5BzfxF6BWE7q0i+IlbCjKexxJDJh651SipfQxnuh51F2DMIinywK5NkVO6TyjXiuEeIN6vBp3xkKPLqLy2p7IKfUtsFTjytwzykdFDtmHomvBtHgg9y/WF1NhmDGuuciZ2+gOWdWKTJMeQbNxnKT6mCit9mU/prs5ZeRLADJZihdbj9cjmqFLdGmqoMo4uNvLhby2ZUByhYsbNBjFi224G2M5xoGWcfgUO3gldGaMazYtq0TcVbiq8vwJK8UzWOrSJbxqSTXYUFCct3UZWjZAHVTZ1BSghiQYOxcQxsMb12wDgPOm4LyvVxwcArzvTZx9ytyHWKrdY15ymn6zxG8XyIZQkRJk56MRUlnULOxuE3UZCCcbWRTq1nTKqaIgD9QIPIO+wRbADawuLf+PfJ7wZTAYXMPd5yPKRHbDjEZqATmQQE8tu+wDfOumHkIPxldywRQ490NOGGL+I2B0AzrgMxsCLtppsDIf7OjjN8H4v3luv6+9WeqfdH3eY3rL/s3c8s7/tT5T3PMP3njPDeZdf8PEdP8n0F5gzkQoRUuRHFWBXs9FE90jV0ObbJyTZCxMspTrkBmzeoWZKsAzDJSIwI0TdT8eNZ1nSWE9WzoJkM0LnbG++ofVyAkOWt9bIzSJib/JpyBWHoLKbnFsY8GexEezjBkbKrWCSLRMNwsqdE5aQobUSiEOtvZMDQiKOLkU2VKCiYED23zncICcthY+/j7RX5xzRtVqOoImiwbNmSUYMU6/XtY0PWFkZkxdLDAMM6Xm8409kio7eVpeZqapml0U5tqb6ABguJ3Nt+zUCv5iZ0gSBuPOaK1KsitWIrKS7BIMnI7IIygiQ69nmM2HjH4UnPQSXd2K4G353qKEJqdUjhAQwtba7hB6YyJ3wgnJL5tacw3UtfNQ7YCB5eslFEbLqIQiN4yubQE5ekSEG8xxZcbK9KPpPCTscaCa5AzI50MvoGoi5xgDXGd9umAHUuXrP3sd9s49Rw1xVh+YbR2aRJJuDHt72pJE18f5Ryw5HrjYbUqcCcjtOXWS3XO5TgyT5OQyPqmktcjDCbYz2ZD2yhaWvVY3xJFKU3kplSQo+sQ6rRsa3FjZWtuMlWNoE5K81/bZ42m1tQvbcQdXP5EBEOqmCfXwQO7biY7++22moM4gJm03uMsQYt1sujIcqEaUAFG3PiGxnYn5b1sFSSoQb7aQVO7JQ4zSgc2rCm1U/VaLmBNtdPMDJnbbs2zuFoAJzXGkoLNwXQs8d0uzXdM9CU6v8AV7Y06X7htyH67V/UBq2HW9CtdjsWuFibJTihySF0kJoKklRTBVLMBbjCbYxrv0wk5jjtk0wKs27U+2rlyqtoJb7lhG7QUKxzablVHNN0F1bPlVKqGzmascjp5uC0wwBrscOmRdyoO/cHB37M6B7Ap5v2JhW1ck22sRYS3But8kL5Wt8ywTEUSXbaDqjuQpgdlDJFNDRKIYFhAyYiRk9HfxGiodMGcGhs5MY21wFkAQLQK8bMuGt3FwgCxk3o2aTqkur7ZrXYti8gEYo0s24eDhr/ACOkKiK8XSWhsQ64FWPnycJpCNgQun5FEH1FB3110zjIaV85OQvyP7Ift+lfLH4peWervuYtv5y+63tB74eWe43oPyT1L5b+TzTq9PyP9bq/7foCvgy23G7JEyrNrrYTHWusB5jNCcoNPUxTpFhiUa8vFiI1pSSWnWadoSXHZQYOSXJJ5smTGBEHzkA0ECLtrvvjYX6Df5pnCt8kXaa16XI/o8fHGbClcJQrXYWbXBKcTqNcGbYPE1Nwqjxg+ohcbOU3y4XllYWUjJZRLHdUoEQUr+lnfTviBY4RbVNYpdj55M1nlclKbIYrbItjIwkBXlSQWe5Yfi9fl15M0uPD5xXBaADiRUqLFldSyTfTCxrAIfmAOMY303xjYEt3hgrkCb7Ps/ZCY0+xoEEJxq8yizpZfnILWjdnpMTS/JMPZr0VbQjliheVGayHeU6mrfR98ieS679AxjYQbTP0DKq3QNx9slHe/IA+uRZwy7C9cn3YIzaJhyKuQ/IsEM99TdH0cN15ws+coEXkzzt0j1RLp+6KXKYGNKamaB011MbbhgZChVa51OCirKzY5TReRJ/vwrYae3ROeUR3wJMJdIjD1GRTE4COo+LNqDEPwzHb5RLDDJBm8mTOgWNddhdu725Adbp8of8AH8uC5Go50vkmk6tZ1EQLApbqCgetz7RQ5RWp/j4lHik85EML1cltQXXS0E8jqMnGcja7bCbZ1H6mnZjAbTxhS7xjzHbthtyonMfaaUZJJOpQlA1Xd1pyjFjPnYk3oSSo0GbDiTlqGY+JyAUa6U293FoQBMinC4/WMBh4BBE30DbYXrO8Ld3j5TUxuXSs9XDWKbNFixglXiyEZKnqDElV1VGQQ1dTNQmAVcEe+gT2uVVEIrZpSHwqAZE03xsBv9Ae6fICQO7a7UziRosvkjW6uuZpwreGXJrkmP1CaKyJa5Fg4SJMD8SHS3jBp9vqWyCedDPF0nAAxrXr6iZzrtvrqCXeQVn1Kji7iOhMK7Cg1xXbayLm5ZOJECaIDhxt0oZyXUx9N1vmWix3BE6soucgfYYppa0RwDOBMCk9dA99Ndsh5Bj/AB1wnTZ/I8xRxBHJTJF3hW5CVdE5pkXQ62G8jVPRx4ncqHHM5wSnlGUnE4skaSUpTEW9z5YLAux0oHtnXXu93IJS+Pj0++f8EvnLZ3z/AOPntr8j/mhBfyU82+Ivqv1p7S+1Pup6x6H5Ov531fAf8Q7fDfp/QUhUgrLSn5ywdfee3zx8NpxwrP0kG5HkOeqNuJTb7ZV79NdcjRwlmGTi8JZMJEkKRAImUOib7FymRchja5Ma5zgC35MbwyS161TrTF7UmjOj+z9brtncmttS4dQWC63KiMi2cXtdtyno1XOwzLR3DnUl1T55SOFRTAIoexbvbGc6C6B0QU/bRmX4FlRoWGohGNdW0szU+0/WKTxuIZZaE/s4iYbqg3LFOokzG0RZplYlI2Bg6MVPFRjwI5HQUQTbtCzqCU+RFp8sNtVB/tto02srFcWNpgWkhtAjqJrcVh0jSaEttvNgiQRKa8y30z1UkQcL+RQzoyYVNBb5QQSeQ99tRN8bZABOTCELAwfwG8rKdYKO5IjtTet842fLFAkh8ww+TrlYSnJ9fCaY5EQzCzZa6YkoJlRTTIIZRUCFVNRANtxBM6bB/QI84hv45m98oWji0to59X64wbOUmH4ir6iMWNFiRJFlp1JmHJqfWTZ8IuO2oxYwJxmqxUBUVQhgDRogJpvktruU3NBkfMfwPk+ONjB2AgOw+bD1/KSyvwc+Cr0Zh+LpejKR28oqSOPqcbarqXLyAwDqujmCgLmSAg0/c10tQ9RQRgjGwYP/AByc5xzX0F7M5x/zLeWPwz2fhmHZIxnH4f7M4+g/SHjaIZPjlz83L3nJ3SfUSIpcXdXLG1oz0iQ1sXZ7DSoUXU1yzbGm7Zbqctx/rG42+prtdox4xqKUC3021xoNncA4hxca0QJs/Zqtdl1XqZ1hmbGaXeC6QU7QC0Xhxyxug1ScGrMuGePlGyEoyCvvtF1Fc+mTgo3SGTMCaZxpgXvguSK4Fk20txnoxYBnSZreRo0pnpmHItsm9YmmDzXA4rfFLXe0tbFvJlKEbqT/AM+aiqO5nBE6aMqCsKHncttgLv8A0DxCSzH1PY+TKcVTwzJzleMkaNYO5EbMNt/wZC9gqjQaqRS6VFl2xmQoA2y2rqNx81Qtz6Gk9PGdCwXeC/J3u8AjfbSiH0Z9yP72lifb346+QfLjzCEOzyb0P7Ve7fvJ6Q9Tebdb/V8f1/E/tut3PyfQXO3ag5OPhCeSlY+m6LyoMX0v6rN3Vts+6qRxu18SlaJqpLRppobk9qqJjRpMHZRBdKVsKPgkYOhBhAl9THc2BAOLiXicXJWz5Qr3EfHyzVKyyuz5YasfyJFdl6OSrPerNrtamNU1wMhqEX02F/BZpPNPAMKqsUE7xZMwBvpnQQzkMbUGSRpZ61FemxJ7cq8x5Q5nUTLxmx6LsrFbFwK0MwLLyS6GM3tqHeFIEDxQqYjdHNjqeB9u7sX1F3CwBjXYPUMBpuu/uY6wrkW1+IqrXlq4RaEfWUjpHa8I2YrMOkSGrIrkYQsUSsMI4EgQ2muJ5phxS1Tgsbbbp4BMTHfzsLnOQyXnfgyX4R4B7o7TPYmYrAOSUZrr/KZIrM2zUGWoVTHJL0MhbQohHWeWKpKi3WcpETHTMa6YwKMOJtrjsz27ApfgY/ksV7pBQjeqly93IWPQu6FFIropR8zlV4qy4zHwZeT5Wgn6S03SEtLSmK9DmpcAyCfFPHyyuGFoT11IimBA6/qkpkb3Iq01p+hCc2Y9UGw0HR/lzOs7GsdSose7e58VdlRWfBx3lVBTOqpgBQ9NDtBSwGmtoAhqGULAd3AeocUEbsuo8e/zBovZ9KQWuRhhEnBVKHUNidDDBbEp6V3eOJcbLKDKa6kSiIhv7xwGxUt+zIndRyxfGoAIemodP1rnjFEaSrYySXHyx7zFliPaX3cucXzylKvTdjySdm9XBaV1Olrnw+fE6IzUcCMV3VTeFUAUEAEfcUwBt2bC5AGabsUvdNc5AZQQLFKvHTA6A2YDkOTo5iZ9Urk2GCMRyNSNeJDsZ37R42SpRPjOIkg0IcLbujUdPPlyudyoWgGou2gNLrhFlPcR7B5ypPIhGaXpSdFhGS7pyZAIMAopqz8TtmJTRqNtbaH2QUKl0mP1KPCRpRSxxN8glkvA2S2dddcChgUEPORDtc9bsax3XJlxnD0zRRGibGHItG65Db8Cugiv2LVtKEc5IoiophXUS8DDHvLCWjlMKRM1251B00L52D2BFP22eRX5WfAj3cu79u/48+0Hv/46pfxw8f7E+YeffGX0x5p1vc79j0O73/N/3nf8P+b6AreWu4A1vWq9KC08jvFoj7xjNqzOVlGvUq1Rk1XT3XEFqmazn5GBaG5ZGXiKmrs4BPEUFNTHC6Kd3cBa64MabZ0COoOZHnnkfZFhIdpbmtsDxyxriwU/FONfiW64rOzIky+TGV3W7HjFySFIKLJEn4FDOG0sEbQPTIAexjAuNhBdg1N5SRLVTmFPvImj10eFS4qrhIU1NVy8eKc4a7RbHN1HM/5KYzbS7tuOYBiiOktFecgTlya0DUQzB87lH1B6wuw2nXAhrSGy1pWKs2Qhrl2CpdD8QR89Ikm83HC/CL4jyOJiVFJpGhVGSn4ruDCO2n9Gwp8JL3ICGQNtsqAedNwdhMdUIfm2p5NV5uHyYa5V4USMwy8uNeFnS0Tp9VQ0jMuCRy+GM91QyQV8mSjYLLb1RkEwYJZ2GBICmhgw+oGHvjfUPzS/7fLmc/8Az7m7/rZf/mz6C9NLhD56GCVPEWJT+1DKJKYwBhSJtJ3JbcKqBgrtpuVHPF0d+EwjYxbcPXIewmNttM64zjOOzH0DauCThK5VY45Yq+2gs1XN8xTH0VOV+ydJckyy4W8MoOFTXWO8EIAkQDLOJYcLodrkcrmDEGEyHtroH1jBgXGca6iB1C8uUXxpGtn6KPSPqrMqVnZK0oWgdcoRM121VJvrFsHOjVx3TUtlPpRmVH2drvWXak9RDBHR8mDIRY4Joc7Q9i+uQFub0a4T/QCDYrHxPz9QNuuRG3bs6t+AiVODSTYZpr9N1xPbDLlRMWG8TSlpFhNyD6s9OLGdDBHcYbOnYGHnAGgFOjSUyuMij9NEt4URZzgla28UtmG7PoTpWqswA+FkxF1fls1oizLpuQRGTJ+5RAIGUPVNK43KECRgTGcahZyEIHygsqWEeUaXwmlJjOXayVSWqcwg9qSxikuysx+B4dFL18d5x7JFYXIxAiTYB2b7vKlxj5te0BSNFHubZ10L674+gSh79cwnt38i/d/kR+N/wp9W+9PuhRz2i9c+0fhvPPW3iPJ/N/Xv6XivE9TzX8vb2fh9Ad3H7D0jzMiPuMIQi57VkmNYkG0KmhcsjWhinq8fidCR7XJi256sF0SMjO6YcEkpOTDBgfc0bDOY1OZHGCF7mM4CZkeDZprZCk4FOPvlWPzlKq05pnfCRUml8T0tISs7Hw9LLx8JIb4S24TcQxZVXoUbeDaM4jJgmIY3LbCbC5AH00ByHsutD85yhWqfmQ1uVpXvw9nWRlkun0LYcXUykGSHOe97opUDDVKMpbc60mLh6pZYmPqqaDlBBQsd8TOpcfQELcNSZ9K1OHIOsHJ7Bl5O5LYNClKfXTYbi6iiAKnpSNL8wSkpxqU0iWT1JkmlVFLydWo2ngqZ7J4sKqndiWmogWmdQtBA3ji/CttPM3zHLLptTM7KhSt1w7TRJvTN3s2uCo2zbMUmayS0Vx4VdsQrJ5VZber0dNiapxQ6HhXMiB50NahaZzrsGFxtZO0RSyFtZPHtpL8pna13Cuu24k4ydRao6ve5TQRWE1/SsfxCpILlNv8AS0GCRDm68HqZIjLmQN8YUAg9tt8ZA+435aQH8zrKhm64LbTsRCjjczMi6pSlOEKqM5WWejNjZJkV2M+Nm4jOE4dLOdrl1PICiRFLjmSeofV30/HIeoDRrZybBX9vX5Ns29FuVOSZwSAiNsqQVq1DvXhgfSZX1JfIcQPBiAO4Val96N5YX9s7lBQyw+oiXuJvjGouu4oVSwFgnAluaG6qWcgR1teXY7NvyCoA5dpu2rMiitB7pVZMn3/feMWM9FIkCnBl1Ap4tVTE8XUuB08aDD411wHgK7C0135jhWsPGb1kG1FiIOlxMi+O4h5Mj6HWRuwHX9jgVbWFN4XoaIqCsjIrwjky8hAV5Q1UjOqaEOW00CMZ13E13DyrFymw9UktBkn0mG5aU6kxaNtFm7G7jqu4mg8CkgVndL8WrMbIGq6tpUUILoS0wdIFFMGASZoE71dDQmmudMhFzpblhSVVrjRjOqj6bFN2XK0kxtHM613il2U/eiRAsHzDFD1MprXmdpOdxl26FGYSEGKsYASS+BlNPKC50Czj8PoMa+H7E9pPjV/cXV2+OfxS9GfHj2to57XenfQPW93/AEX688p9J+Y/1R0fD+D7/wCbxXc/U+gcBwxxi+4nq3JbbkONntFq2ftvZVzk2+/YajmDlg8guF9bHkZwk2nGJgygqqIsFNsblVgbODqjpr3t+3TULbYAeqfx4yVTrlWjhQEJKcox+uRJb6RlKbWXTuCIqjBpLk2zGXcqRFjhlBsHhH4We6ankcbZ1C06a2GNoKLjHYLgMK2uUvNSM6JXuZC6shcG5uHV2zMLbOuVayV5PKrud8gySxFZUuQjyY71tI0S2hL5bvo4RQwMHooCb7b9/Och5FBjEcTpWSrEklIyheKGOHB0mK0wS3ba8EWq8Stitsc2SRSiAA89rGONMXQk1uTBKCjkhrsCaE0MaimSwe2udO3IYUuvdnIxaEJ8isyVYoA7CrhiW28wE3bFkJ4jBRe9wpTKjtHC9NrYyzFdQInD8gEFcE92qe2qoIVK522D23210yCXa0WLYsJW2sVJKvxpSRYOzbouPe+WIRGb0cVLZ00Q0pkoXjxekCM0DdkPA693y7X2mKeyQcUzQG64LsXEycC7M7a4Cp3MrJYGA7LxFZCIA5C0sFb9WvtbaL2XF1M6fmZ1rw/3nU5rakIsVFx3Oks9H9LDcVRxCwqkmhGxlYyCKEdxgPONtwKCJKAWEi+7fHfZt6pr9lpZn+XXpYucVgOj9bWiv12cq7UhmNNWRbFyciKYzmbTzcL0FN4EVEjv7jKAJgp251wFkQPTcMrY2TZNvYxJpotaq4CYYdM2s2ikmqNYK/Otp1OS3BVRwF1t1Q9s4VXAkqIEmOLYqk41XugGbUAQiom3e32CwENY6UJeatFeNWpEOOuQE97KUELtf7TVnj6I6lLz83UlGmhwdvwvNkBOZ4E0ONl1UO9/Ym2UgLcI1v3y+2nQwH3gGdNQrFxdXGO42hrj+tbVNS9s4mYl5ZlRqgVUT0S3kdkqYPgtoTltrrC6ntNltGGT++6IeBwJgiWNmsld99Nd9tPoJqlFbIatjF0WpzOqu3o/kuiLRp5YqwDiUK11Ddrn5D26DX9+Ya8GILfZjoUiMPOAs3zIzfJqYWdcB+M/Qx3ds7YCU+D9afez5re0sQdb4y+Vf2/Hxlqp8w/IvZX0J7eepvUPut1fC/1r0PLO/wCUft+70fw+gAGlg3J1c6nDk5DZ8/kQr9FovVbAPyKgiEgI6ORZpFbSlAvkiUIrg8gR03EvdWFNjakkkoUzqCXLdum2cY21DAsoQrFcyzjxMRtXD+XSgzdJASApuQNjxuSQHa490ZJyWCPKuyOgzwfU8pZEc6DgwNoDvgLAmM5x9BtPGPdR12D4BrUyryXs5z8jKJEdlXbFTlj1SINI87JNZzdc8GqjZInjDiOtdIWBWk9HburBmjxjU2GUJaaaZE3BB0yH9OTNtoqKmrNW+PiPT4UJWagixswT3WytFY662TSH9aZJc0SnzR+QEVbfxNwbTGzyyaT8QjEwhAg8FQxd+zYPXGoMwa7MVqT2rpSmw6zHHXCosuRjPc4X1PoUBRgzoHUp1MRe1Am++LHS+ouEsbg97mF8gGCUT07qkz53TBXbfIfe31D6406fx0fsxeCy0o1vBISQ1eQiyD6rBMb2rsxYoUh2JMTTbqM4H7D70aK0sCS8zZERdNg8O45gE2qg7bZ201223xgMlslPzPqVafWX7Gt4xyYP9uSHcWRqnLMQsiB2+5+OpmsaF0Fde1eHAvGJATl9WdshovcLBHTpfxm+NO8Y0D17M5AuJ/uArn2RXq30VWTSY/aETRlIk0WFoOSKQg8p5sSKowOmyK3oEBV1d8AixtJkYdbc8c0ThRsGMCd4Tbw+ugmwGS1bhNt+1WWbHx8xHXIDwb0FpMxLlYmMps93T4kOBdjYGR0WFlNvN9wqKYRlJWLmNCJUoIa1DMGtsZD32DzjbIJAsQRrSv2u4wLSMuEG/Bkwy7Z5AmC5CE4YuhByS9FbmBr35wgJdn110PpPcMDOpktYczgQ4nAmDeugA4uwX6Wm24HvKz0FEZnJOqu2+MMz/F05wgdSKw1tbzfgxVW4hFO10ehhXaKZkZ5gYsCqTXvvqtpyYt7li5gmFkLTfwggguoKd4+WevZhqHidfdjHFPJJJi1PEm228t1dr41mdyMIO8GPfVsxbGabrIB1sk1qE9u5so6JI44pbodzbt032zgLz9oqyvvP9yr7r9W/dD49eQfL74RV68x9Z+zvs971+7HrX0/5P5f+n0O/4XwH7Pqdz6DnhaMBThY/+KaTYNf4hkebHyU5Q3O5B2fFrOXHy6AUBPJr5A+teQt0koKm6cSNqpcMYXQLbUPI+ve7Nc5zgJf+LJQi71fOU8jJE71FsfDUfk68zIlGHrKMNP1htcFVVtG0CmJuVx0ISWn7KKgJptgEDUTYUTGu2ca5112zgDC4x2O5JI/jMckLMaEfueU3Is3fkHylhs2DyNjnOvGE93VdVNtUiGlFcbZR4mCAJLY1nvHQckAwNjmve2L402A4eRKAVahcqxZYWisBvCD3Wl1OsvMjtl2IqNMmXwm3YCTjkaoznW3C6H1I6MiMR9O9LyKVw3N8DFBQepqFv+GcfQHZOlpnffevD/oo9Kt2er+LMTXlCMnDcW1lZmprUxuHIWQGA9hJbfZE0/Q0EuwpiUTghVp56+At1UPONM/oYz9AUldoGvhDkzwQjyDySQa86+EVKSdm9Wpu1vjaP1l+Q4UiVpoETslgOYi4TLgCIw+vpw60YPEtDW5wibDAH26WNc6hJWy44uOJsMef7PO3jzRrEP8ABJzdL7paUaM5RdUwy07ZVZ2jYlMo0kbVeTtVN3yQ3imhQQELcHG+/aIH3Bs53yC+o647aNsOELhW8m+scVzuzSLZWJ2jmprOhhtsqw9aGO5qzp7ZeFZJHJEJA2CXJhMsEMFFN6KxgnsXHA32xtjfbq6hWWmG5kmFLAT5xeQFLfFe14biYOTZvQn1URjvpbuklgVFMKlfiMIiuWQDSEdNwCbxgoa0LmyxI8fFwAMNtrsJvsBfRdxqVuuVSpnT9J0Jxmeu5ZqtrZkN5WElSF0xOcI1iHtXMaOAZTf0NIbsOM0E0mlnELscbhU5ul7a53C12znOBcAONceDKGGC3LPN+bXtSmZJBTomg9HjZeb1c2qxNq0SdG1ZHVEO8lSc3U19mg3WgrICz5oRSljBQsAmFxNNds9TIugEBTjjSaC8yG1CdtpvqpfCDK9MuATlYYij2HGYw0iu7sTo6cLffL8BHZjtWDy4lzL5xueTgVLbcuXADzsX73+bAWD3lpv8gPsG/AeWfj77c+nPOPTTe+Kfo32796/IvOPX3r3ueN/ZdXwXW88/3u5+t9Bwb8cf9xn7Fuj7U3yB+JXvLI3lHpv2I8p9ZeLI+ou57jf8T8f4Xwfi/CfsPE9/ufn6n0B7GP71bw5nqfKTpeHH6vh/if4jp9LfqeG8J+78R3O3p9H9Xv8AZ3Pzdn0DI/4/vzE/t47Ofb87nzl+Xch+lPcv0P5F648fX/1p0fW/9NeG9rvFf98fn8263d/DofQGY7vuadr7+978evtH+oLJ/JfxXtz0PajzpgfD3r+1P/NPxvuN0+3y3991O74//S+g0jnT+WXxULfGv4+/bV+Gsk++Pu96M9H+adBifGjoeov638m8R0fC+Xfpdbp+L/0/oJ17dz7i38dfs+Nfc+LtjOn1/AeuO98WGn3Pj32/q+m+l3ur0Pw8p73+72/QdJn0HCjYb5wevubD42/Cr4w+9ttfnF5r6A8T6O+Kyx7R+8/nv9R+Z+vvE+N8o/c9Xr9f9LvfQE7X37qXx3hj5M/Fj7MXs4yfe/037TeiPt4fCVJ9Y+SeQf8AM3016h8R4fwX/H/DdnT/AG3d+gaJUj5p+xd4/jN7S/E32BjP7F/pj0b5F6M+PS56T9S+cf1L5N689P8AT9Z/uOl1u/8Ao976BZtGPkN0v5Avy++I/wAnvhrXb389Oeket7k/CiUPVnyI9K/0z6O8163R8L+x8B4zpfk7foCk4W/it8LpB+FHx2+5d8LYK+RHtB5r6Z9f+z7o+KvnXn/9DeTeB7nZ4P8AT6ff8b+PZ9Bz0/8A2ifeE/8Agd92T4uf+kfvP77/AA+/9sfF+g//AA3yb/o+g//Z# base64 【解码】
import base64
def base64_decode_file(base64_data):
img_data = base64.b64decode(base64_data)
with open('1.jpg', 'wb') as f:
f.write(img_data)
# 输入
base64_decode_file("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")
# 输出：（是一个jpg图片文件）3、ASCLL码 编码解码
# ASCLL【编码】
def ASCLL_encode(string):
result = []
for a in string:
result = result + [ord(a)]
return result
# 输入
print(ASCLL_encode('你好'))
# 输出(列表)：[20320, 22909]# ASCLL【解码】
def ASCLL_decode(string):
result = ""
for a in eval(string):
result = result + chr(a)
return result
# 输入(列表)
print(ASCLL_decode('[20320, 22909]'))
# 输出：你好4、Unicode编码解码
# Unicode 【编码】 （仅对中文有效）
def str_to_unicode(str_data):
return str_data.encode('unicode_escape').decode('utf-8')
# 输入
print(str_to_unicode('你好'))
# 输出：\u4f60\u597d# Unicode 【解码】
def unicode_to_str(unicode_str):
return unicode_str
# 输入
print(unicode_to_str('\u4f60\u597d'))
# 输出：你好5、UTF-8编码解码
# UTF-8 【编码】
def utf8_encode(str_data):
return str_data.encode('utf-8')
# 输入
print(utf8_encode('你好'))
# 输出：b'\xe4\xbd\xa0\xe5\xa5\xbd'# UTF-8 【解码】
# 输入
print(b'\xe4\xbd\xa0\xe5\xa5\xbd'.decode('utf-8'))
# 输出：你好6、URL 编码解码
# 方法一
# URL 【编码】 （仅对中文有效）
import urllib.parse
def URL_encode(url):
return urllib.parse.quote(url)
# 输入
print(URL_encode('你好'))
# 输出：%E4%BD%A0%E5%A5%BD# 方法二
# URL 【编码】 （对所有字符串有效）
def URL_encode(url):
return ''.join([hex(ord(c)).replace('0x', '%') for c in url])
# 输入
print(URL_encode('http://www.baidu.com'))
# 输出：%68%74%74%70%3a%2f%2f%77%77%77%2e%62%61%69%64%75%2e%63%6f%6d# URL 【解码】
import urllib.parse
def URL_decode(url):
return urllib.parse.unquote(url)
# 输入
print(URL_decode('%E4%BD%A0%E5%A5%BD'))
# 输出：你好7、摩斯密码 编码解码(已补全)
# 摩斯密码字典 【必备 必须添加】（后续会更新更多）
# 摩斯密码会把正常的英文都统一为大写，输出会变为大写
# ！！！！加解密有限制，只能对 【英文和数字】 进行加解密。字典需更新
MORSE_CODE_DICT = {
'A':'.-','B':'-...','C':'-.-.','D':'-..',
'E':'.','F':'..-.','G':'--.','H':'....',
'I':'..', 'J':'.---', 'K':'-.-',
'L':'.-..', 'M':'--', 'N':'-.','O':'---', 'P':'.--.', 'Q':'--.-',
'R':'.-.', 'S':'...', 'T':'-',
'U':'..-', 'V':'...-', 'W':'.--',
'X':'-..-', 'Y':'-.--', 'Z':'--..',
'1':'.----', '2':'..---', '3':'...--',
'4':'....-', '5':'.....', '6':'-....',
'7':'--...', '8':'---..', '9':'----.',
'0':'-----', ', ':'--..--', '.':'.-.-.-',
'?':'..--..', '/':'-..-.', '-':'-....-',
'(':'-.--.', ')':'-.--.-'}# 摩斯密码【加密】 (通用版) 与互联网上的相匹配，可以通用 目前可加密所有，不包含空格
# 这个加密包不含空格，原本含有空格的字符串会被替换为无（不含空格的加密）
# 摩斯密码【加密】 加密中文和字符串
def Turn_Moss(MOSS):
if MOSS == '':
return ''
# 文字 ==》ASCLL==》二进制==》摩斯密码
return bin(int(ord(MOSS[0]))).replace('0b','').replace('0','.').replace('1','-')
# 加密字典内的内容
def morse_encode(message):
cipher = ''
set = 0
for letter in message.replace(' ','').upper():
if set == 1:
cipher += '/'
if ((letter != ' ') and (letter in MORSE_CODE_DICT.keys())) == True:
cipher += MORSE_CODE_DICT[letter]
set = 1
if letter not in MORSE_CODE_DICT.keys():
cipher += Turn_Moss(letter)
set = 1
return cipher
# 输入
print(morse_encode('123abc你好大哥😂😋##@@(*￣０￣)ノ▩'))
# 输出：.----/..---/...--/.-/-.../-.-./-..----.--...../-.--..-.-----.-/-.--..-..-..---/-.-.-..---..-.-/-----.--.......-./-----.--.....-.--/-...--/-...--/-....../-....../-.--./-.-.-./-----------...--/--------...-..../-----------...--/-.--.-/--....--..---./-..-.--.-.-..-# 摩斯密码【解密】 (通用版、部分表情解密不通用) 与互联网上的相匹配，可以通用 目前可解密密所有，不包含空格
# （不含空格的解密）
# 摩斯密码【解密】 解密中文和字符串
def Moss_Turn(Turn):
if Turn == '':
return ''
# 摩斯密码 ==》二进制==》十六进制==》ASCLL==》文字
try:
return chr(eval(str('0b')+str(Turn.replace('-','1').replace('.','0'))))
except:
return ['摩斯密码有错误！','1']
# 解密字典内的内容
def decode_morse_code(code):
code = code.replace('/',' ')
# 将摩斯密码字符串按空格分割
code_list = code.split(' ')
# 定义解密后的字符串
decode_str = ''
# 遍历摩斯密码字符串列表
for code_str in code_list:
# 将摩斯密码字符串从字典中取出对应的字符
if code_str in list(MORSE_CODE_DICT.values()):
decode_str += list(MORSE_CODE_DICT.keys())[list(MORSE_CODE_DICT.values()).index(code_str)]
else:
M = Moss_Turn(code_str)
# 出现错误
if len(M) == 2:
return M[0]
decode_str += M
# 返回解密后的字符串
return decode_str
# 输入
print(decode_morse_code('.----/..---/...--/.-/-.../-.-./-..----.--...../-.--..-.-----.-/-.--..-..-..---/-.-.-..---..-.-/-----.--.......-./-----.--.....-.--/-...--/-...--/-....../-....../-.--./-.-.-./-----------...--/--------...-..../-----------...--/-.--.-/--....--..---./-..-.--.-.-..-'))
# 输出：123ABC你好大哥😂😋##@@(*￣０￣)ノ▩# 摩斯密码【加密】 (修改版 私用) 加密后的摩斯密码只能通过下面的那个脚本进行解密
# 这个加密包含空格，原本含有空格的字符串都会加密（加密含空格）
# 摩斯密码【加密】 加密中文和字符串 (修改版 私用)
def Turn_Moss(MOSS):
if MOSS == '':
return ''
# 文字 ==》ASCLL==》二进制==》摩斯密码
return bin(int(ord(MOSS[0]))).replace('0b','').replace('0','.').replace('1','-')
# 摩斯密码加密 (修改版 私用)
def morses_encode(message):
cipher = ''
set = 0
for letter in message.upper():
if set != 0:
cipher += '/'
if letter in MORSE_CODE_DICT.keys():
cipher += MORSE_CODE_DICT[letter]
set += 1
if letter not in MORSE_CODE_DICT.keys():
if letter == ' ':
set = 0
cipher += '&/'
else:
cipher += Turn_Moss(letter)
set = 1
return cipher
print(morses_encode('123 ABC 你好！大哥😂😋##@@(*￣０￣)ノ▩'))
# 输出：.----/..---/...--/&/.-/-.../-.-./&/&/-..----.--...../-.--..-.-----.-/--------.......-/-.--..-..-..---/-.-.-..---..-.-/-----.--.......-./-----.--.....-.--/-...--/-...--/-....../-....../-.--./-.-.-./-----------...--/--------...-..../-----------...--/-.--.-/--....--..---./-..-.--.-.-..-
# 摩斯密码【解密】 (修改版 私用) 也可以用于互联网的加解密，可以通用，前提是字典要齐全
# （解密含空格）可通用
# 摩斯密码【解密】 解密中文和字符串 (修改版 私用)
def Moss_Turn(Turn):
if Turn == '':
return ''
# 摩斯密码 ==》二进制==》十六进制==》ASCLL==》文字
try:
return chr(eval(str('0b')+str(Turn.replace('-','1').replace('.','0'))))
except:
return ['摩斯密码有错误！','1']
# 摩斯密码解密 (修改版 私用)
def decodes_morse_code(code):
code = code.replace('/',' ')
# 将摩斯密码字符串按空格分割
code_list = code.split(' ')
# 定义解密后的字符串
decode_str = ''
# 遍历摩斯密码字符串列表
for code_str in code_list:
if code_str == '&':
decode_str += ' '
else:
# 将摩斯密码字符串从字典中取出对应的字符
if code_str in list(MORSE_CODE_DICT.values()):
decode_str += list(MORSE_CODE_DICT.keys())[list(MORSE_CODE_DICT.values()).index(code_str)]
else:
M = Moss_Turn(code_str)
# 出现错误
if len(M) == 2:
return M[0]
decode_str += M
# 返回解密后的字符串
return decode_str
print(decodes_morse_code('.----/..---/...--/&/.-/-.../-.-./&/&/-..----.--...../-.--..-.-----.-/--------.......-/-.--..-..-..---/-.-.-..---..-.-/-----.--.......-./-----.--.....-.--/-...--/-...--/-....../-....../-.--./-.-.-./-----------...--/--------...-..../-----------...--/-.--.-/--....--..---./-..-.--.-.-..-'))
# 输出：123 ABC 你好！大哥😂😋##@@(*￣０￣)ノ▩8、hexstr 编码解码
# hexstr 【编码】
import binascii
def hexstr_encode(data):
return binascii.b2a_hex(data.encode()).decode()
# 输入
print(hexstr_encode('你好'))
# 输出：e4bda0e5a5bd# hexstr 【解码】
import binascii
def encode_hexstr(data):
return binascii.a2b_hex(data).decode()
# 输入
print(encode_hexstr('e4bda0e5a5bd'))
# 输出：你好9、Escape 编码解码
# Escape 【编码】 %u4f60 %u597d
def Escape_to_unicode(str_data):
d = ''
for a in str_data:
g = hex(ord(a))[2:]
if len(g) == 1:
d += "%u000" + g
if len(g) == 2:
d += "%u00" + g
if len(g) == 3:
d += "%u0" + g
if len(g) in [4,5,6,7,8]:
d += "%u" + g
return d
# 输入
print(Escape_to_unicode('你好 Abc123😎🤗'))
# 输出：%u4f60%u597d%u0020%u0041%u0062%u0063%u0031%u0032%u0033%u1f60e%u1f91717# Escape 【解码】
def unicode_to_Escape(unicode_str):
unicode_str = unicode_str.split('%u')
del (unicode_str)[0]
d = ''
for a in list(unicode_str):
d += chr(int(str(int(''.join('0x'+a),16))))
return d
# 输入
print(unicode_to_Escape('%u4f60%u597d%u0020%u0041%u0062%u0063%u0031%u0032%u0033%u1f60e%u1f917'))
# 输出：你好 Abc123😎🤗四、字符串转换📚
1、中文&繁体
# 简体转繁体
import opencc
def convert_opencc(text):
return opencc.OpenCC('s2t').convert(text)
# 输入
print(convert_opencc('线类'))
# 输出：線類# 繁体转简体
import opencc
def opencc_convert(text):
return opencc.OpenCC('t2s').convert(text)
# 输入
print(opencc_convert('線類'))
# 输出：线类2、字符串 大写&小写
# 字符串转大写
def exchange_upper(str):
return str.upper()
# 输入
print(exchange_upper('abc'))
# 输出：ABC# 字符串转小写
def exchange_lower(str):
return str.lower()
# 输入
print(exchange_lower('ABC'))
# 输出：abc3、字符串 全角&半角
# 半角转全角
def strB2Q(ustring):
"""半角转全角"""
rstring = ""
for uchar in ustring:
inside_code=ord(uchar)
if inside_code == 32: # 半角空格直接转化
inside_code = 12288
elif inside_code >= 32 and inside_code <= 126: # 半角字符（除空格）根据关系转化
inside_code += 65248
rstring += chr(inside_code)
return rstring
# 输入
print(strB2Q('123abc'))
# 输出：１２３ａｂｃ# 全角转半角
def strQ2B(ustring):
"""全角转半角"""
rstring = ""
for uchar in ustring:
inside_code = ord(uchar)
if inside_code == 12288: # 全角空格直接转换
inside_code = 32
elif (inside_code >= 65281 and inside_code <= 65374): # 全角字符（除空格）根据关系转化
inside_code -= 65248
rstring += chr(inside_code)
return rstring
# 输入
print(strQ2B('１２３ａｂｃ'))
# 输出：123abc4、时间戳 & 日期
# 日期转时间戳
import time
def Unix_time(times):
# 转换为时间戳,将"%Y-%m-%d %H:%M:%S"转换为 1672989181字符串
return int(time.mktime(time.strptime(times, '%Y-%m-%d %H:%M:%S')))
# 输入
print(Unix_time('2023-01-01 15:12:07'))
# 输出：1672557127# 时间戳转日期
import time
def time_Unix(times):
# 转换为其他日期格式,如:"%Y-%m-%d %H:%M:%S"
return time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(times))
# 输入
print(time_Unix('1672557127'))
# 输出：2023-01-01 15:12:075、颜色 HEX & RGB & CMYK
# HEX 转 RGB(元组)
def hex_to_rgb(hex_color):
hex_color = hex_color.lstrip('#')
lv = len(hex_color)
return tuple(int(hex_color[i:i + lv // 3], 16) for i in range(0, lv, lv // 3))
# 输入
print(hex_to_rgb('#FFFFFF'))
# 输出(元组)：(255, 255, 255)# RGB(元组) 转 HEX
def rgb_to_hex(rgb_color):
return '#%02x%02x%02x' % rgb_color
# 输入(元组)
print(rgb_to_hex((255, 255, 255)))
# 输出：#FFFFFF# RGB(元组) 转 CMYK(元组)
def rgb_to_cmyk(rgb):
r = rgb[0] / 255.0
g = rgb[1] / 255.0
b = rgb[2] / 255.0
c = 1 - r
m = 1 - g
y = 1 - b
k = min(c, m, y)
c = (c - k) / (1 - k)
m = (m - k) / (1 - k)
y = (y - k) / (1 - k)
cmyk = (c, m, y, k)
return cmyk
# 输入(元组)
print(rgb_to_cmyk((198, 254, 234)))
# 输出(元组)：(0.2204724409448819, 0.0, 0.07874015748031502, 0.0039215686274509665)# CMYK(元组) 转 RGB(元组)
def cmyk_to_rgb(cmyk):
c = cmyk[0]
m = cmyk[1]
y= cmyk[2]
k = cmyk[3]
r = int(255 * (1 - c) * (1 - k))
g = int(255 * (1 - m) * (1 - k))
b = int(255 * (1 - y) * (1 - k))
rgb = (r, g, b)
return rgb
# 输入(元组)
print(cmyk_to_rgb((0.2204724409448819, 0.0, 0.07874015748031502, 0.0039215686274509665)))
# 输出(元组)：(198, 254, 234)五、进制转换📦
1、【2进制】 转 4进制、8进制、10进制、16进制、32进制
# 2进制 转 4进制
def binary_to_quaternary(binary):
# 将2进制转换为10进制
decimal = int(binary, 2)
# 将10进制转换为4进制
quaternary = ''
while decimal != 0:
remainder = decimal % 4
decimal = decimal // 4
quaternary = str(remainder) + quaternary
return quaternary
# 输入
print(binary_to_quaternary('1101110110111'))
# 输出：1232313# 2进制 转 8进制
# 输入
print(oct(int('1101110110111',2))) # 2进制 转 8进制
# 输出：0o15667# 2进制 转 10进制
# 输入
print(str(int('1101110110111',2))) # 2进制 转 10进制
# 输出：7095# 2进制 转 16进制
# 输入
print(hex(int('1101110110111',2))) # 2进制 转 16进制
# 输出：0x1bb7# 2进制 转 32进制
def binary_to_base32(binary):
# 定义一个字典，用于存储2进制到32进制的映射关系
base32_dict = {
'00000': '0',
'00001': '1',
'00010': '2',
'00011': '3',
'00100': '4',
'00101': '5',
'00110': '6',
'00111': '7',
'01000': '8',
'01001': '9',
'01010': 'A',
'01011': 'B',
'01100': 'C',
'01101': 'D',
'01110': 'E',
'01111': 'F',
'10000': 'G',
'10001': 'H',
'10010': 'I',
'10011': 'J',
'10100': 'K',
'10101': 'L',
'10110': 'M',
'10111': 'N',
'11000': 'O',
'11001': 'P',
'11010': 'Q',
'11011': 'R',
'11100': 'S',
'11101': 'T',
'11110': 'U',
'11111': 'V'
}
binary = (5 - len(binary) % 5) * '0' + binary
# 将2进制字符串转换为列表
binary_list = list(binary)
# 将2进制列表转换为5位2进制字符串的列表
binary_list_5 = [binary_list[i:i+5] for i in range(0, len(binary_list), 5)]
# 将2进制字符串列表转换为32进制字符串
base32_str = ''
for binary_str in binary_list_5:
base32_str += base32_dict[''.join(binary_str)]
return base32_str
# 输入
print(binary_to_base32('1101110110111'))
# 输出：6TN2、【4进制】 转 2进制、8进制、10进制、16进制、32进制
# 4进制 转 2进制
# 输入
print(bin(int('1101110110111',4)))
# 输出：0b1010001010100010100010101# 4进制 转 8进制
# 输入
print(oct(int('1101110110111',4)))
# 输出：0o121242425# 4进制 转 10进制
# 输入
print(str(int('1101110110111',4)))
# 输出：21316885# 4进制 转 16进制
# 输入
print(hex(int('1101110110111',4)))
# 输出：0x1454515# 4进制 转 32进制
def binary_to_base32(binary):
# 4进制 转 2进制
binary = bin(int(binary,4))
if binary[0:][:2] == '0b':
binary = binary.replace('0b','')
# 2进制 转 32进制
# 定义一个字典，用于存储2进制到32进制的映射关系
base32_dict = {
'00000': '0',
'00001': '1',
'00010': '2',
'00011': '3',
'00100': '4',
'00101': '5',
'00110': '6',
'00111': '7',
'01000': '8',
'01001': '9',
'01010': 'A',
'01011': 'B',
'01100': 'C',
'01101': 'D',
'01110': 'E',
'01111': 'F',
'10000': 'G',
'10001': 'H',
'10010': 'I',
'10011': 'J',
'10100': 'K',
'10101': 'L',
'10110': 'M',
'10111': 'N',
'11000': 'O',
'11001': 'P',
'11010': 'Q',
'11011': 'R',
'11100': 'S',
'11101': 'T',
'11110': 'U',
'11111': 'V'
}
binary = (5 - len(binary) % 5) * '0' + binary
# 将2进制字符串转换为列表
binary_list = list(binary)
# 将2进制列表转换为5位2进制字符串的列表
binary_list_5 = [binary_list[i:i+5] for i in range(0, len(binary_list), 5)]
# 将2进制字符串列表转换为32进制字符串
base32_str = ''
for binary_str in binary_list_5:
base32_str += base32_dict[''.join(binary_str)]
return base32_str
# 输入
print(binary_to_base32('11011101101111011'))
# 输出：52KA5A53、【8进制】 转 2进制、4进制、10进制、16进制、32进制
# 8进制 转 2进制
# 输入
print(bin(int('1101110110111',8)))
# 输出：0b1001000001001001000001001000001001001# 8进制 转 4进制
def binary_to_quaternary(binary):
# 将8进制转换为10进制
decimal = int(binary,8)
# 将10进制转换为4进制
quaternary = ''
while decimal != 0:
remainder = decimal % 4
decimal = decimal // 4
quaternary = str(remainder) + quaternary
return quaternary
# 输入
print(binary_to_quaternary('1101110110111'))
# 输出：1020021020021001021# 8进制 转 10进制
# 输入
print(str(int('1101110110111',8)))
# 输出：77462540361# 8进制 转 16进制
# 输入
print(hex(int('1101110110111',8)))
# 输出：0x1209209049# 8进制 转 32进制
def binary_to_base32(binary):
# 8进制 转 2进制
binary = bin(int(binary,8))
if binary[0:][:2] == '0b':
binary = binary.replace('0b','')
# 2进制 转 32进制
# 定义一个字典，用于存储2进制到32进制的映射关系
base32_dict = {
'00000': '0',
'00001': '1',
'00010': '2',
'00011': '3',
'00100': '4',
'00101': '5',
'00110': '6',
'00111': '7',
'01000': '8',
'01001': '9',
'01010': 'A',
'01011': 'B',
'01100': 'C',
'01101': 'D',
'01110': 'E',
'01111': 'F',
'10000': 'G',
'10001': 'H',
'10010': 'I',
'10011': 'J',
'10100': 'K',
'10101': 'L',
'10110': 'M',
'10111': 'N',
'11000': 'O',
'11001': 'P',
'11010': 'Q',
'11011': 'R',
'11100': 'S',
'11101': 'T',
'11110': 'U',
'11111': 'V'
}
binary = (5 - len(binary) % 5) * '0' + binary
# 将2进制字符串转换为列表
binary_list = list(binary)
# 将2进制列表转换为5位2进制字符串的列表
binary_list_5 = [binary_list[i:i+5] for i in range(0, len(binary_list), 5)]
# 将2进制字符串列表转换为32进制字符串
base32_str = ''
for binary_str in binary_list_5:
base32_str += base32_dict[''.join(binary_str)]
return base32_str
# 输入
print(binary_to_base32('1101110110111'))
# 输出：284I14294、【10进制】 转 2进制、4进制、8进制、16进制、32进制
# 10进制 转 2进制
# 输入
print(bin(int('1101110110111',10)))
# 输出：0b1001000001001001000001001000001001001# 10进制 转 4进制
def dec2four(num):
# 定义一个空列表，用于存放转换后的四进制数
four_list = []
num = int(num)
# 循环，直到num为0
while num != 0:
# 将num除以4的余数添加到列表中
four_list.append(num % 4)
# 将num除以4，得到新的num
num = num // 4
# 将列表中的数字反转
four_list.reverse()
# 将列表中的数字转换为字符串
four_str = ''.join(str(i) for i in four_list)
# 返回转换后的四进制数
return four_str
# 输入
print(dec2four('1101110110111'))
# 输出：100001133101232132133# 10进制 转 8进制
# 输入
print(oct(int('1101110110111',10)))
# 输出：0o20013721563637# 10进制 转 16进制
# 输入
print(hex(int('1101110110111',10)))
# 输出：0x1005f46e79f# 10进制 转 32进制
def binary_to_base32(num, b = 32):
num = int(num)
return ((num == 0) and "0") or (binary_to_base32(num // b, b).lstrip("0") + "0123456789abcdefghijklmnopqrstuvwxyz"[num % b])
# 输入
print(binary_to_base32('1101110110111'))
# 输出：101fkdpsv5、【16进制】 转 2进制、4进制、8进制、10进制、32进制
# 16进制 转 2进制
# 输入
print(bin(int('1241241243',16)))
# 输出：0b1001001000001001001000001001001000011# 16进制 转 4进制
def binary_to_quaternary(binary):
# 将16进制转换为10进制
decimal = int(binary, 16)
# 将10进制转换为4进制
quaternary = ''
while decimal != 0:
remainder = decimal % 4
decimal = decimal // 4
quaternary = str(remainder) + quaternary
return quaternary
# 输入
print(binary16_to_quaternary('1241241243'))
# 输出：1021001021001021003# 16进制 转 8进制
# 输入
print(oct(int('1241241243',16)))
# 输出：0o1110111011103# 16进制 转 10进制
# 输入
print(str(int('1241241243',16)))
# 输出：78402294339# 16进制 转 32进制
def binary_to_base32(binary):
# 16进制 转 2进制
binary = bin(int(binary,16))
if binary[0:][:2] == '0b':
binary = binary.replace('0b','')
# 2进制 转 32进制
# 定义一个字典，用于存储2进制到32进制的映射关系
base32_dict = {
'00000': '0',
'00001': '1',
'00010': '2',
'00011': '3',
'00100': '4',
'00101': '5',
'00110': '6',
'00111': '7',
'01000': '8',
'01001': '9',
'01010': 'A',
'01011': 'B',
'01100': 'C',
'01101': 'D',
'01110': 'E',
'01111': 'F',
'10000': 'G',
'10001': 'H',
'10010': 'I',
'10011': 'J',
'10100': 'K',
'10101': 'L',
'10110': 'M',
'10111': 'N',
'11000': 'O',
'11001': 'P',
'11010': 'Q',
'11011': 'R',
'11100': 'S',
'11101': 'T',
'11110': 'U',
'11111': 'V'
}
binary = (5 - len(binary) % 5) * '0' + binary
# 将2进制字符串转换为列表
binary_list = list(binary)
# 将2进制列表转换为5位2进制字符串的列表
binary_list_5 = [binary_list[i:i+5] for i in range(0, len(binary_list), 5)]
# 将2进制字符串列表转换为32进制字符串
base32_str = ''
for binary_str in binary_list_5:
base32_str += base32_dict[''.join(binary_str)]
return base32_str
# 输入
print(binary16_to_base32('1241241243'))
# 输出：290I84I36、【32进制】 转 2进制、4进制、8进制、10进制、16进制
# 32进制 转 2进制
# 输入
print(bin(int('123456789',32)))
# 输出：0b10001000011001000010100110001110100001001# 32进制 转 4进制
def binary_to_quaternary(binary):
# 将32进制转换为10进制
decimal = int(binary, 32)
# 将10进制转换为4进制
quaternary = ''
while decimal != 0:
remainder = decimal % 4
decimal = decimal // 4
quaternary = str(remainder) + quaternary
return quaternary
# 输入
print(binary_to_quaternary('123456789'))
# 输出：101003020110301310021# 32进制 转 8进制
# 输入
print(oct(int('123456789',32)))
# 输出：0o21031024616411# 32进制 转 10进制
# 输入
print(str(int('123456789',32)))
# 输出：1171591994633# 32进制 转 16进制
# 输入
print(hex(int('123456789',32)))
# 输出：0x110c8531d09六、生成&解析&清除📦
1、RSA 生成密钥对
# RSA 生成密钥对
'''
公钥：可以使用公钥直接加密字符串，如果生成密钥对的时候添加了证书密码，无需证书密码可以直接加密字符串，但解密需要证书密码和私钥才可以解密
私钥：可以使用私钥直接加密字符串，如果生成密钥对的时候添加了证书密码，则需要证书密码才可以使用私钥进行加密，解密无需证书密码，可以直接用公钥进行解密
使用方法：
--生成密钥对(无证书密码)--
加密：公钥+字符串 | 私钥+字符串
解密：私钥+字符串 | 公钥+字符串
--生成密钥对(有证书密码)--
加密：公钥+字符串 | 私钥+证书密码+字符串
解密：私钥+证书密码+字符串 | 公钥+字符串
'''
from Crypto.PublicKey import RSA
def RSA_key(password=None,bits=1024,e=3):
'''
password: 证书密码 默认为无
bits: 字节 默认为1024 可选【1024,2048,3072,4096】
e: 公钥指数 默认为3 可随意填写 最大值为65537， 推荐使用【3、17、65537】
'''
if password == '':
password = None
# 生成新的RSA密钥
key = RSA.generate(bits,e=e) # 3、17、65537
# 私钥
private_key = key.export_key(format="PEM",passphrase=password)
# 公钥
public_key = key.publickey().export_key()
f = open("公钥_pub_key.pem", "wb")
f.write(public_key)
f.close()
f = open("私钥_priv_key.pem", "wb")
f.write(private_key)
f.close()
# 输入
RSA_key(password='12345678',bits=3072)
# 输出：（两个文件：一个私钥文件[私钥_priv_key.pem]，一个公钥文件[公钥_pub_key.pem]）2、RSA 私钥解析出公钥
# RSA 使用私钥文件解析生成公钥
from Crypto.PublicKey import RSA
def pub_open(file='',password=None):
'''
file: 私钥文件 必输入项 输入私钥文件路径
password: 如果私钥有证书密码，则需要输入，否则不用输入
'''
try:
if password == '':
password = None
# 读取私钥文件
with open(file, 'rb') as f:
key = f.read()
# 将字符串解码为RSA私钥
rsa_key = RSA.importKey(key,passphrase=password)
# 将RSA私钥转换为公钥
public_key = rsa_key.publickey()
# 将公钥导出到字符串
public_key_string = public_key.exportKey()
# 将公钥字符串保存到文件
with open('公钥_pub_key.pem', 'wb') as f:
f.write(public_key_string)
except:
pritn('请检查私钥是否有证书密码，公钥生成失败！')
# 输入
pub_open(file='私钥_priv_key.pem',password='12345678')
# 输出：（一个公钥文件[公钥_pub_key.pem]）3、RSA 私钥 【清除-修改-添加】 证书密码
# RSA 私钥 清除-修改-添加 密码
# 私钥的密码修改后，建议将私钥重新解析生成一个公钥
from Crypto.PublicKey import RSA
def RSA_DELETE(file='',password=None,NEW_password=None):
'''
file: 要清除私钥的文件路径
password: 私钥的当前密码 如果当前私钥无证书密码 可以不填
NEW_password: 私钥的新密码 如果不想添加私钥无证书密码 可以不填 会无密码
'''
if NEW_password == '':
NEW_password = None
if password == '':
password = None
with open(file, 'rb') as key:
# 加载RSA私钥
key2 = RSA.importKey(key.read(),passphrase=password)
# 清除私钥中的密码
key2.publickey = None
# 保存清除后的私钥
open('已修改_私钥_priv_key.pem', 'wb').write(key2.exportKey('PEM',passphrase=NEW_password))
# 输入(清除密码)
RSA_DELETE(file='私钥_priv_key.pem',password='123abc',NEW_password='')
# 输出：（无密码的私钥文件[已修改_私钥_priv_key.pem]）
# 输入(修改密码)
RSA_DELETE(file='私钥_priv_key.pem',password='123abc',NEW_password='12345678')
# 输出：（修改后的私钥文件[已修改_私钥_priv_key.pem]） 证书密码已修改成 12345678
# 输入(添加密码)
RSA_DELETE(file='私钥_priv_key.pem',password='',NEW_password='12345678')
# 输出：（添加密码后的私钥文件[已修改_私钥_priv_key.pem]） 证书密码已添加 123456784、RSA 私钥解析
# 私钥解析
from Crypto.PublicKey import RSA
def parse_rsa_key(file='',password=None):
"""
file：私钥文件
password：私钥证书密码，如果没有则不填
解析：RSA模数、私有指数、因子、中文余数组件、长度、数据块、公有指数
"""
if password == '':
password = None
with open(file, 'rb') as key:
key = key.read()
rsa_key = RSA.importKey(key,passphrase=password)
print('是否是私钥：',rsa_key.has_private())
print('RSA模数(n)：', rsa_key.n)
print('私有指数(d)：', rsa_key.d)
print('RSA模量的第一个因子(p)：', rsa_key.p)
print('RSA模量的第二因子(q)：', rsa_key.q)
print('中文余数组件(u)：', rsa_key.u)
print('_dp：',rsa_key._dp)
print('_dq：',rsa_key._dq)
print('key长度：', rsa_key.size_in_bits())
print('数据块：', rsa_key.size_in_bytes())
print('公有指数(e)：', hex(rsa_key.e))
# 输入
parse_rsa_key(file='私钥_priv_key.pem',password='312')
# 输出：
是否是私钥： True
RSA模数(n)： 153254643885489667325544302182852719616776132530548243501092207066374574394232277170402266035078156205473992240564691794575449465428596249264268849980572218691782532780845082561592504311962907862607613042793261622892779888388298392376226279087811370537200391092122357610373235672913747468035403351018939310729
私有指数(d)： 68595933956954909460724728935285436886621466830204345253231591346644365248339252918451867981033349621303600842039224699056658599247485273599921608333156914971498199300796324548103811991486174136099769901230603735082340894238618464297200735323743007827787199211424194680892259918497380543882879970375162479705
RSA模量的第一个因子(p)： 12759010976818548615524338606887335485270939299665725512694231118469026100698012083031823895177730429232525170715997253329216709842441403500229315902936067
RSA模量的第二因子(q)： 12011483034534046357201940625232426243265372185333945430902272782467098055801180614080054802348666534925025017113529611484888106719893187698287092106278787
中文余数组件(u)： 11209349286964155947940245668010874868990663227665540941699280759299379610823406100061882085723261599750064236908833969673386123582465108793237336617327686
_dp： 9319527220658619134613273251929394840775742928040622553560169730703454223422094975582242242735522768014419029283836436163840332944102872965744195679899133
_dq： 3618638647387585810711431949960923199826533232025167746276675371424239498508300807855052901682592612807417091686978785253484760960641639042296418001226305
key长度： 1024
数据块： 128
公有指数(e)： 0x100015、RSA 通过私钥的【RSA模数+公有指数】生成公钥
# 通过【RSA模数+公有指数】 生成公钥
from Crypto.PublicKey import RSA
def res_modulus_exponent(modulus,exponent):
'''
modulus: RSA模数
exponent: 公有指数
'''
# RSA模数
modulus = int(modulus)
# 公有指数
exponent = int(exponent)
key = RSA.construct((modulus,exponent))
pubkey = key.publickey().exportKey()
open('生成的公钥_pub_key.pem', 'wb').write(pubkey)
# 输入
res_modulus_exponent(153254643885489667325544302182852719616776132530548243501092207066374574394232277170402266035078156205473992240564691794575449465428596249264268849980572218691782532780845082561592504311962907862607613042793261622892779888388298392376226279087811370537200391092122357610373235672913747468035403351018939310729,0x10001)
# 输出：（一个公钥文件[生成的公钥_pub_key.pem]）6、RSA 私钥与公钥效验
# RSA 私钥与公钥效验
from Crypto.PublicKey import RSA
def pub_open(file1='',file2='',password=None):
'''
:param file1:私钥文件 必输入项 输入私钥文件路径
:param file2:公钥文件 必输入项 输入私钥文件路径
:param password: 如果私钥有证书密码，则需要输入，否则不用输入:
'''
'''
file1: 私钥文件 必输入项 输入私钥文件路径
file2: 公钥钥文件 必输入项 输入私钥文件路径
password: 如果私钥有证书密码，则需要输入，否则不用输入
'''
if password == '':
password = None
# 读取私钥文件
with open(file1, 'rb') as f:
key = f.read()
try:
# 将字符串解码为RSA私钥
rsa_key = RSA.importKey(key,passphrase=password)
except:
return '请输入正确的证书密码，或者不填！！！！'
# 将RSA私钥转换为公钥
public_key = rsa_key.publickey()
# 将公钥导出到字符串
public_key_string = public_key.exportKey()
with open(file2, 'rb') as f:
key2 = f.read()
if public_key_string in key2:
return '私钥与公钥效验成功'
else:
return '私钥与公钥对不上，请检查密码是否错误或别的原因！！'
# 输入
print(pub_open(file1='私钥_priv_key.pem',file2='公钥_pub_key.pem',password='12341'))
# 输出：私钥与公钥效验成功7、UUID 生成
# UUID生成 UUID共由五段组成
# [0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}
# 第一段有8个字符串 第二段、第三段、第四段都是由4个字符串组成 第五段是由12个字符串组成
# 所有的字符串是只能是 《1234567890abcdef》，完整的UUID是36位(包含横杠)
# 生成UUID
import random
def get_uuid():
uuid = ""
for i in range(32):
if i in [8, 12, 16, 20]:
uuid += "-"
uuid += hex(random.randint(0, 15))[2:]
return uuid
# 输入
print(get_uuid())
# 输出：13924daa-59e0-f7e6-fea7-ed8e0e553f2e8、UUID 效验
# 效验UUID
def uuid_in(uuid):
uuid = str(uuid)
if len(uuid) != 36:
return '错误'
for a in range(32):
if a in [8,13,18,23]:pass
else:
if uuid[a] in ['0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f']:pass
else:
return '错误'
return '正确'
# 输入
print(uuid_in('13924daa-59e0-f7e6-fea7-ed8e0e553f2e'))
# 输出：正确9、时间戳生成
# 时间戳生成
import time
# 输入
print(time.time())
# 输出：1672557127
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
