客户端似乎在服务器发出特定回复后挂起

Question

我正在服务器和客户端之间实现身份验证过程，以便交换一些信息。我在服务器和客户端上创建了一个名为 serverToClientAuth 的函数，该函数执行基本的来回通信，以便在交换某些数据之前建立彼此经过身份验证的完整性检查。

当我运行服务器，然后运行客户端时，交换完美地进行，加密和哈希按要求工作，但是在从服务器到客户端的最后一条消息上，客户端似乎挂起并且无法退出该功能并返回正常运行 虽然前 3 次通信工作正常，但最后一次由于某种原因无法正常工作。

我一开始以为这与加密/解密功能有关，但随着前 3 个操作有效，我不明白为什么最后一个操作不起作用？看来 receive_msg 函数正在抓取最后一条消息而不是身份验证函数，这是客户端窗口上的最终“12”输出，如下所示。

我已经包含了服务器和客户端以及下面每个的输出。如果有人知道为什么会发生这种挂起，我们将不胜感激。

#Server.py
from socket import AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR, socket
from threading import Thread
from signal import signal, SIGINT
import sys
import os
import random
import rsa

WELCOME_MSG = 'Server is active and awaiting connections'

def nonceGenerator():
    num = ""
    for i in range(5):
        rand = random.randint(0,1)
        num += str(rand)
    return num

def generateAKeys():
    (publicKey, privateKey) = rsa.newkeys(1024)
    with open('keys/APubKey.pem', 'wb') as p:
        p.write(publicKey.save_pkcs1('PEM'))
    with open('keys/APrivKey.pem', 'wb') as p:
        p.write(privateKey.save_pkcs1('PEM'))

def generateBKeys():
    (publicKey, privateKey) = rsa.newkeys(1024)
    with open('keys/BPubKey.pem', 'wb') as p:
        p.write(publicKey.save_pkcs1('PEM'))
    with open('keys/BPrivKey.pem', 'wb') as p:
        p.write(privateKey.save_pkcs1('PEM'))

def generateCKeys():
    (publicKey, privateKey) = rsa.newkeys(1024)
    with open('keys/CPubKey.pem', 'wb') as p:
        p.write(publicKey.save_pkcs1('PEM'))
    with open('keys/CPrivKey.pem', 'wb') as p:
        p.write(privateKey.save_pkcs1('PEM'))

def generateSKeys():
    (publicKey, privateKey) = rsa.newkeys(1024)
    with open('keys/SPubKey.pem', 'wb') as p:
        p.write(publicKey.save_pkcs1('PEM'))
    with open('keys/SPrivKey.pem', 'wb') as p:
        p.write(privateKey.save_pkcs1('PEM'))       


def loadKeys():
    with open('keys/SPubKey.pem', 'rb') as p:
        SPubKey = rsa.PublicKey.load_pkcs1(p.read())
    with open('keys/SPrivKey.pem', 'rb') as p:
        SPrivKey = rsa.PrivateKey.load_pkcs1(p.read())
    with open('keys/APubKey.pem', 'rb') as p:
        APubKey = rsa.PublicKey.load_pkcs1(p.read())
    with open('keys/APrivKey.pem', 'rb') as p:
        APrivKey = rsa.PrivateKey.load_pkcs1(p.read())
    with open('keys/BPubKey.pem', 'rb') as p:
        BPubKey = rsa.PublicKey.load_pkcs1(p.read())
    with open('keys/BPrivKey.pem', 'rb') as p:
        BPrivKey = rsa.PrivateKey.load_pkcs1(p.read())
    with open('keys/CPubKey.pem', 'rb') as p:
        CPubKey = rsa.PublicKey.load_pkcs1(p.read())
    with open('keys/CPrivKey.pem', 'rb') as p:
        CPrivKey = rsa.PrivateKey.load_pkcs1(p.read())
    return SPubKey, SPrivKey, APubKey, APrivKey, BPubKey, BPrivKey, CPubKey, CPrivKey

def encrypt(message, key):
    return rsa.encrypt(message.encode('utf8'), key)

def decrypt(ciphertext, key):
    try:
        return rsa.decrypt(ciphertext, key).decode('utf8')
    except:
        return False

def sign(message, key):
    return rsa.sign(message.encode('utf8'), key, 'SHA-1')

def verify(message, signature, key):
    try:
        return rsa.verify(message.encode('utf8'), signature, key,) == 'SHA-1'
    except:
        return False

def incoming_connections():

    while True:

        client, addr = SERVER.accept()
        print(f'A client has connected {addr}')
        # client.send(WELCOME_MSG.encode())
        Thread(target=single_client, args=(client,)).start()
        print('Client connected')

def single_client(client):

    client_name = client.recv(BUFFERSIZE).decode()
    #client_name = 'Anonymous'
    welcome_msg = f'Welcome {client_name}.\nType exit() or press CTRL+D or CTRL+C to exit.\n'
    client.send(welcome_msg.encode())
    chat_msg = f'{client_name} has joined the room'
    broadcast_msg(chat_msg.encode())
    clients[client] = client_name

    serverToClientAuth(client) #Begin Authentication process upon reciving client

    while True:
        msg = client.recv(BUFFERSIZE)

        if msg == 'online()'.encode('utf8'):            
            real_clients_num, real_clients_name = get_clients()
            client.send(f'Online users {real_clients_num} : {real_clients_name}'.encode('utf8'))
        elif msg == EXIT_CMD.encode('utf8'):
            print(f'{clients[client]} has disconnected ')
            client.send('You are leaving the room...'.encode())
            client.close()
            client_leaving = clients[client]
            del clients[client]
            broadcast_msg(f'{client_leaving} has left the room!'.encode())
            break
        elif '@'.encode('utf8') in msg:
            unicast_msg(msg, client)
        else:
            broadcast_msg(msg, clients[client] + ': ')

def get_clients():
    
    real_clients_num = 0
    real_clients_name = []

    for k,v in clients.items():
        if v != 'Anonymous':
            real_clients_num += 1
            real_clients_name.append(v)

    return real_clients_num, real_clients_name

def broadcast_msg(msg, name=""):

    for client in clients:
        client.send(name.encode() + msg)

def unicast_msg(msg, client):
    # Get only name by removing @
    msg = msg.decode('utf8')
    refered_client, client_msg = msg.split(' ',1)
    client_to_connect = refered_client.strip('@')
    for k,v in clients.items():
        if v == client_to_connect:
            k.send(f'{clients[client]} -> {client_to_connect}: {client_msg}'.encode('utf8'))

def receive_msg():
    while True:
        try:
            msg = client_socket.recv(BUFFERSIZE).decode("utf8")
            print(msg)
        except OSError as error:
            return error
        
def serverToClientAuth(client):
    Ka=bytes('1', 'utf8')
    Kb=bytes('2', 'utf8')
    Kc=3
    user = clients[client] #A, B or C
    message1 = client.recv(1024) #Nonce Na, Nb or Nc
    NEnc, sig1 = message1[:128], message1[128:]
    N = decrypt(NEnc, SPrivKey)
    if verify(N, sig1, APubKey):
        Ns = nonceGenerator() #Servers Nonce
        NNs = "{}|{}".format(N, Ns)
        NNsEnc = encrypt(NNs, APubKey)
        sig2 = sign(NNs, SPrivKey)
        message2 = NNsEnc + sig2
        client.send(message2)

        message3 = client.recv(1024)
        NsXX = decrypt(message3, SPrivKey)
        print(NsXX)
        NsXX = NsXX.split("|")
        if NsXX[0] == Ns: #Does the Nonce that client returned match what was sent?
            if NsXX[1] == 'B' and NsXX[2] == 'C':
                message4 = Ka + Kb
                client.send(message4)
                print("Client " + user + " has been authenticated to the server\n")
            elif NsXX[1] == 'A' and NsXX[2] == 'C':
                message4 = "{}|{}".format(Ka, Kc)
                client.send(message4.encode('utf8'))
                print("Client " + user + " has been authenticated to the server\n")
            elif NsXX[1] == 'A' and NsXX[2] == 'B':
                message4 = "{}|{}".format(Ka, Kb)
                client.send(message4.encode('utf8'))
                print("Client " + user + " has been authenticated to the server\n")

            else:
                print("Unrecognised identifier")

        else:
            print("Replied nonce from Client does not match")

    else:
        print('The message signature could not be verified')


if __name__ == "__main__":

    clients = {}
    generateAKeys()
    generateBKeys()
    generateCKeys()
    generateSKeys()
    SPubKey, SPrivKey, APubKey, APrivKey, BPubKey, BPrivKey, CPubKey, CPrivKey = loadKeys()

    HOST = '127.0.0.1'
    PORT = 5000
    BUFFERSIZE = 1024
    ADDR = (HOST, PORT)
    EXIT_CMD = "exit()"
    SERVER = socket(AF_INET, SOCK_STREAM)
    SERVER.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    SERVER.bind(ADDR)
    SERVER.listen(2)

    print("Waiting for connection...")
    ACCEPT_THREAD = Thread(target=incoming_connections)
    ACCEPT_THREAD.start()
    ACCEPT_THREAD.join()
    SERVER.close()

服务器文件 ^^^

#Client A
from socket import AF_INET, socket, SOCK_STREAM
from threading import Thread
from signal import signal, SIGINT
import sys
import os 
import random
import rsa

def nonceGenerator():
    num = ""
    for i in range(5):
        rand = random.randint(0,1)
        num += str(rand)
    return num

def loadKeys():
    with open('keys/APubKey.pem', 'rb') as p:
        APubKey = rsa.PublicKey.load_pkcs1(p.read())
    with open('keys/APrivKey.pem', 'rb') as p:
        APrivKey = rsa.PrivateKey.load_pkcs1(p.read())
    with open('keys/SPubKey.pem', 'rb') as p:
        SPubKey = rsa.PublicKey.load_pkcs1(p.read())
    return APubKey, APrivKey, SPubKey

def encrypt(message, key):
    return rsa.encrypt(message.encode('utf8'), key)

def decrypt(ciphertext, key):
    try:
        return rsa.decrypt(ciphertext, key).decode('utf8')
    except:
        return False

def sign(message, key):
    return rsa.sign(message.encode('utf8'), key, 'SHA-1')

def verify(message, signature, key):
    try:
        return rsa.verify(message.encode('utf8'), signature, key,) == 'SHA-1'
    except:
        return False

def receive_msg():
    while True:
        try:
            msg = client_socket.recv(BUFFERSIZE).decode("utf8")
            print(msg)
        except OSError as error:
            return error

def keyBoard_Input():
    while True:
        try:
            msg = input()
            if msg != 'exit()':
                client_socket.send(msg.encode('utf8'))
            else:
                clean_exit()
        except EOFError:
            clean_exit()

def send_msg(data):
    try:
        msg = data
        if msg != 'exit()':
            client_socket.send(msg.encode('utf8'))
        else:
            clean_exit()
    except EOFError:
        clean_exit()

def clean_exit():
    client_socket.send('exit()'.encode('utf8'))
    client_socket.close()
    sys.exit(0)

def handler(signal_received, frame):
    clean_exit()

def serverToClientAuth(client):
    Na = nonceGenerator()
    NaEnc = encrypt(Na, SPubKey)
    sig1 = sign(Na, APrivKey)
    message1 = NaEnc + sig1
    client_socket.send(message1) 

    message2 = client_socket.recv(1024)
    NaNsEnc, sig2 = message2[:128], message2[128:]     
    NaNs = decrypt(NaNsEnc, APrivKey)
    if verify(NaNs, sig2, SPubKey):
        NaNs = NaNs.split("|")
        if NaNs[0] == Na:
            Ns = NaNs[1]
            print(Ns)
            
            NsBC = "{}|{}|{}".format(Ns, 'B', 'C')
            NsBCEnc = encrypt(NsBC, SPubKey) #No signature needed anymore
            message3 = NsBCEnc
            client_socket.send(message3)
            print('Client gets stuick here')
            message4 = client_socket.recv(1024)
            print(message4)
            message4 = message4.split("|")    
            APubKey, CPubKey = message3[0], message3[1]
            print("Client B is Authenticated to the Server")
            print("Ka = " + APubKey)
            print("Kc = " + CPubKey)


        else:
            print("Replied nonce from server does not match")
    else:
        print('The message signature could not be verified')


if __name__ == '__main__':
    
    signal(SIGINT, handler)
    
    HOST = '127.0.0.1'
    PORT = 5000

    BUFFERSIZE = 1024
    ADDR = (HOST, PORT)

    client_socket = socket(AF_INET, SOCK_STREAM)
    client_socket.connect(ADDR)
    receive_thread = Thread(target=receive_msg)
    receive_thread.start()
    
    APubKey, APrivKey, SPubKey = loadKeys()
    send_msg('A') #Assign Client ID at the moment the connection is initiated
    serverToClientAuth(client_socket)
    keyBoard_Input()

客户端文件 ^^^^

Waiting for connection...
A client has connected ('127.0.0.1', 51407)
Client connected
01001|B|C
Client A has been authenticated to the server

服务器响应 ^^^

Welcome A.
Type exit() or press CTRL+D or CTRL+C to exit.

01001
Client gets stuick here
12

客户端响应 ^^^

这里显示的“12”应该是“1|2”，因为这是服务器发送的消息。然而，似乎 receive_msg 函数实际上是在获取消息而不是函数，导致函数挂起并等待消息。