我正在开发一个必须在日志中写入一些机密信息的网络应用程序（使用 gevent，但这并不重要）。显而易见的想法是使用硬编码到我的应用程序中的公钥来加密机密信息。要阅读它，需要一个私钥，而 2048 位 RSA 似乎足够安全。我选择了 pycrypto（也尝试了 M2Crypto，但几乎没有发现任何差异）并将日志加密实现为logging.Formatter子类。但是，我是 pycrypto 和密码学的新手，我不确定我选择的数据加密方式是否合理。PKCS1_OAEP模块是我需要的吗？还是有更友好的加密方式而不将数据分成小块？
所以，我所做的是：
import logging
import sys
from Crypto.Cipher import PKCS1_OAEP as pkcs1
from Crypto.PublicKey import RSA
PUBLIC_KEY = """ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDe2mtK03UhymB+SrIbJJUwCPhWNMl8/gA9d7jex0ciSuFfShDaqJ4wYWG4OOl\
VqKMxPrPcZ/PMSwtc021yI8TXfgewb65H/YQw4JzzGANq2+mFT8jWRDn+xUc6vcWnXIG3OPg5DvIipGQvIPNIUUP3qE7yDHnS5xdVdFrVe2bUUXmZJ9\
0xJpyqlTuRtIgfIfEQC9cggrdr1G50tXdXZjS0M1WXl5P6599oH/ykjpDFrCnh5fz9WDwUc0mNJ+11Qh+yfDp3k7AhzhRaROKLVWnfkklFaFm7LsdVX\
KPjp7dPRcTb84c2OnlIjU0ykL74Fy0K3eaPvM6TLe/K1XuD3933 pupkin@pupkin"""
PUBLIC_KEY = RSA.importKey(PUBLIC_KEY)
LOG_FORMAT = '[%(asctime)-15s - %(levelname)s: %(message)s]'
# May be more, but there is a limit.
# I suppose, the algorithm requires enough padding,
# and size of padding depends on key length.
MAX_MSG_LEN = 128
# Size of a block encoded with padding. For a 2048-bit key seems to be OK.
ENCODED_CHUNK_LEN = 256
def encode_msg(msg):
res = []
k = pkcs1.new(PUBLIC_KEY)
for i in xrange(0, len(msg), MAX_MSG_LEN):
v = k.encrypt(msg[i : i+MAX_MSG_LEN])
# There are nicer ways to make a readable line from data than using hex. However, using
# hex representation requires no extra code, so let it be hex.
res.append(v.encode('hex'))
assert len(v) == ENCODED_CHUNK_LEN
return ''.join(res)
def decode_msg(msg, private_key):
msg = msg.decode('hex')
res = []
k = pkcs1.new(private_key)
for i in xrange(0, len(msg), ENCODED_CHUNK_LEN):
res.append(k.decrypt(msg[i : i+ENCODED_CHUNK_LEN]))
return ''.join(res)
class CryptoFormatter(logging.Formatter):
NOT_SECRET = ('CRITICAL',)
def format(self, record):
"""
If needed, I may encode only certain types of messages.
"""
try:
msg = logging.Formatter.format(self, record)
if not record.levelname in self.NOT_SECRET:
msg = encode_msg(logging.Formatter.format(self, record))
return msg
except:
import traceback
return traceback.format_exc()
def decrypt_file(key_fname, data_fname):
"""
The function decrypts logs and never runs on server. In fact,
server does not have a private key at all. The only key owner
is server admin.
"""
res = ''
with open(key_fname, 'r') as kf:
pkey = RSA.importKey(kf.read())
with open(data_fname, 'r') as f:
for l in f:
l = l.strip()
if l:
try:
res += decode_msg(l, pkey) + '\n'
except Exception: # A line may be unencrypted
res += l + '\n'
return res
# Unfortunately dictConfig() does not support altering formatter class.
# Anyway, in demo code I am not going to use dictConfig().
logger = logging.getLogger()
handler = logging.StreamHandler(sys.stderr)
handler.setFormatter(CryptoFormatter(LOG_FORMAT))
logger.handlers = []
logger.addHandler(handler)
logging.warning("This is secret")
logging.critical("This is not secret")
更新：感谢下面接受的答案，现在我看到了：
我的解决方案现在似乎非常有效（日志条目很少，没有性能考虑，或多或少受信任的存储）。关于安全性，我现在能做的最好的事情就是不要忘记禁止运行我的守护程序的用户写入程序的
.py和.pyc文件。:-) 但是，如果用户受到威胁，他仍然可能会尝试将调试器附加到我的守护进程，所以我也应该为他禁用登录。非常明显的时刻，但非常重要的时刻。当然，有一些解决方案更具可扩展性。一种非常常见的技术是使用缓慢但可靠的 RSA 加密 AES 密钥，并使用非常快的 AES 加密数据。这种情况下的数据加密是对称的，但是检索 AES 密钥需要破坏 RSA，或者在我的程序运行时从内存中获取它。使用高级库和二进制日志文件格式进行流加密也是一种方法，尽管加密为流的二进制日志格式应该很容易受到日志损坏的影响，即使由于停电而突然重启也可能是一个问题，除非我这样做一些较低级别的事情（至少在每个守护程序启动时记录轮换）。
我
.encode('hex')改为.encode('base64').replace('\n').replace('\r'). 幸运的是，base64 编解码器工作正常，没有行尾。它节省了一些空间。使用不受信任的存储可能需要签署记录，但这似乎是另一回事。
根据捕获异常检查字符串是否加密是可以的，因为除非日志被恶意用户篡改，否则引发异常的是 base64 编解码器，而不是 RSA 解密。