为啥python不可加密

Posted 2023-05-06

可以加密。 python 代码加密甚至可以做到比用汇编手写混淆，用 c 手写混淆更加难以解密。具体做法略复杂仅简单说个过程。

第一级别是源码级别的混淆，用 ast 和 astor ，再自己手写一个混淆器，三五百行的脚本直接混淆到几万行，整个文件面目全非，基本可以做到就算直接放脚本给你拿去逆，除非你再写出来一个逆向前面的混淆算法的脚本来逆（在熟悉 python 的情况下需要花几天，且不说需要了解程序构造原理），手动去调试脚本几乎达到不可行的地步（话费时间再乘以 2 ）

第二级别是个性化定制 pyinstaller ， pyinstaller 会打包所有需要的库，将脚本也包含进打包的 exe ，但是， pyinstaller 有一个 stub ，相当于一个启动器，需要由这个启动器来解密脚本和导入模块，外面有直接导出脚本的工具，但是那是针对 pyinstaller 自带的启动器做的，完全可以自己修改这个启动器再编译，这样逆向者就必须手动调试找到 main 模块。配合第一级别加密，呵呵，中国就算是最顶尖的逆向专家也要花个一两周，来破解我们的程序逻辑了，就我所知，实际上国内对于 py 程序的逆向研究不多。

第三级别是再上一层，将 py 翻译为 c 再直接编译 c 为 dll ，配合第一阶段先混淆再转 c 再编译，在第一步混淆之后，会产生非常多垃圾（中间层）函数，这些中间层函数在 c 这里会和 py 解释器互相调用，脚本和二进制之间交叉运行，本身混淆之后的源码就极难复原，再混合这一层，想逆向，难。

第四级别是利用 py 的动态特性，绝大多数逆向者都是 c ，汇编出身，对于程序的第一直觉就是，程序就是一条一条的指令，后一条指令必然在这一条指令后面，然而， py 的动态特性可以让代码逻辑根本就不在程序里面，这一点不想多讲，涉及到我一个项目里的深度加密。

第五级别，数学做墙。了解过比特币原理的知道要想用挖比特币就得提供大量算力去帮网络计算 hash ，这个成为 pow ，那么既然已经采用 py 了估计已经不考虑太多 cpu 利用率了，那就可以采用 pow （还有其他的手段）确保程序运行时拥有大量算力，如果程序被单步调试，呵呵，一秒钟你也跑不出来几个 hash 直接拉黑这个 ip （这个说法可能比较难理解，因为我第四层的加密没有说明，不过意思就是拒绝执行就对了） 参考技术A 对 Python 加密时可能会有两种形式，一种是对Python转成的exe进行保护，另一种是直接对.py或者.pyc文件进行保护，下面将列举两种形式的保护流程。
1、 对 python转exe加壳
下载最新版Virbox Protector加壳工具，使用加壳工具直接对demo.exe进行加壳操作
2、对.py/.pyc加密
第一步，使用加壳工具对 python 安装目录下的 python.exe 进行加壳，将 python.exe 拖入到加壳工具 VirboxProtector 中，配置后直接点击加壳。
第二步，对.py/.pyc 进行加密，使用 DSProtector 对.py/.pyc 进行保护。

Python使用rsa模块实现非对称加密与解密

Python使用rsa模块实现非对称加密与解密

1、简单介绍：

RSA加密算法是一种非对称加密算法 是由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。加密密钥（即公开密钥）PK是公开信息，而解密密钥（即秘密密钥）SK是需要保密的。
RSA密钥至少为500位长，一般推荐使用1024位。RSA密钥长度随着保密级别提高，增加很快。
由于RSA的特性，一个1024位的密钥只能加密117位字节数据，当数据量超过117位字节的时候，程序就会抛出异常。 ——来自大佬

2、代码实现：

来一段大佬的代码：

import rsa


# 一、生成公钥及私钥, 并保存
public_key, private_key = rsa.newkeys(1024)  # 生成公钥和私钥
# 将生成的公钥和私钥进行转换，以便存储
pub = public_key.save_pkcs1()
pri = private_key.save_pkcs1(\'PEM\')  # save_pkcsl()是内置方法，其默认参数是‘PEM’
with open(\'pubkey.pem\', mode=\'wb\') as f, open(\'privkey.pem\', mode=\'wb\') as f1:
	f.write(pub)  # 打开两个文件，分别存储公钥及私钥
	f1.write(pri)


# 二. 使用公钥加密, 私钥解密
def func():
	with open(\'pubkey.pem\', mode=\'rb\') as f, open(\'privkey.pem\', \'rb\') as f1:
		pub = f.read()  # 从文件中再读出公钥和私钥
		pri = f1.read()
		public_key = rsa.PublicKey.load_pkcs1(pub)  # 转换为原始状态
		private_key = rsa.PrivateKey.load_pkcs1(pri)
	message = "rsa加密测试"
	info = rsa.encrypt(message.encode(\'utf-8\'), public_key)  # 使用公钥加密内容，内容必须是二进制
	msg = rsa.decrypt(info, private_key)  # 使用私钥解密，获得解密后的内容
	print(msg.decode(\'utf-8\'))  # 使用之前记得先解码

3、代码升级：

现在我将上述的代码段封装成一个Rsa class（包含的方法有：__init__——初始化方法，key_transform_store——存储公钥与私钥的方法、encry——加密方法、decry——解密方法），使用的时候，直接将下面的代码段拎到我们需要的地方去引用：先创建一Rsa对象，然后调用里面的方法即可：

import rsa


class Rsa(object):
	"""RSA加密、解密"""

	def __init__(self, number, pub_path=\'public_key.pem\', priv_path=\'private_key.pem\'):
		"""

		:param pub_path: the path to public key, default its path is public_key.pem
		:param priv_path: the path to private key, default its path is private_key.pem
		"""
		# Generate the public and private keys, and returns them
		self.public_key, self.private_key = rsa.newkeys(number)

		self.public_key_path = pub_path
		self.private_key_path = priv_path

	def key_transform_store(self):
		"""
		convert and save the generated public and private keys to a file
		:return: None
		"""
		# convert the generated public and private keys for storage
		pub = self.public_key.save_pkcs1()
		pri = self.private_key.save_pkcs1(\'PEM\')

		# open two files to store the public key and private key respectively
		
		with open(self.public_key_path, mode=\'wb\') as f:
			f.write(pub)

		with open(self.private_key_path, mode=\'wb\') as f1:
			f1.write(pri)

	def encry(self, info):
		"""
		encrypt information
		:param info: the original string information to be encrypted
		:return:info_encrypted
		"""
		# read the public key from the file
		with open(self.public_key_path, mode=\'rb\') as f:
			pub = f.read()
			# convert pub to original state
			public_key = rsa.PublicKey.load_pkcs1(pub)

		# use the public key to encrypt the content, which must be binary
		info_encrypted = rsa.encrypt(info.encode(\'utf-8\'), public_key)
		return info_encrypted

	def decry(self, info_encrypted):
		"""
		decrypt information
		:param info_encrypted: encrypted information
		:return: info
		"""
		# read the private key from the file
		with open(self.private_key_path, \'rb\') as f:
			pri = f.read()
			# convert pri to original state
			private_key = rsa.PrivateKey.load_pkcs1(pri)

		# decrypt with private key to obtain the decrypted content
		msg = rsa.decrypt(info_encrypted, private_key)
		info = msg.decode(\'utf-8\')  # decode
		return info


rsa_obj = Rsa(1024)  # 实例化
rsa_obj.key_transform_store()  # 
info_encrypted = rsa_obj.encry(\'我是真心喜欢你的。\')  # 加密
print(info_encrypted)
info = rsa_obj.decry(info_encrypted)  # 解密
print(info)  # 我是真心喜欢你的。

这里会出现一个问题：由于RSA的特性，一个1024位的密钥只能加密117位字节数据，当数据量超过117位字节的时候，程序就会抛出异常。如下测试会抛出：OverflowError: 189 bytes needed for message, but there is only space for 117

rsa_obj = Rsa(1024)  # 实例化
rsa_obj.key_transform_store()  # 
info_encrypted = rsa_obj.encry(\'我是真心喜欢你的。我是真心喜欢你的。我是真心喜欢你的。我是真心喜欢你的。我是真心喜欢你的。我是真心喜欢你的。我是真心喜欢你的。\')  # 加密
print(info_encrypted)
info = rsa_obj.decry(info_encrypted)  # 解密
print(info)

。。。。。。

后记: 通常使用中, 会先对数据进行bas64加密, 再对加密后的内容使用rsa加密, 最后对rsa解密后的内容进行bas64解密。

以上。