安全的数据库图形管理工具（2）：三个问题

import rsa
import socket
public_key = open("server_public_key.pem", "rb").read()  # 打开公钥文件并读取
public_key = rsa.PublicKey.load_pkcs1(public_key)  # 加载公钥
private_key = open("self_private_key.pem", "rb").read()  # 打开私钥文件并读取
private_key = rsa.PrivateKey.load_pkcs1(private_key)  # 加载私钥
# 用公钥加密要发送的数据
send_encode_data = rsa.encrypt(b"123456789012345678901234567890", public_key)
s = socket.socket()  # 创建套接字对象
host = "111.230.108.44"  # 服务器的IP地址
port = 1234  # 服务器程序的端口号
s.connect((host, port))  # 连接服务器
s.send(send_encode_data)  # 发送已经加密的数据
receive_encode_data = s.recv(128)  # 接受已经加密的数据
print(rsa.decrypt(receive_encode_data, private_key).decode())  # 解密接收到的加密数据并输出

for i in range(0, len(cmd), 20):
    sock.send(rsa.encrypt(cmd[i:i + 20], public_key))

import socket
import rsa
import json
import struct
public_key = rsa.PublicKey.load_pkcs1(open("server_public_key.pem", "rb").read())  # 加载公钥
private_key = rsa.PrivateKey.load_pkcs1(open("self_private_key.pem", "rb").read())  # 加载私钥
sock = socket.socket()  # 创建套接字对象
sock.connect(('', 8080))  # 连接服务器
while True:
    cmd = input().strip().encode()  # 1.输入命令 2.去除无效字符 3.编码成字节序列
    if not cmd:  # 如果输入的命令为空，继续下一次循环
        continue
    elif cmd == b'logout':  # 如果命令是logout就结束循环
        break
    for i in range(0, len(cmd), 20):  # 分块加密，一块20个字节
        sock.send(rsa.encrypt(cmd[i:i + 20], public_key))  # 发送加密的数据
    head = sock.recv(4)  # 接收报头长度
    head_json = struct.unpack("i", head)[0]  # 获取报头长度
    head_dic = json.loads(sock.recv(head_json).decode())  # 1.接收报头 2.将接收的报头解码成字符串 3.将字符串转换成对应的字典
    data_size = head_dic["data_size"]  # 获取字典的value，也就是真实数据长度
    block_list = []  # 接收数据的容器
    recv_size = 0  # 接收到的数据长度
    while recv_size < data_size:  # 当实际接收的数据长度小于应该接收的数据长度，就继续接收
        block = sock.recv(32)  # 接收数据，一次32个字节
        recv_size += len(block)  # 改变实际接收的数据长度
        block_list.append(block)  # 将接收的数据添加到容器中
    if data_size != 0:  # 如果应该接收的数据长度不等于0
        if block_list[-1] == b'':  # 如果最后一块是空字节
            del block_list[-1]  # 将最后一块删去
    for i in range(len(block_list)):  # 分块解密
        block_list[i] = rsa.decrypt(block_list[i], private_key)
    response = b"".join(block_list).decode()  # 拼接容器中的数据并解码成字符串
    print(response)  # 输出这个字符串
sock.close()  # 程序结束之前，关闭套接字对象

import socket
import rsa
from os import system
import json
import struct
from time import sleep
sock = socket.socket()  # 创建套接字对象
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # 设置套接字选项
sock.bind(('', 8080))  # 将IP和端口捆绑
sock.listen(1)  # 设置最大连接数
public_key = rsa.PublicKey.load_pkcs1(open("client_public_key.pem", "rb").read())  # 加载公钥
private_key = rsa.PrivateKey.load_pkcs1(open("self_private_key.pem", "rb").read())  # 加载私钥
conn, addr = sock.accept()  # 接受客户端连接
while True:
    try:
        conn.setblocking(True)  # 设置阻塞，防止后面的超时一直生效
        block = conn.recv(32)  # 接收数据
        block_list = []  # 接收数据的容器
        conn.settimeout(1)  # 设置超时，防止第23行发生阻塞
        while len(block) == 32:  # 当接收的字节等于32个，就一直接收
            block_list.append(block)  # 将接收的数据添加到容器中
            try:  # 尝试继续接收
                block = conn.recv(32)
            except socket.timeout:  # 如果超时，就把接收的数据置空，因为没有数据到来
                block = b""
        conn.setblocking(True)  # 设置阻塞，防止前面的超时一直生效
        block_list.append(block)  # 最后一次添加到容器
        if block_list[-1] == b'':  # 如果最后一个是空字节，就删去
            del block_list[-1]
        for i in range(len(block_list)):  # 分块解密
            block_list[i] = rsa.decrypt(block_list[i], private_key)
        request = b"".join(block_list).decode()  # 拼接容器中的数据并解码成字符串
        system(request+" 1> out 2> err")  # 执行命令（在命令执行过程中已经重定向到文件了）
        out, err = open("out", "rb").read(), open("err", "rb").read()  # 读取文件中的内容
        err_list = []  # 出错列表
        out_list = []  # 输出列表
        for i in range(0, len(err), 20):  # 如果当前的块不为空，将加密之后添加到出错列表中
            if err[i:i+20] != b"":
                err_list.append(rsa.encrypt(err[i:i+20], public_key))
            else:
                break
        for i in range(0, len(out), 20):  # 如果当前的块不为空，将加密之后添加到输出列表中
            if out[i:i+20] != b"":
                out_list.append(rsa.encrypt(out[i:i+20], public_key))
            else:
                break
        err = b"".join(err_list)  # 拼接加密之后的错误数据
        out = b"".join(out_list)  # 拼接加密之后的正确数据
        response_head = json.dumps({"data_size": len(out)+len(err)}).encode()  # 设置报头并转换成对应的类型
        conn.send(struct.pack("i", len(response_head)))  # 将报头长度压缩成一个定长字节序列并发送
        conn.send(response_head)  # 发送报头
        for i in range(0, len(err), 32):  # 分块发送出错的数据
            if len(err[i:i+32]) != 0:
                conn.send(err[i:i+32])
                sleep(0.001)  # 防止因为发送太快发送缓冲区溢出
        for i in range(0, len(out), 32):  # 分块发送正确的数据
            if len(out[i:i+32]) != 0:
                conn.send(out[i:i+32])
                sleep(0.001)  # 防止因为发送太快发送缓冲区溢出
    except KeyboardInterrupt:
        break
    except ConnectionResetError:
        break
sock.close()  # 在程序结束之前，关闭套接字对象