├── requirements.txt ├── README.md ├── public_key.pem ├── BigIPCookieDecoder.py ├── SM4.py ├── RSA2.py ├── SM2.py ├── private_key.pem ├── RSA.py ├── WeChatApp.py ├── AES.py ├── common.py ├── RSA3.py └── RSASign.py /requirements.txt: -------------------------------------------------------------------------------- 1 | cryptography==36.0.2 2 | gmssl==3.2.2 3 | pycryptodome==3.11.0 4 | rsa==4.9 5 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # My-encryption-template 2 | 3 | 一些渗透测试相关的加解密方法的实现，封装成类或函数，方便编写 Burpy 脚本的时候直接调用。 4 | 5 | > 以上都是基于Python3实现。 6 | 7 | 例如网站登录密码加密的rsa、aes。 8 | 9 | 金融站点的sm2、sm4加解密算法。 10 | 11 | 微信小程序sessionKey泄露的加解密算法。 12 | 13 | F5-Big-Ip cookie泄露的解密算法。 14 | 15 | 还有一些常见的例如 uuid、md5、base64、中文字符串转 `\xe7\xaf\xae\xe7\x90\x83`。 16 | 17 | ## 其他 18 | 19 | 如果还有其他需要补充的欢迎提供。 -------------------------------------------------------------------------------- /public_key.pem: -------------------------------------------------------------------------------- 1 | -----BEGIN PUBLIC KEY----- 2 | MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAm8kPgp7ed4m69hcIkAzL 3 | zyvy7Q8oUyuTJ5hX/Z6nz/f+IJAWCDd7s2QaznbvXmEPOi3r7SeoRlIVRXXhmVwE 4 | 8FH3JfhgXufd6vS1TntdVOAbhAOMYEwZzdqTvW7QogJoatD9AczN39ySeZ77ltn1 5 | jb5sI0Yh9XCA/ldaPXKj2u141WQlg00g8CjFE0+CzwgrF+6sNStdG+tnE2tE0aPY 6 | 1Y3yorD8oFhCPLGC7dzBMzmOOO07JbQqPwPldj0aRpAh0+ThA7hCcM2+cQu8x1dq 7 | +foGmd2G1J4zgebIsJ92H9YNQSKZ3Kr43/c0pLVWTIVJGI1JFTlX9dun3axRHtg3 8 | 5QIDAQAB 9 | -----END PUBLIC KEY----- -------------------------------------------------------------------------------- /BigIPCookieDecoder.py: -------------------------------------------------------------------------------- 1 | # python3 2 | import struct 3 | import binascii 4 | import struct 5 | 6 | def decode(cookie_value): 7 | (host, port, end) = cookie_value.split('.') 8 | [a, b, c, d] = struct.unpack(" None: 7 | self.key = key 8 | self.crypt_sm4 = CryptSM4() 9 | 10 | def encrypt_ecb(self, plaintext): 11 | self.crypt_sm4.set_key(self.key, SM4_ENCRYPT) 12 | encrypt_value = self.crypt_sm4.crypt_ecb(plaintext) 13 | return encrypt_value 14 | 15 | def decrypt_ecb(self, ciphertext): 16 | self.crypt_sm4.set_key(self.key, SM4_DECRYPT) 17 | decrypt_value = self.crypt_sm4.crypt_ecb(ciphertext).decode() 18 | return decrypt_value 19 | 20 | def encrypt_cbc(self, iv, plaintext): 21 | self.crypt_sm4.set_key(self.key, SM4_ENCRYPT) 22 | encrypt_value = self.crypt_sm4.crypt_cbc(iv, plaintext) 23 | return encrypt_value 24 | 25 | def decrypt_cbc(self, iv, ciphertext): 26 | self.crypt_sm4.set_key(self.key, SM4_DECRYPT) 27 | decrypt_value = self.crypt_sm4.crypt_cbc(iv, ciphertext).decode() 28 | return decrypt_value 29 | 30 | if __name__ == '__main__': 31 | key = b'3l5butlj26hvv313' 32 | iv = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' # bytes类型 33 | payload = b'123456' 34 | mys4 = MySM4(key) 35 | # result = mys4.encrypt_ecb(payload) 36 | # result = mys4.decrypt_ecb(result) 37 | 38 | result = mys4.encrypt_cbc(iv, payload) 39 | result = mys4.decrypt_cbc(iv, result) 40 | print(result) 41 | -------------------------------------------------------------------------------- /RSA2.py: -------------------------------------------------------------------------------- 1 | from cryptography.hazmat.backends import default_backend 2 | from cryptography.hazmat.primitives.asymmetric import rsa 3 | from cryptography.hazmat.primitives.asymmetric import padding 4 | import base64 5 | 6 | class RSAPadding(): 7 | """ 8 | RSA 加密，有填充 9 | """ 10 | def __init__(self, e, m) -> None: 11 | self.e = e 12 | self.m = m 13 | 14 | def data_encrypt(self, text): 15 | """ 16 | RSA 加密 17 | :param text: 加密前内容 18 | :return: 加密后内容 19 | """ 20 | public_exponent = int(self.e,16) 21 | public_modulus= int(self.m, 16) 22 | content = text 23 | max_length = 117 24 | public_key = rsa.RSAPublicNumbers(public_exponent, public_modulus).public_key(default_backend()) 25 | data = b'' 26 | for i in range(0, len(content), max_length): 27 | data += public_key.encrypt(content[i: i + max_length].encode(), 28 | padding.PKCS1v15()) 29 | data = base64.b64encode(data).decode() 30 | return data 31 | 32 | if __name__ == '__main__': 33 | e = "10001" 34 | m = 'B23322F080BD5876C0735D585D25C7BC409F637237B07744D27FBF39FB100ABE59DF380EA6BFCDF28C286E7A0CD95BE87F6099F8F39B0E97D9782C3D33FCFB80D43D2F22A9D9417ECFD1A0B8421DEE1CD4B323E8078336E77419A97F94E60A90CA06551202F63819FC8E73425F06ECA4C05BBF8CA32366240A6C36CA61D85019' 35 | plaintext = '123456' 36 | rsap = RSAPadding(e, m) 37 | r = rsap.data_encrypt(plaintext) 38 | print(r) -------------------------------------------------------------------------------- /SM2.py: -------------------------------------------------------------------------------- 1 | import base64 2 | import binascii 3 | from gmssl import sm2, func 4 | 5 | class SM2: 6 | """ 7 | 非对称算法 SM2 加解密脚本 8 | """ 9 | def __init__(self, private_key, public_key): 10 | """ 11 | 初始化sm2 12 | """ 13 | self.sm2_crypt = sm2.CryptSM2(public_key=public_key, private_key=private_key) 14 | 15 | def sm2_decrypt(self, ciphertext_payload:bytes): 16 | """ 17 | 解密函数 18 | """ 19 | dec_data = self.sm2_crypt.decrypt(ciphertext_payload) 20 | return dec_data 21 | 22 | def sm2_encrypt(self, plaintext_payload:bytes): 23 | """ 24 | 加密函数 25 | """ 26 | enc_data = self.sm2_crypt.encrypt(plaintext_payload) 27 | return enc_data 28 | 29 | if __name__ == "__main__": 30 | plaintext_payload = b'111' 31 | ciphertext_payload = b"\xcb\xa4>^H\xe1\x0c\xabK\x82\x00b\x82\x800%R!\x0c\xfb6\x19\x11\x06\x91Q\xa34\xe0\xb2\xb53\xd7%\xbdP\xef\xa0\x8b\\\xf7sT\x7f\xb21H\xc1\xe3\x13\xcbo\x01\xda\xbep\xce\xf0W\xab\x0e\x8d\xb6\xc8\x9b\xd0\xf9\x7f\xbe\x8eO\x8b\xa4\x90l\xb4\xff\xbf)\x1e\xba<\xad\x80N\x19j\xebJ'%\xf3\x90\xb2g\xf97\n\xe7" 32 | #16进制的公钥和私钥 33 | private_key = '00B9AB0B828FF68872F21A837FC303668428DEA11DCD1B24429D0C99E24EED83D5' 34 | public_key = 'B9C9A6E04E9C91F7BA880429273747D7EF5DDEB0BB2FF6317EB00BEF331A83081A6994B8993F3F5D6EADDDB81872266C87C018FB4162F5AF347B483E24620207' 35 | sm2 = SM2(private_key, public_key) 36 | # r = sm2.sm2_encrypt(plaintext_payload) 37 | r = sm2.sm2_decrypt(ciphertext_payload) 38 | print(r) 39 | -------------------------------------------------------------------------------- /private_key.pem: -------------------------------------------------------------------------------- 1 | -----BEGIN PRIVATE KEY----- 2 | MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCbyQ+Cnt53ibr2 3 | FwiQDMvPK/LtDyhTK5MnmFf9nqfP9/4gkBYIN3uzZBrOdu9eYQ86LevtJ6hGUhVF 4 | deGZXATwUfcl+GBe593q9LVOe11U4BuEA4xgTBnN2pO9btCiAmhq0P0BzM3f3JJ5 5 | nvuW2fWNvmwjRiH1cID+V1o9cqPa7XjVZCWDTSDwKMUTT4LPCCsX7qw1K10b62cT 6 | a0TRo9jVjfKisPygWEI8sYLt3MEzOY447TsltCo/A+V2PRpGkCHT5OEDuEJwzb5x 7 | C7zHV2r5+gaZ3YbUnjOB5siwn3Yf1g1BIpncqvjf9zSktVZMhUkYjUkVOVf126fd 8 | rFEe2DflAgMBAAECggEAGXOAwDNaXyc2T0w2Duq4RXGFr6shSG0/DmH6RiosenKm 9 | pwVDRDZkVEuPgZm2w7GRvkyQVd97w3lXllCK+fYprGWHvkFU5Ux2WhN+p4LKHbq7 10 | ZBb8USM9t/700icPmNhR3Nml7Cxcmi08FPifW+biEjVBD4Y+uA2YVXVJ/e4DzRlr 11 | tV8hgQ+T8+xB5b17Q9dmyjJUcN7kzaoZBSyoHcH0+7h1C/VxZJBCEaHKVlHd47IS 12 | FhaR+piIXyU+byvMJVthvqWYFEjlZDeb7+JHk0NDzxd/MkuZv8QzzZmWdN8A5b8i 13 | ApQfQyJKqj0cU5KdBlwfqdm0iC9D0soooIH+klIHRQKBgQDMvQNCR2HCDPi732cM 14 | LlXqdl4pn+Wufihthd+Vqq+mAlKT2T/5LkdwnpM6h7yixcmDr2HaDLCZ71F9IiUt 15 | iqvA8B/NVg4pI5zupF+OfDI1Sg9CGWxNJqfVQ2jC9D/pLc29XNnHIjXclabJL0U9 16 | BlSvqq1BcYNCd8rs4tmobv7NxwKBgQDCyldmA9NXWA19qpwxESatVW75PdnJMLx6 17 | nEH85XCbONxuS1Sf1orKWg0RklRVGGRnBAqf4V0zmP0u0OVfThYuAmnwp1pYG/wW 18 | XmuXDWojrLrSbA1gtxK2F7m5KpXg8iCcK5Rnug/JVdHsrHqtJ9hTFnoL2af6I3jr 19 | HiV62D388wKBgALrw2sjp5JkKvxLMKYs1w70R12iqV028Y62dT0mZUEiEVmIpPAC 20 | KATETmdsXlWYKsrVKrk4qyBXGLuHTC59JvwmsN12F9egaXHCKJbY0MKP3u3bfP8Q 21 | yR4yywDVCUBjZecItxavN0OBYxLFuOApAfZLohMn8m51VRDSH7bWdo4rAoGAT1cn 22 | fi/0t1DwPc1uTTYVMOjpiK++s4ocWzymTCIQWckxT+NzFp/GbGF9jTizDO4ghy1I 23 | PpMG6WtZROZlZwphUmA9Un53+Ad+CIZxAFfAccN7XRYR5ODsyCqlxVwpLDSzP6ko 24 | i49nurQwC1y9oyXloQI4t/bxypsEN5BR59WIei0CgYBmcZhyWjV80SI7m996iNuo 25 | Fy3gVDndbpUeHXwAj3JLN9izlR3OotoXbjGlah7Ddh6DFGWjpDVDKpEiqXv/GNMR 26 | jbgWrjH+Rh3WH9pMnn0VWlfZ6T9IX6pqvXsfXEvyONDRhw360HSop5KdXey4b3q9 27 | /5H03MmqOc7p0MzJ4U2z3A== 28 | -----END PRIVATE KEY----- -------------------------------------------------------------------------------- /RSA.py: -------------------------------------------------------------------------------- 1 | import rsa 2 | 3 | class RsaEncrypt(object): 4 | """ 5 | RSA 加密无填充 6 | """ 7 | def __init__(self, e, m): 8 | self.e = e 9 | self.m = m 10 | 11 | def encrypt(self, message, upper=True): 12 | mm = int(self.m, 16) 13 | ee = int(self.e, 16) 14 | rsa_pubkey = rsa.PublicKey(mm, ee) 15 | crypto = self._encrypt(message.encode(), rsa_pubkey) 16 | ciphertext = crypto.hex() 17 | if upper: 18 | ciphertext = ciphertext.upper() 19 | return ciphertext 20 | 21 | def _pad_for_encryption(self, message, target_length): 22 | message = message[::-1] 23 | max_msglength = target_length - 11 24 | msglength = len(message) 25 | 26 | padding = b'' 27 | padding_length = target_length - msglength - 3 28 | 29 | for i in range(padding_length): 30 | padding += b'\x00' 31 | 32 | return b''.join([b'\x00\x00', padding, b'\x00', message]) 33 | 34 | def _encrypt(self, message, pub_key): 35 | keylength = rsa.common.byte_size(pub_key.n) 36 | padded = self._pad_for_encryption(message, keylength) 37 | 38 | payload = rsa.transform.bytes2int(padded) 39 | encrypted = rsa.core.encrypt_int(payload, pub_key.e, pub_key.n) 40 | block = rsa.transform.int2bytes(encrypted, keylength) 41 | 42 | return block 43 | 44 | 45 | if __name__ == '__main__': 46 | #模 47 | m = "ae068c2039bd2d82a529883f273cf20a48e0b6faa564e740402375a9cb332a029b8492ae342893d9c9d53d94d3ab8ae95de9607c2e03dd46cebe211532810b73cc764995ee61ef435437bcddb3f4a52fca66246dbdf2566dd85fbc4930c548e7033c2bcc825b038e8dd4b3553690e0c438bbd5ade6f5a476b1cbc1612f5d501f" 48 | #指数 49 | e = '10001' 50 | en = RsaEncrypt(e, m) 51 | message = '123456' 52 | print(en.encrypt(message)) -------------------------------------------------------------------------------- /WeChatApp.py: -------------------------------------------------------------------------------- 1 | from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes 2 | from cryptography.hazmat.primitives import padding 3 | from cryptography.hazmat.backends import default_backend 4 | import base64 5 | 6 | class Weixin(): 7 | """ 8 | 微信小程序sessionKey泄露加解密脚本 9 | """ 10 | def __init__(self, key, iv) -> None: 11 | """ 12 | 初始化session_key和iv 13 | """ 14 | self.key = key 15 | self.iv = iv 16 | 17 | def encrypto(self, plaintext_payload : bytes): 18 | """ 19 | 加密函数 20 | """ 21 | backend = default_backend() 22 | cipher = Cipher(algorithms.AES(base64.b64decode(self.key)), modes.CBC(base64.b64decode(self.iv)), backend=backend) 23 | padder = padding.PKCS7(128).padder() 24 | payload = padder.update(plaintext_payload) + padder.finalize() 25 | encryptor = cipher.encryptor() 26 | ct = encryptor.update(payload) + encryptor.finalize() 27 | return base64.b64encode(ct) 28 | 29 | def decrypto(self, ciphertext_payload : str): 30 | """ 31 | 解密函数 32 | """ 33 | backend = default_backend() 34 | cipher = Cipher(algorithms.AES(base64.b64decode(self.key)), modes.CBC(base64.b64decode(self.iv)), backend=backend) 35 | decryptor = cipher.decryptor() 36 | pt = decryptor.update(base64.b64decode(ciphertext_payload)) + decryptor.finalize() 37 | unpadder = padding.PKCS7(128).unpadder() 38 | pt = unpadder.update(pt) + unpadder.finalize() 39 | return pt.decode() 40 | 41 | if __name__ == "__main__": 42 | ciphertext_payload = "CiyLU1Aw2KjvrjMdj8YKliAjtP4gsMZMQmRzooG2xrDcvSnxIMXFufNstNGTyaGS9uT5geRa0W4oTOb1WT7fJlAC+oNPdbB+3hVbJSRgv+4lGOETKUQz6OYStslQ142dNCuabNPGBzlooOmB231qMM85d2/fV6ChevvXvQP8Hkue1poOFtnEtpyxVLW1zAo6/1Xx1COxFvrc2d7UL/lmHInNlxuacJXwu0fjpXfz/YqYzBIBzD6WUfTIF9GRHpOn/Hz7saL8xz+W//FRAUid1OksQaQx4CMs8LOddcQhULW4ucetDf96JcR3g0gfRK4PC7E/r7Z6xNrXd2UIeorGj5Ef7b1pJAYB6Y5anaHqZ9J6nKEBvB4DnNLIVWSgARns/8wR2SiRS7MNACwTyrGvt9ts8p12PKFdlqYTopNHR1Vf7XjfhQlVsAJdNiKdYmYVoKlaRv85IfVunYzO0IKXsyl7JCUjCpoG20f0a04COwfneQAGGwd5oa+T8yO5hzuyDb/XcxxmK01EpqOyuxINew==" 43 | plaintext_payload = b'{"openId":"oGZUI0egBJY1zhBYw2KhdUfwVJJE","nickName":"Band","gender":1,"language":"zh_CN","city":"Guangzhou","province":"Guangdong","country":"CN","avatarUrl":"http://wx.qlogo.cn/mmopen/vi_32/aSKcBBPpibyKNicHNTMM0qJVh8Kjgiak2AHWr8MHM4WgMEm7GFhsf8OYrySdbvAMvTsw3mo8ibKicsnfN5pRjl1p8HQ/0","unionId":"ocMvos6NjeKLIBqg5Mr9QjxrP1FA","watermark":{"timestamp":1477314187,"appid":"wx4f4bc4dec97d474b"}}' 44 | session_key = 'tiihtNczf5v6AKRyjwEUhQ==' 45 | iv = 'r7BXXKkLb8qrSNn05n0qiA==' 46 | wx = Weixin(session_key, iv) 47 | r = wx.decrypto(ciphertext_payload) 48 | # r = wx.encrypto(plaintext_payload) 49 | print(r) -------------------------------------------------------------------------------- /AES.py: -------------------------------------------------------------------------------- 1 | import hashlib, base64 2 | from Crypto.Cipher import AES 3 | from cryptography.hazmat.primitives.padding import PKCS7 4 | from cryptography.hazmat.primitives.ciphers import algorithms 5 | import json 6 | 7 | 8 | class AES_ECB_pkcs7(): 9 | """ 10 | AES_ECB_pkcs7加解密 11 | """ 12 | def __init__(): 13 | pass 14 | 15 | def pkcs7padding(self, text): 16 | """ 17 | 明文使用PKCS7填充 18 | 最终调用AES加密方法时，传入的是一个byte数组，要求是16的整数倍，因此需要对明文进行处理 19 | :param text: 待加密内容(明文) 20 | :return: 21 | """ 22 | bs = AES.block_size # 16 23 | length = len(text) 24 | bytes_length = len(bytes(text, encoding='utf-8')) 25 | # tips：utf-8编码时，英文占1个byte，而中文占3个byte 26 | padding_size = length if (bytes_length == length) else bytes_length 27 | padding = bs - padding_size % bs 28 | # tips：chr(padding)看与其它语言的约定，有的会使用'\0' 29 | padding_text = chr(padding) * padding 30 | return text + padding_text 31 | 32 | 33 | def pkcs7_unpad(self, content): 34 | """ 35 | 解密时候用 36 | :param content: 37 | :return: 38 | """ 39 | if not isinstance(content, bytes): 40 | content = content.encode() 41 | pad = PKCS7(algorithms.AES.block_size).unpadder() 42 | pad_content = pad.update(content) + pad.finalize() 43 | return pad_content 44 | 45 | 46 | def encrypt(self, key, content): 47 | """ 48 | AES加密 49 | key,iv使用同一个 50 | 模式ecb 51 | 填充pkcs7 52 | :param key: 密钥 53 | :param content: 加密内容 54 | :return: 55 | """ 56 | key_bytes = bytes(key, encoding='utf-8') 57 | iv = key_bytes 58 | cipher = AES.new(key_bytes, AES.MODE_ECB) 59 | # 处理明文 60 | content_padding = self.pkcs7padding(content) 61 | # 加密 62 | encrypt_bytes = cipher.encrypt(bytes(content_padding, encoding='utf-8')) 63 | # 重新编码 64 | result = str(base64.b64encode(encrypt_bytes), encoding='utf-8') 65 | return result 66 | 67 | def decrypt(self, key,text): 68 | key_bytes = bytes(key, encoding='utf-8') 69 | iv = key_bytes 70 | cryptos = AES.new(key_bytes, AES.MODE_ECB) 71 | data = cryptos.decrypt(text) 72 | return json.loads(self.pkcs7_unpad(data)) 73 | 74 | class AES_ECB_pkcs5(): 75 | """ 76 | AES_ECB_pkcs5加解密 77 | """ 78 | def __init__(self): 79 | self.key = 'XXXXXXXXXXX' #秘钥 80 | self.MODE = AES.MODE_ECB 81 | self.BS = AES.block_size 82 | self.pad = lambda s: s + (self.BS - len(s) % self.BS) * chr(self.BS - len(s) % self.BS) 83 | self.unpad = lambda s: s[0:-ord(s[-1])] 84 | 85 | def add_to_16(value): 86 | while len(value) % 16 != 0: 87 | value += '\0' 88 | return str.encode(value) 89 | 90 | def AES_encrypt(self, text): 91 | aes = AES.new(self.add_to_16(self.key), self.MODE) 92 | encrypted_text = str(base64.encodebytes(aes.encrypt(self.add_to_16(self.pad(text)))), 93 | encoding='utf-8').replace('\n', '') 94 | return encrypted_text -------------------------------------------------------------------------------- /common.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from cryptography.hazmat.primitives.ciphers import algorithms 3 | from cryptography.hazmat.primitives.ciphers import Cipher 4 | from cryptography.hazmat.primitives.ciphers import modes 5 | from cryptography.hazmat.backends import default_backend 6 | 7 | import io,gzip 8 | import hashlib 9 | import base64 10 | import uuid 11 | 12 | def upper_str(text): 13 | return text.upper() 14 | 15 | 16 | class AES_GZIP: 17 | def gzip_decode(self, content): 18 | buf = io.BytesIO(content) 19 | gf = gzip.GzipFile(fileobj=buf) 20 | content = gf.read() 21 | return content 22 | 23 | def pwd_decrypt(self, content): 24 | key = b'XXXX' 25 | iv = b'XXXXX' 26 | cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend()) 27 | decryptor = cipher.decryptor() 28 | data = decryptor.update(content) 29 | return self.gzip_decode(data) 30 | 31 | class CommonFunc: 32 | def __init__(self) -> None: 33 | pass 34 | 35 | def md5(self, plaintext, length=32): 36 | """ 37 | md5加密函数 38 | length指定长度32或者16位 39 | """ 40 | ciphertext = hashlib.md5(plaintext.encode(encoding="UTF-8")).hexdigest() 41 | if length == 32: 42 | return ciphertext 43 | else: 44 | return ciphertext[8:-8] 45 | 46 | def base64_encrypt(self, plaintext): 47 | return base64.b64encode(plaintext.encode()).decode() 48 | 49 | def base64_decrypt(self, ciphertext): 50 | return base64.b64decode(ciphertext).decode() 51 | 52 | def uuid(self, mode=1): 53 | """ 54 | 默认使用uuid1 55 | uuid1 基于时间戳 56 | uuid3 基于名字的MD5散列值 57 | uuid4 基于随机数 58 | uuid5 基于名字的SHA-1散列值 59 | """ 60 | if mode == 1: 61 | return uuid.uuid1() 62 | elif mode == 3: 63 | namespace_uuid = uuid.NAMESPACE_DNS # 命名空间 UUID 64 | name_str = "example.com" # 名称 65 | return uuid.uuid3(namespace_uuid, name_str) 66 | elif mode == 4: 67 | return uuid.uuid4() 68 | elif mode == 5: 69 | namespace_uuid = uuid.NAMESPACE_DNS # 命名空间 UUID 70 | name_str = "example.com" # 名称 71 | return uuid.uuid5(namespace_uuid, name_str) 72 | 73 | def str_to_hex(self, payload): 74 | """ 75 | 字符串转b'\xe7\xaf\xae\xe7\x90\x83' 76 | :param s: 77 | :return: 78 | """ 79 | byte_array = payload.encode('utf-8') 80 | hex_str = ''.join(['\\x{:02x}'.format(b) for b in byte_array]) 81 | return hex_str 82 | 83 | def hex_to_str(self, payload: bytes): 84 | text = payload.decode('utf-8') 85 | return text 86 | 87 | def str_to_unicode(self, payload): 88 | encoded_text = payload.encode('unicode_escape').decode() 89 | return encoded_text 90 | 91 | def unicode_to_str(self, payload): 92 | codes = payload.split('\\u')[1:] # 拆分出每个编码点 93 | # 将编码点转换为整数，并转换为对应的 Unicode 字符，然后拼接为完整的字符串 94 | text = ''.join([chr(int(code, 16)) for code in codes]) 95 | return text 96 | 97 | if __name__ == "__main__": 98 | # gzip_aes = AES_GZIP() 99 | # gzip_aes.pwd_decrypt() 100 | # payload = '123456' 101 | # en_payload = 'MTIzNDU2' 102 | # cf = CommonFunc() 103 | # print(cf.upper_str('aaaaa')) 104 | # print(CommonFunc.upper_str('fff')) 105 | pass 106 | -------------------------------------------------------------------------------- /RSA3.py: -------------------------------------------------------------------------------- 1 | # 公钥加密 2 | import base64 3 | import rsa 4 | from Crypto.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5 5 | from Crypto.PublicKey import RSA 6 | 7 | class RSAPulicKey(): 8 | """ 9 | 实现了 RSA 公钥私钥加解密 10 | """ 11 | def __init__(self) -> None: 12 | pass 13 | 14 | def rsa_encrypt(self, data, publicKeyStr): 15 | ''' 16 | data:内容 17 | publicKeyStr:不需要-----BEGIN PUBLIC KEY-----开头，-----END PUBLIC KEY-----结尾的格式,只要中间部分即可 18 | key_encoded:需要-----BEGIN PUBLIC KEY-----开头，-----END PUBLIC KEY-----结尾的格式 19 | ''' 20 | key_encoded='''-----BEGIN PUBLIC KEY----- 21 | MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCdZGziIrJOlRomzh7M9qzo4ibw 22 | QmwORcVDI0dsfUICLUVRdUN+MJ8ELd55NKsfYy4dZodWX7AmdN02zm1Gk5V5i2Vw 23 | GVWE205u7DhtRe85W1oR9WTsMact5wuqU6okJd2GKrEGotgd9iuAJm90N6TDeDZ4 24 | KHEvVEE1yTyvrxQgkwIDAQAB 25 | -----END PUBLIC KEY-----''' 26 | publicKeyBytes = base64.b64decode(publicKeyStr.encode()) 27 | key = RSA.import_key(publicKeyBytes) 28 | #key = RSA.import_key(key_encoded) 29 | # 4、对原密码加密 30 | encryptPassword = rsa.encrypt(data.encode(), key) 31 | return base64.b64encode(encryptPassword).decode() 32 | 33 | def rsa_decrypt(self, msg, privateKeyStr): 34 | msg = base64.b64decode(msg) 35 | # 私钥解密 36 | priobj = Cipher_pkcs1_v1_5.new(RSA.importKey(privateKeyStr)) 37 | data = priobj.decrypt(msg,None).decode() 38 | return data 39 | 40 | if __name__ =='__main__': 41 | data = '123456' 42 | publickey_str = """MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAm8kPgp7ed4m69hcIkAzL 43 | zyvy7Q8oUyuTJ5hX/Z6nz/f+IJAWCDd7s2QaznbvXmEPOi3r7SeoRlIVRXXhmVwE 44 | 8FH3JfhgXufd6vS1TntdVOAbhAOMYEwZzdqTvW7QogJoatD9AczN39ySeZ77ltn1 45 | jb5sI0Yh9XCA/ldaPXKj2u141WQlg00g8CjFE0+CzwgrF+6sNStdG+tnE2tE0aPY 46 | 1Y3yorD8oFhCPLGC7dzBMzmOOO07JbQqPwPldj0aRpAh0+ThA7hCcM2+cQu8x1dq 47 | +foGmd2G1J4zgebIsJ92H9YNQSKZ3Kr43/c0pLVWTIVJGI1JFTlX9dun3axRHtg3 48 | 5QIDAQAB""" 49 | privatekey_str = """-----BEGIN PRIVATE KEY----- 50 | MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCbyQ+Cnt53ibr2 51 | FwiQDMvPK/LtDyhTK5MnmFf9nqfP9/4gkBYIN3uzZBrOdu9eYQ86LevtJ6hGUhVF 52 | deGZXATwUfcl+GBe593q9LVOe11U4BuEA4xgTBnN2pO9btCiAmhq0P0BzM3f3JJ5 53 | nvuW2fWNvmwjRiH1cID+V1o9cqPa7XjVZCWDTSDwKMUTT4LPCCsX7qw1K10b62cT 54 | a0TRo9jVjfKisPygWEI8sYLt3MEzOY447TsltCo/A+V2PRpGkCHT5OEDuEJwzb5x 55 | C7zHV2r5+gaZ3YbUnjOB5siwn3Yf1g1BIpncqvjf9zSktVZMhUkYjUkVOVf126fd 56 | rFEe2DflAgMBAAECggEAGXOAwDNaXyc2T0w2Duq4RXGFr6shSG0/DmH6RiosenKm 57 | pwVDRDZkVEuPgZm2w7GRvkyQVd97w3lXllCK+fYprGWHvkFU5Ux2WhN+p4LKHbq7 58 | ZBb8USM9t/700icPmNhR3Nml7Cxcmi08FPifW+biEjVBD4Y+uA2YVXVJ/e4DzRlr 59 | tV8hgQ+T8+xB5b17Q9dmyjJUcN7kzaoZBSyoHcH0+7h1C/VxZJBCEaHKVlHd47IS 60 | FhaR+piIXyU+byvMJVthvqWYFEjlZDeb7+JHk0NDzxd/MkuZv8QzzZmWdN8A5b8i 61 | ApQfQyJKqj0cU5KdBlwfqdm0iC9D0soooIH+klIHRQKBgQDMvQNCR2HCDPi732cM 62 | LlXqdl4pn+Wufihthd+Vqq+mAlKT2T/5LkdwnpM6h7yixcmDr2HaDLCZ71F9IiUt 63 | iqvA8B/NVg4pI5zupF+OfDI1Sg9CGWxNJqfVQ2jC9D/pLc29XNnHIjXclabJL0U9 64 | BlSvqq1BcYNCd8rs4tmobv7NxwKBgQDCyldmA9NXWA19qpwxESatVW75PdnJMLx6 65 | nEH85XCbONxuS1Sf1orKWg0RklRVGGRnBAqf4V0zmP0u0OVfThYuAmnwp1pYG/wW 66 | XmuXDWojrLrSbA1gtxK2F7m5KpXg8iCcK5Rnug/JVdHsrHqtJ9hTFnoL2af6I3jr 67 | HiV62D388wKBgALrw2sjp5JkKvxLMKYs1w70R12iqV028Y62dT0mZUEiEVmIpPAC 68 | KATETmdsXlWYKsrVKrk4qyBXGLuHTC59JvwmsN12F9egaXHCKJbY0MKP3u3bfP8Q 69 | yR4yywDVCUBjZecItxavN0OBYxLFuOApAfZLohMn8m51VRDSH7bWdo4rAoGAT1cn 70 | fi/0t1DwPc1uTTYVMOjpiK++s4ocWzymTCIQWckxT+NzFp/GbGF9jTizDO4ghy1I 71 | PpMG6WtZROZlZwphUmA9Un53+Ad+CIZxAFfAccN7XRYR5ODsyCqlxVwpLDSzP6ko 72 | i49nurQwC1y9oyXloQI4t/bxypsEN5BR59WIei0CgYBmcZhyWjV80SI7m996iNuo 73 | Fy3gVDndbpUeHXwAj3JLN9izlR3OotoXbjGlah7Ddh6DFGWjpDVDKpEiqXv/GNMR 74 | jbgWrjH+Rh3WH9pMnn0VWlfZ6T9IX6pqvXsfXEvyONDRhw360HSop5KdXey4b3q9 75 | /5H03MmqOc7p0MzJ4U2z3A== 76 | -----END PRIVATE KEY-----""" 77 | 78 | r = RSAPulicKey() 79 | result = r.rsa_encrypt(data, publickey_str) 80 | result = r.rsa_decrypt(result, privatekey_str) 81 | print(result) -------------------------------------------------------------------------------- /RSASign.py: -------------------------------------------------------------------------------- 1 | from Crypto.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5 2 | from Crypto.Signature import PKCS1_v1_5 3 | 4 | from Crypto.PublicKey import RSA 5 | from Crypto.Hash import SHA256 6 | import base64 7 | 8 | 9 | class RsaUtil: 10 | """ 11 | 实现了 RSA 加解密、签名和验证 12 | """ 13 | def __init__(self, pub_key, pri_key): 14 | self.pri_key_obj = None 15 | self.pub_key_obj = None 16 | self.verifier = None 17 | self.signer = None 18 | if pub_key: 19 | pub_key = RSA.importKey(base64.b64decode(pub_key)) 20 | self.pub_key_obj = Cipher_pkcs1_v1_5.new(pub_key) 21 | self.verifier = PKCS1_v1_5.new(pub_key) 22 | if pri_key: 23 | pri_key = RSA.importKey(base64.b64decode(pri_key)) 24 | self.pri_key_obj = Cipher_pkcs1_v1_5.new(pri_key) 25 | self.signer = PKCS1_v1_5.new(pri_key) 26 | 27 | def public_long_encrypt(self, data, charset='utf-8'): 28 | data = data.encode(charset) 29 | length = len(data) 30 | default_length = 117 31 | res = [] 32 | for i in range(0, length, default_length): 33 | res.append(self.pub_key_obj.encrypt(data[i:i + default_length])) 34 | byte_data = b''.join(res) 35 | return base64.b64encode(byte_data).decode() 36 | 37 | def private_long_decrypt(self, data, sentinel=b'decrypt error'): 38 | data = base64.b64decode(data) 39 | length = len(data) 40 | default_length = 256 41 | res = [] 42 | for i in range(0, length, default_length): 43 | res.append(self.pri_key_obj.decrypt(data[i:i + default_length], sentinel)) 44 | return str(b''.join(res), encoding = "utf-8") 45 | 46 | def sign(self, data, charset='utf-8'): 47 | h = SHA256.new(data.encode(charset)) 48 | signature = self.signer.sign(h) 49 | return base64.b64encode(signature).decode() 50 | 51 | def verify(self, data, sign, charset='utf-8'): 52 | h = SHA256.new(data.encode(charset)) 53 | return self.verifier.verify(h, base64.b64decode(sign)) 54 | 55 | if __name__ == '__main__': 56 | publickey_str = """MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAm8kPgp7ed4m69hcIkAzL 57 | zyvy7Q8oUyuTJ5hX/Z6nz/f+IJAWCDd7s2QaznbvXmEPOi3r7SeoRlIVRXXhmVwE 58 | 8FH3JfhgXufd6vS1TntdVOAbhAOMYEwZzdqTvW7QogJoatD9AczN39ySeZ77ltn1 59 | jb5sI0Yh9XCA/ldaPXKj2u141WQlg00g8CjFE0+CzwgrF+6sNStdG+tnE2tE0aPY 60 | 1Y3yorD8oFhCPLGC7dzBMzmOOO07JbQqPwPldj0aRpAh0+ThA7hCcM2+cQu8x1dq 61 | +foGmd2G1J4zgebIsJ92H9YNQSKZ3Kr43/c0pLVWTIVJGI1JFTlX9dun3axRHtg3 62 | 5QIDAQAB""" 63 | privatekey_str = """MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCbyQ+Cnt53ibr2 64 | FwiQDMvPK/LtDyhTK5MnmFf9nqfP9/4gkBYIN3uzZBrOdu9eYQ86LevtJ6hGUhVF 65 | deGZXATwUfcl+GBe593q9LVOe11U4BuEA4xgTBnN2pO9btCiAmhq0P0BzM3f3JJ5 66 | nvuW2fWNvmwjRiH1cID+V1o9cqPa7XjVZCWDTSDwKMUTT4LPCCsX7qw1K10b62cT 67 | a0TRo9jVjfKisPygWEI8sYLt3MEzOY447TsltCo/A+V2PRpGkCHT5OEDuEJwzb5x 68 | C7zHV2r5+gaZ3YbUnjOB5siwn3Yf1g1BIpncqvjf9zSktVZMhUkYjUkVOVf126fd 69 | rFEe2DflAgMBAAECggEAGXOAwDNaXyc2T0w2Duq4RXGFr6shSG0/DmH6RiosenKm 70 | pwVDRDZkVEuPgZm2w7GRvkyQVd97w3lXllCK+fYprGWHvkFU5Ux2WhN+p4LKHbq7 71 | ZBb8USM9t/700icPmNhR3Nml7Cxcmi08FPifW+biEjVBD4Y+uA2YVXVJ/e4DzRlr 72 | tV8hgQ+T8+xB5b17Q9dmyjJUcN7kzaoZBSyoHcH0+7h1C/VxZJBCEaHKVlHd47IS 73 | FhaR+piIXyU+byvMJVthvqWYFEjlZDeb7+JHk0NDzxd/MkuZv8QzzZmWdN8A5b8i 74 | ApQfQyJKqj0cU5KdBlwfqdm0iC9D0soooIH+klIHRQKBgQDMvQNCR2HCDPi732cM 75 | LlXqdl4pn+Wufihthd+Vqq+mAlKT2T/5LkdwnpM6h7yixcmDr2HaDLCZ71F9IiUt 76 | iqvA8B/NVg4pI5zupF+OfDI1Sg9CGWxNJqfVQ2jC9D/pLc29XNnHIjXclabJL0U9 77 | BlSvqq1BcYNCd8rs4tmobv7NxwKBgQDCyldmA9NXWA19qpwxESatVW75PdnJMLx6 78 | nEH85XCbONxuS1Sf1orKWg0RklRVGGRnBAqf4V0zmP0u0OVfThYuAmnwp1pYG/wW 79 | XmuXDWojrLrSbA1gtxK2F7m5KpXg8iCcK5Rnug/JVdHsrHqtJ9hTFnoL2af6I3jr 80 | HiV62D388wKBgALrw2sjp5JkKvxLMKYs1w70R12iqV028Y62dT0mZUEiEVmIpPAC 81 | KATETmdsXlWYKsrVKrk4qyBXGLuHTC59JvwmsN12F9egaXHCKJbY0MKP3u3bfP8Q 82 | yR4yywDVCUBjZecItxavN0OBYxLFuOApAfZLohMn8m51VRDSH7bWdo4rAoGAT1cn 83 | fi/0t1DwPc1uTTYVMOjpiK++s4ocWzymTCIQWckxT+NzFp/GbGF9jTizDO4ghy1I 84 | PpMG6WtZROZlZwphUmA9Un53+Ad+CIZxAFfAccN7XRYR5ODsyCqlxVwpLDSzP6ko 85 | i49nurQwC1y9oyXloQI4t/bxypsEN5BR59WIei0CgYBmcZhyWjV80SI7m996iNuo 86 | Fy3gVDndbpUeHXwAj3JLN9izlR3OotoXbjGlah7Ddh6DFGWjpDVDKpEiqXv/GNMR 87 | jbgWrjH+Rh3WH9pMnn0VWlfZ6T9IX6pqvXsfXEvyONDRhw360HSop5KdXey4b3q9 88 | /5H03MmqOc7p0MzJ4U2z3A==""" 89 | 90 | r = RsaUtil(publickey_str, privatekey_str) 91 | data = '123456' 92 | cipherplain = r.public_long_encrypt(data) 93 | print(cipherplain) 94 | # result = r.private_long_decrypt(result) 95 | sign = r.sign(cipherplain) 96 | print(sign) 97 | result = r.verify(cipherplain, sign) 98 | print(result) 99 | --------------------------------------------------------------------------------