简单的远程加解密文件

本例通过客户端和服务器端来为大家展示一下AES来远程加解密文件（相关库的使用请自行搜索），通过socket来进行客户端和服务器的通信，客户端对服务器发送过来的密钥字符串、
iv值和一个字符串（可以为任意值），对客户端相应的文件进行加密操作，在这里大家可以将所有的文件都进行加密操作，请自行测试，但是请大家在测试期间，
不要使用自己重要的文件来测试，可以创建一些无用的文件来测试。

各位大牛请绕过，不要喷 ......

客户端主要是使用服务器上发送过来的key长度进行判断是否为16的整数倍，如果不够则使用随机数来将key填充到AES加解密的要求为止，然后使用getKey将所有生成的随机数进行保存，
然后再将其加密后，发送到服务器上。加密的密钥是服务器上发送过来的key加上getKey本地生成的随机数字符串，在不知道服务器上保存的数据和密钥及长度，大大增加了解密的难度。

具体的客户端代码如下：

"""
write by HuSoul
"""
# 客户端代码
# -*-  coding:utf-8  -*-

import random
from Crypto.Cipher import AES
import socket

# 使用AES加密文件的函数
def AESEncrypt_File(fs,key=b'123456789!@#$%^&',iv='3333333333333333',keyList='123456789!@#$%^&*(ABCDEFGHI'):

    keyLength = len(key)
    getKey = ''   # 保存在本地生成的所有随机数
    key_b = key   # 加密随机数的密钥

    if keyLength not in [16,24,32]:
        if keyLength < 16:
            key_b = key_b + keyList[6:16 - keyLength + 6]   # 至于这个密钥的选择可以自己定义一个空间，保证该密钥是16的整数倍
            for i in range(16 - keyLength):
                r = chr(random.randint(33,126))   # 生成随机数 33-126的可见字符
                key += r    # 将发送过来不够长度的密钥，加上随机字符到合法的密钥
                getKey += r
        elif 16 < keyLength < 24:
            key_b = key_b + keyList[9:24 - keyLength + 9]
            for i in range(24 - keyLength):
                r = chr(random.randint(33,126))
                key += r
                getKey += r
        elif 24 < keyLength < 32:
            key_b = key_b + keyList[11:32 - keyLength + 11]
            for i in range(32 - keyLength):
                r = chr(random.randint(33,126))
                key += r
                getKey += r
        else:
            key = key[0:32]

    cipherFile = AES.new(key,AES.MODE_CBC,iv)   # 生成加密时使用的实际密码
    enKey = AES.new(key_b,AES.MODE_CBC,iv)

    x = len(fs) % 16    # 因为AES分块大小固定为16字节，所以要判断输入的文本是否为16字节的整数倍

    fs_pad = ''
    if x != 0:
        fs_pad = fs + '0' * (16 - x)   # 当不是16字节的整数倍，就使用 '0' 字符补足
        print('fs_pad is :' + fs_pad)
        print(len(fs_pad))
        print(len(fs_pad) % 16)

    msg = cipherFile.encrypt(fs_pad)   # 加密文件流
    if len(getKey.strip()) < 16:
        getKey += '*' * (16 - len(getKey))
    remainingKey = enKey.encrypt(getKey)   # 加密剩下的key
    return msg,remainingKey

# 使用AES解密文件的函数
def AESDecrypt_File(fs,key=b'123456789!@#$%^&',iv='3333333333333333'):

    # AES key must be either 16, 24, or 32 bytes long
    cipher = AES.new(key,AES.MODE_CBC,iv)

    x = len(fs) % 16    # 因为AES分块大小固定为16字节，所以要判断输入的文本是否为16字节的整数倍

    fs_pad = fs
    if x != 0:
        fs_pad += '0' * (16 - x)   # 当不是16字节的整数倍，就使用 '0' 字符补足
        print('fs_pad is :' + fs_pad)
        print(len(fs_pad))
        print(len(fs_pad) % 16)

    msg_pd = cipher.decrypt(fs_pad)
    return msg_pd


def EncryptFile(fs,key=b'123456789!@#$%^&',iv='3333333333333333',keyList=''):

    getFile = open(fs,'rb')
    getFile.seek(0,0)
    fs_msg = getFile.read()
    getFile.close()


    # encrypt src FileStream
    fsCon = fs.split('.')
    fen = open(fsCon[0]+'_b.'+ fsCon[1],'wb')
    fen_msg,getKey = AESEncrypt_File(fs_msg,key,iv,keyList)
    fen.writelines(fen_msg)
    fen.close()

    return getKey


def DecryptFile(fs,key=b'123456789!@#$%^&',iv='3333333333333333'):
    getFile = open(fs,'rb')
    getFile.seek(0,0)
    fs_msg = getFile.read()
    getFile.close()

    # decrypt src FileStream
    fsCon = fs.split('.')
    fde = open(fsCon[0] + 'b.' + fsCon[1],'wb')
    fde_msg = AESDecrypt_File(fs_msg,key,iv)
    fde.writelines(fde_msg)
    fde.close()

# 与服务器通信
def Connection():
    """
    Connecting by Client
    :return:
    """
    ID = 12345678
    Host = '127.0.0.1'
    Port = 7896
    # 先获取相应的密钥信息
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    s.bind((Host,Port))
    s.listen(5)
    q = True
    getKey = ''
    while True:
        conn,addr = s.accept()
        while q:
            # 接收相应的密钥 iv string
            receive = conn.recv(1024)
            info = receive.split(':')
            if info[0] == 'en':
                # Encrypt test
                getKey = EncryptFile('Desert.jpg',info[1],info[2],info[3])
                conn.close()
                print('file is already encrypt successfully')
                q = False

                # 再发送剩余的密钥给服务器
                c2s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                c2s.connect((Host,9999))
                c2s.sendall(str(ID) + '0x255' + getKey)
                c2s.close()
            elif info[0] == 'de':
                # Decrypt test
                DecryptFile('Desert_b.jpg',info[1],info[2])
                conn.close()
                print('file is already decrypt successfully')
                # 发送信息给服务器
                c2s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                c2s.connect((Host,9999))
                c2s.sendall('de:Decrypt Successfully ...')
                c2s.close()
                q = False
if __name__ == '__main__':
  Connection()

在服务器端则只需使用socket进行对客户端进行连接（对于socket的使用请自行搜索），设置相关的参数和值，发送相应的数据和命令来达到加解密远程文件的操作。

# 服务器端的代码

#   -*- coding:utf-8   -*-
import socket
from Crypto.Cipher import AES

Host = '127.0.0.1'
Port = 9999

# key
key = 'testtest'
# iv
iv = '1234567890QWERTY'   # iv是要求要16位、24位和32位的，与加密的密钥长度一样,这个值可以自己修改
# keyList
keyList = '1$d9Ry*g2^Sj0&b%3)+6}vP4@,Wv-+A)'  # 用于加密随机数时，填充到密钥的后面的字符集

keyLength = len(key)

# 加密代码
s2cEn = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s2cEn.connect((Host,7896))
s2cEn.sendall('en'+ ':' + key + ':' + iv + ':' + keyList)

# 获取远程主机发送过来的加密随机数字符串
ss = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ss.bind((Host,Port))
ss.listen(5)
q = True
getKey = ''
while True:
    conn,addr = ss.accept()
    while q:
        remainingKey = conn.recv(1024)

        conn.close()
        print('Successful to get the person key by : ' + str(addr))
        q = False
        if keyLength not in [16,24,32]:
            if keyLength < 16:
                key_b = key + keyList[6:16 - keyLength + 6]
            elif 16 < keyLength < 24:
                key_b = key + keyList[9:24 - keyLength + 9]
            elif 24 < keyLength < 32:
                key_b = key + keyList[11:32 - keyLength + 11]
            else:
                key = key[0:32]
        # decrypt received remainingKey
        remainKey = remainingKey.split('0x255')
        print('remainKey[1] : ' + remainKey[1])
        decryptRekey = AES.new(key_b,AES.MODE_CBC,iv)
        getKey = decryptRekey.decrypt(remainKey[1])
        print(getKey)   # 获取随机数
        

# 解密代码
getKey = '12345678'  # 随机数字符串,从上述的加密代码中控制台输出的getKey值
deKey = key + getKey
s2cDe = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s2cDe.connect((Host,7896))
s2cDe.sendall('de' + ':' + deKey + ':' + iv)

当你要解密远程文件时，调用解密代码进行解密文件，但是此时应当将上述加密的代码注释，当然你可以用一个选项来选择相应的操作，
对远程主机进行操作，可以修改适当的代码来达到你的需求。

至于上述的过程虽然没有将所有的代码都解释的很清楚，但是我相信代码上的注释大家还是可以看懂的。虽然这段代码的意义不大，在一些加密文件的手段上也是用代码堆积而成的，
但是我希望可以给大家编写程序时带来灵感，通过不同的案例来启发大家对编程的热爱。

免责声明： 
　　请勿用于非法用途，如有盗用，后果自负，一切责任与本人无关

 作者：http://www.cnblogs.com/GHost-Ma/
 出处：http://www.cnblogs.com/GHost-Ma/
 版权：本文版权归作者和博客园共有
 转载：欢迎转载，但未经作者同意，必须保留此段声明；必须在文章中给出原文连接；否则必究法律责任