python3 + wxpython 实现RSA加密聊天室

版权声明:本文为博主原创连载文章,为了内容连贯性,未经博主允许不得转载。 https://blog.csdn.net/Kevinhanser/article/details/81365179

python3 + wxpython 实现 RSA 加密聊天室


2018年8月2日16:31:26 【原创】
目录:python 编程博客 索引

1. 运行环境

最近打算使用 python3 写一个图形化的聊天室,需要涉及到 RSA 加密模块,使用的是 python 自带的 RSA 加密模块

另外我的环境使用了 wxpython 图形化模块,安装方法也很简单

pip install wxpython
pip install pyinstaller
pip install cryptography

wxpython 已经更新到版本 4.0 了,在这里的小软件中的环境是可以兼容使用的

打包成文件

pyinstaller -F -w -i C:\Users\John\Desktop\pythonworkV4.0\icon.ico C:\Users\John\Desktop\pythonworkV4.0\setup.py

参考了博客 应该是这两个链接:

wxpython select 聊天室server+client

OpenSSL和Python实现RSA Key数字签名和验证


2. 功能简介

1. 作为聊天室服务器登录
2. 作为聊天室客户端登录
3. 客户端链接服务器IP
4. 客户端1与服务器进行验证
5. 客户端2与服务器进行验证
6. 客户端1加密消息并发送
7. 服务器解密消息并转发到客户端2
8. 客户端2发送消息同客户端1
  1. 主界面

    在这里插入图片描述

  2. 代码下载

    python3 + wxpython 实现RSA加密聊天室

3. 程序代码

# -*- coding: utf-8 -*-
#Python3-OpenSSL
#pip3 install cryptography

import wx
import socket
import threading
import sys
import select
import queue as Queue
# 导入cryptography库的相关模块和函数
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization

from cryptography.hazmat.primitives.asymmetric import padding

#data_file_name = r'msg.bin'
data_file_name = r'msg.txt'
encrypted_file_name = r'msg.bin.encrypted'
decrypted_file_name = r'msg.bin.decrypted'

private_key_file_name = r'Key.pem'
public_key_file_name = r'Key_pub.pem'



class chatdlg(wx.Dialog):
    def __init__(self):
        wx.Dialog.__init__(self, None, -1, u'基于 OpenSSL 聊天工具的设计与实现', 
                size=(610, 500))

        self.DisplayText = wx.TextCtrl(self, -1, '', 
                size=(600, 350), style=wx.TE_MULTILINE)

        self.InputText = wx.TextCtrl(self, -1, "Hi,How are you! ", 
                pos=(5, 370), size=(480, -1))

        self.sendButton = wx.Button(self, -1, "Send", pos=(500, 370))
        self.Bind(wx.EVT_BUTTON, self.OnSendClick, self.sendButton)
        self.sendButton.SetDefault()

        wx.StaticText(self, -1, "IP", (5, 415))
        self.IPText = wx.TextCtrl(self, -1, "127.0.0.1", 
                pos=(30, 415), size=(150, -1))
        wx.StaticText(self, -1, "Port", (200, 415))
        self.PortText = wx.TextCtrl(self, -1, "8001", 
                pos=(230, 415), size=(50, -1))

        self.cButton = wx.Button(self, -1, "Connect as a client", pos=(300, 415))
        self.Bind(wx.EVT_BUTTON, self.OnClientClick, self.cButton)
        self.sButton = wx.Button(self, -1, "Connect as a Server", pos=(450, 415))
        self.Bind(wx.EVT_BUTTON, self.OnSeverClick, self.sButton)

    def OnSendClick(self, event):
       #self.sendButton.SetLabel("Clicked")
        self.send_data = self.InputText.GetValue()
        
        try:
            #print(self.send_data)

            fo = open(data_file_name,'w')
            fo.write(self.send_data)
            fo.close()
            # 先对数据加密
            self.datamsg = encrypt(data_file_name, encrypted_file_name, public_key_file_name)


            self.client.send(self.datamsg)   # self.datamsg 是客户端要发送的密文

            # self.client.send(self.send_data.encode('utf-8'))   ##encoding="utf-8"
            
            self.DisplayText.AppendText('\nYour said:  [')
            #self.DisplayText.AppendText(self.send_data.encode())   #encoding="utf-8"
            self.DisplayText.AppendText(self.send_data)
            self.DisplayText.AppendText(']\n')
        except  socket.error:
            self.DisplayText.AppendText('Pls connect to chat server @%d firstly\n' % self.port)

    def SocketProc_server(self):
        self.sButton.SetLabel(self.PortText.GetValue())
        
        # Sockets to which we expect to write
        outputs = [ ]

        # Outgoing message queues (socket:Queue)
        message_queues = {}

        #创建socket并绑定
        self.server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        self.port = int(self.PortText.GetValue())
        self.host = ''

        print('Waiting for connection @%s:%d\n' % (self.host, self.port))

        self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server.bind((self.host, self.port))
        self.server.listen(5)        

        self.DisplayText.AppendText('Waiting for connection @%s:%d\n' % (self.host, self.port))

        # Sockets from which we expect to read
        inputs = [ self.server ]

        while inputs:
            # Wait for at least one of the sockets to be ready for processing
            print('\n>>sys.stderr, waiting for the next event')
            readable, writable, exceptional = select.select(inputs, outputs, inputs)

            fo = open(encrypted_file_name,'w')
            fo.write('')
            fo.close()

            
            # Handle inputs
            for s in readable:
                if s is self.server:
                    # A "readable" server socket is ready to accept a connection
                    connection, client_address = s.accept()
                    print(client_address)

                    self.DisplayText.AppendText('new connection from %s, %s \n' % (client_address[0],client_address[1]))#$!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                    connection.setblocking(False)
                    inputs.append(connection)

                    # Give the connection a queue for data we want to send
                    message_queues[connection] = Queue.Queue()
                else:
                    
                    data = s.recv(1024)

                    fo = open(encrypted_file_name,'ab')
                    fo.write(data)
                    fo.close()
                    datamsg = decrypt(encrypted_file_name, decrypted_file_name, private_key_file_name)

                
                    if data:
                        # A readable client socket has data
                        print('received [%s] from %s' % (datamsg, s.getpeername()))

                        self.DisplayText.AppendText('received [%s] from %s\n' % (datamsg, s.getpeername()))

                        for c in inputs:
                            if c is self.server:
                                print('\nfrom server')
                            elif c is not s:
                                print('send_data [%s] to %s' % (datamsg, s.getpeername()))     #.decode()
                                message_queues[c].put('[ %s ] from %s ' % (datamsg,str(s.getpeername())))
                                if c not in outputs:
                                    outputs.append(c)
                    else:
                        # Interpret empty result as closed connection
                        print('closing %,%s after reading no data' % (client_address[0],client_address[1]))
                        
                        self.DisplayText.AppendText('closing %s,%s after reading no data\n\n' % (client_address[0],client_address[1]))
                        # Stop listening for input on the connection
                        if s in outputs:
                            outputs.remove(s)
                        inputs.remove(s)
                        s.close()
                        
                        # Remove message queue
                        del message_queues[s]

            # Handle outputs
            for s in writable:
                try:
                    next_msg = message_queues[s].get_nowait()
                except Queue.Empty:
                    print('output queue for %s, %s is empty' % (s.getpeername()[0],s.getpeername()[1]))
                    outputs.remove(s)
                else:
                    print('sending "%s" to %s' % (next_msg, s.getpeername()))       # datamsg 是解码后的,用于显示在服务器端界面
                    print(datamsg)  # datamsg 是解码后的,用于显示在服务器端界面

                    
                    s.send(data)    # data 是解码前的

                    
            # Handle "exceptional conditions"
            for s in exceptional:
                print('handling exceptional condition for %s ' % s.getpeername())
                self.DisplayText.AppendText('handling exceptional condition for', s.getpeername())
                # Stop listening for input on the connection
                inputs.remove(s)
                if s in outputs:
                    outputs.remove(s)
                s.close()

                # Remove message queue
                del message_queues[s]   

    def SocketProc_client(self):
        self.cButton.SetLabel(self.PortText.GetValue())
        
        # Sockets to which we expect to write
        outputs = [ ]

        # Outgoing message queues (socket:Queue)
        message_queues = {}

        self.client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        self.host = str(self.IPText.GetValue())
        self.port = int(self.PortText.GetValue())
        print('Connecting to chat server@%s:%d\n' % (self.host, self.port))
        try:
            self.client.connect((self.host, self.port))
            print('connected to chat server @%s:%d\n' % (self.host, self.port))
            self.DisplayText.AppendText('Connected to chat server@%s:%d\n' % (self.host, self.port))
        except socket.error:
            print('Could not connect to chat server @%s:%d\n' % (self.host, self.port))
            self.DisplayText.AppendText('Could not connect to chat server @%s:%d\n' % (self.host, self.port))
            return

        inputs = [ self.client ]
        message_queues[self.client] = Queue.Queue()


        while inputs:
            # Wait for at least one of the sockets to be ready for processing
            print('\nwaiting for the next event')
            readable, writable, exceptional = select.select(inputs, outputs, inputs)
    

            fo = open(encrypted_file_name,'w')
            fo.write('')
            fo.close()


            
            # Handle inputs
            for s in readable:
                data = s.recv(1024) # data是客户端刚接收到的密文

                fo = open(encrypted_file_name,'ab')
                fo.write(data)  #将密文写入文件
                fo.close()
                datamsg = decrypt(encrypted_file_name, decrypted_file_name, private_key_file_name)
                
                    
                if data:

                    print('received "%s" from %s' % (datamsg.decode('utf-8'), s.getpeername())) # datamsg 是客户端接收到密文之后进行解密的信息

                    self.DisplayText.AppendText('received "%s"\n' % datamsg.decode('utf-8'))    # 显示明文
                else:
                    # Interpret empty result as closed connection
                    print('>>sys.stderr, closing %s after reading no data' % (client_address[0],client_address[1]))
                    #self.DisplayText.AppendText('closing %s after reading no data\n\n' % client_address)#!!!!!!!!!!!!!!!!!!!!!!!!!
                    # Stop listening for input on the connection
                    if s in outputs:
                        outputs.remove(s)
                    inputs.remove(s)
                    s.close()
                    
                    # Remove message queue
                    del message_queues[s]

            # Handle outputs
            for s in writable:
                try:
                    next_msg = message_queues[s].get_nowait()
                except Queue.Empty:
                    # No messages waiting so stop checking for writability.
                    print('>>sys.stderr, output queue for % is empty' % s.getpeername())
                    outputs.remove(s)
                else:
                    print('>>sys.stderr, sending "%s" to %s' % (next_msg, s.getpeername()))

                    fo = open(data_file_name,'w')
                    fo.write(next_msg)
                    fo.close()
                    # 先对数据加密
                    datamsg = encrypt(data_file_name, encrypted_file_name, public_key_file_name)
                    # 打印加密结果
                    print("encrypted data:")
                    #dump_hex(data)
                    print(datamsg)
                    '''
                    # 对数据进行解密
                    datatest = decrypt(encrypted_file_name, decrypted_file_name, private_key_file_name)
                    # 打印解密结果
                    print("decrypted data:")
                    print(datatest)
                    print('!!!!!!!!!!!!!!!!!!!!!!')
                    print('!!!!!!!!!!!!!!!!!!!!!!')
                    print('!!!!!!!!!!!!!!!!!!!!!!')
                    '''



                    
                    s.send(datamsg)
            # Handle "exceptional conditions"
            for s in exceptional:
                print('>>sys.stderr, handling exceptional condition for %s ' % s.getpeername())
                self.DisplayText.AppendText('handling exceptional condition for % s' % s.getpeername())
                # Stop listening for input on the connection
                inputs.remove(s)
                if s in outputs:
                    outputs.remove(s)
                s.close()

                # Remove message queue
                del message_queues[s]    
    def SocketProc_process(self):
        pass
        #recv all recv_data
        #broadcast msg

    def OnSeverClick(self, event):
        self.socketmode=1
        #thread.start_new_thread(self.SocketProc_server,())
        trd=threading.Thread(target=self.SocketProc_server)
        trd.setDaemon(True) 
        trd.start()

        

    def OnClientClick(self, event):
        self.socketmode=0
        #self.cButton.SetLabel("connected")
        #thread.start_new_thread(self.SocketProc_client,())
        
        #threading.Thread
        trd=threading.Thread(target=self.SocketProc_client)
        trd.setDaemon(True) 
        trd.start()



# 定义辅助函数,用于打印16进制数据
def dump_hex(buffer, sep=' ', indent=0, line_size=16):
    """
    辅助函数,将bytes数组以如下格式打印输出:
    0000: 40 71 37 d0 80 32 7f 04 d9 6d fb fc f7 6a 7d d4
    0010: 48 ad 75 79 7a 0d 6c 55 01 ed 45 d5 1e 75 33 a6
    :param buffer: 待打印数据
    :param sep: 各16进制数据之间的分隔符,默认用空格' '分隔
    :param indent: 打印输出前是否需要缩进,默认不缩进
    :param line_size: 每行输出16进制的数量,默认1行输出16个
    :return: 无返回值
    """
    # 计算缩进空格数
    leading = '%s' % ' '*indent
    # 循环打印每行16进制数据
    for x in range(0, len(buffer), line_size):
        # 打印缩进字符和当前行数据的起始地址
        print('%s%04X: ' % (leading, x))
        # 将当前行数据制作成列表list,并打印
        line = ['%02x' % i for i in buffer[x:x+line_size]]
        #print(*line, sep=sep, end='\n')


# 加密函数
def encrypt(src_file_name, dst_file_name, public_key_file_name):
    """
    对原始数据文件使用指定的公钥进行加密,并将加密输出到目标文件中
    :param src_file_name: 原始数据文件
    :param dst_file_name: 加密输出文件
    :param public_key_file_name: 用于加密的公钥
    :return: 加密结果的bytes数组
    """
    # 读取原始数据
    data_file = open(src_file_name, 'rb')
    data = data_file.read()
    data_file.close()

    # 读取公钥数据
    key_file = open(public_key_file_name, 'rb')
    key_data = key_file.read()
    key_file.close()

    # 从公钥数据中加载公钥 
    public_key = serialization.load_pem_public_key(
        key_data,
        backend=default_backend()
        )

    # 使用公钥对原始数据进行加密,使用PKCS#1 v1.5的填充方式
    out_data = public_key.encrypt(
        data,
        padding.PKCS1v15()
    )

    # 将加密结果输出到目标文件中
    # write encrypted data
    out_data_file = open(dst_file_name, 'wb')
    out_data_file.write(out_data)
    out_data_file.close()

    # 返回加密结果
    return out_data


# 解密函数
def decrypt(src_file_name, dst_file_name, private_key_file_name):
    """
    对原始数据文件使用指定的私钥进行解密,并将结果输出到目标文件中
    :param src_file_name: 原始数据文件
    :param dst_file_name: 解密输出文件
    :param private_key_file_name: 用于解密的私钥
    :return: 解密结果的bytes数组
    """
    # 读取原始数据
    data_file = open(src_file_name, 'rb')
    data = data_file.read()
    data_file.close()

    # 读取私钥数据
    key_file = open(private_key_file_name, 'rb')
    key_data = key_file.read()
    key_file.close()

    # 从私钥数据中加载私钥
    private_key = serialization.load_pem_private_key(
        key_data,
        password=None,
        backend=default_backend()
    )

    # 使用私钥对数据进行解密,使用PKCS#1 v1.5的填充方式
    out_data = private_key.decrypt(
        data,
        padding.PKCS1v15()
    )

    # 将解密结果输出到目标文件中
    out_data_file = open(dst_file_name, 'wb')
    out_data_file.write(out_data)
    out_data_file.close()

    # 返回解密结果
    return out_data


if __name__ == '__main__':
    app = wx.App()
    app.MainLoop() 
    dialog = chatdlg()
    result = dialog.ShowModal()
    if result == wx.ID_OK:
        print("OK")
    else:
        print("Cancel")
    dialog.Destroy()
展开阅读全文

没有更多推荐了,返回首页