嘗試在客戶端和服務器之間進行安全套接字通信并得到一個操作嘗試在不是套接字錯誤的東西上-有解無憂

我正在嘗試拼湊一個安全的套接字客戶端服務器通信解決方案。我沒有這樣做的經驗，所以拼湊了我認為相關的部分。這個想法是服務器等待連接，客戶端創建一個安全的連接，然后可以進行通信。

該代碼還利用安全通信與客戶端和服務器密鑰和證書進行授權。

客戶端代碼：


class Client:
    def __init__(self):
        try:
            self.host, self.port = "127.0.0.1", 65416
            self.client_cert = os.path.join(os.path.dirname(__file__), "client.crt")
            self.client_key = os.path.join(os.path.dirname(__file__), "client.key")
            self._context = ssl.SSLContext()
            self._context.load_cert_chain(self.client_cert, self.client_key)
            self._sock = None
            self._ssock = None
        except Exception as e:
            print("Error in Initializing")

    def checkvalidclient(self):
        # ---- Client Communication Setup ----

        HOST = self.host  # The server's hostname or IP address
        PORT = self.port        # The port used by the server
        try:
            self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self._ssock = self._context.wrap_socket(self._sock,)
            self._ssock.connect((HOST, PORT))
            print ("Socket successfully created")
        except socket.error as err:
            print ("socket creation failed with error %s" %(err))

        print('Waiting for connection')
        Response = self._ssock.recv(1024)
        while True:
            Input = input('Say Something: ')
            # s.send(str.encode(Input))
            send_msg(self._ssock, str.encode(Input))
            # Response = s.recv(1024)
            Response = recv_msg(self._ssock)
            if Response is not None:
                print(Response.decode('utf-8'))

    def closesockconnection(self):
        self._ssock.close()

# ---- To Avoid Message Boundary Problem on top of TCP protocol ----
def send_msg(sock: socket, msg):  # ---- Use this to send
    # Prefix each message with a 4-byte length (network byte order)
    msg = struct.pack('>I', len(msg))   msg
    sock.sendall(msg)

def recv_msg(sock: socket):       # ---- Use this to receive
    # Read message length and unpack it into an integer
    raw_msglen = recvall(sock, 4)
    if not raw_msglen:
        return None
    msglen = struct.unpack('>I', raw_msglen)[0]
    # Read the message data
    return recvall(sock, msglen)

def recvall(sock: socket, n: int):
    # Helper function to receive n bytes or return None if EOF is hit
    data = bytearray()
    while len(data) < n:
        packet = sock.recv(n - len(data))
        if not packet:
            return None
        data.extend(packet)
    return data

client = Client()
client.checkvalidclient()

服務器代碼：

import socket
import os
import ssl
from os import path
from _thread import *
import struct # Here to convert Python data types into byte streams (in string) and back

# ---- To Avoid Message Boundary Problem on top of TCP protocol ----
def send_msg(sock: socket, msg):  # ---- Use this to send
    # Prefix each message with a 4-byte length (network byte order)
    msg = struct.pack('>I', len(msg))   msg
    sock.sendall(msg)

def recv_msg(sock: socket):       # ---- Use this to receive
    # Read message length and unpack it into an integer
    raw_msglen = recvall(sock, 4)
    if not raw_msglen:
        return None
    msglen = struct.unpack('>I', raw_msglen)[0]
    # Read the message data
    return recvall(sock, msglen)

def recvall(sock: socket, n: int):
    # Helper function to receive n bytes or return None if EOF is hit
    try:
        data = bytearray()
        while len(data) < n:
            packet = sock.recv(n - len(data))
            if not packet:
                return None
            data.extend(packet)
        return data
    except Exception as e:
        print("Exception in recvall : "   str(e))

# ---- Server Communication Setup
class Server:

    def __init__(self):
        self.HOST = '127.0.0.1'  # Standard loopback interface address (localhost)
        self.PORT = 65416        # Port to listen on (non-privileged ports are > 1023)
        self.ThreadCount = 0
        self.server_cert = path.join(path.dirname(__file__), "server.crt")
        self.server_key = path.join(path.dirname(__file__), "server.key")
        self.client_cert = path.join(path.dirname(__file__), "client.crt")

        self._context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
        self._context.verify_mode = ssl.CERT_REQUIRED
        self._context.load_cert_chain(self.server_cert, self.server_key)
        self._context.load_verify_locations(self.client_cert)
        self.sock = None

    def connect(self):
        try: # create socket
            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
            print ("Socket successfully created")
        except socket.error as err:
            print ("socket creation failed with error %s" %(err))

        try: # bind socket to an address
            self.sock.bind((self.HOST, self.PORT))
        except socket.error as e:
            print(str(e))

        print('Waiting for a Connection..')
        self.sock.listen(3)

    def threaded_client(self, conn: socket):
        conn.send(str.encode('Welcome to the Server'))
        while True:
            # data = conn.recv(2048) # receive message from client
            data = recv_msg(conn)
            print(data)
            if data is not None:
                reply = 'Server Says:  '   data.decode('utf-8')
                if not data:
                    break
                # conn.sendall(str.encode(reply))
                send_msg(conn, str.encode(reply))
        #conn.close()

    def waitforconnection(self):
        while True:
            Client, addr = self.sock.accept()
            self._context.wrap_socket(Client, server_side=True)
            print('Connected to: '   addr[0]   ':'   str(addr[1]))

            start_new_thread(self.threaded_client, (Client, )) # Calling threaded_client() on a new thread
            self.ThreadCount  = 1
            print('Thread Number: '   str(self.ThreadCount))
        #self.sock.close()

server = Server()
server.connect()
server.waitforconnection()

這些行：

    def threaded_client(self, conn: socket):
        conn.send(str.encode('Welcome to the Server'))

導致錯誤：[WinError 10038] 嘗試對不是套接字的東西進行操作

當我洗掉客戶端中的證書相關行時：

            self.client_cert = os.path.join(os.path.dirname(__file__), "client.crt")
            self.client_key = os.path.join(os.path.dirname(__file__), "client.key")
            self._context = ssl.SSLContext()
            self._context.load_cert_chain(self.client_cert, self.client_key)

和服務器中的證書相關行：

        self.server_cert = path.join(path.dirname(__file__), "server.crt")
        self.server_key = path.join(path.dirname(__file__), "server.key")
        self.client_cert = path.join(path.dirname(__file__), "client.crt")

        self._context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
        self._context.verify_mode = ssl.CERT_REQUIRED
        self._context.load_cert_chain(self.server_cert, self.server_key)
        self._context.load_verify_locations(self.client_cert)
        self.sock = None

并進行了一些小的更改以洗掉與證書相關的功能，一切似乎都正常，客戶端可以向服務器發送訊息并且服務器可以回應（并且客戶端顯示回應）。

但是，當我添加與背景關系相關的證書時，我開始收到錯誤訊息：嘗試對不是套接字的東西進行操作

服務器等待：

Client, addr = self.sock.accept()

并在客戶端呼叫后繼續運行（在 client.py 檔案中）：

self._ssock.connect((HOST, PORT))

然后服務器到達以下行：

    def threaded_client(self, conn: socket):
        conn.send(str.encode('Welcome to the Server'))

在此錯誤上失敗的地方。

列印終端，回溯和例外錯誤導致：

Socket successfully created
Waiting for a Connection..
Connected to: 127.0.0.1:57434
Thread Number: 1
Traceback (most recent call last):
  File "c:\testcode\Server.py", line 71, in threaded_client
    conn.send(str.encode('Welcome to the Server'))
OSError: [WinError 10038] An operation was attempted on something that is not a socket

我的知識有限，我找不到更多安全多執行緒雙向通信客戶端到服務器套接字代碼的示例。這個想法是確保客戶端在傳輸發生之前被授權與服務器通信。

關于我在哪里失敗的任何想法？

謝謝

uj5u.com熱心網友回復：

好的，看起來我已經接近了，但需要做一些調整。

解決方案： SSL/TLS客戶端證書驗證與Python v3.4 SSLContext

和這里的評論者，幫助我越過了終點線。

服務器代碼：

import socket
import os
from socket import AF_INET, SOCK_STREAM, SO_REUSEADDR, SOL_SOCKET, SHUT_RDWR
import ssl
from os import path
from _thread import *
import struct # Here to convert Python data types into byte streams (in string) and back
import traceback

# ---- To Avoid Message Boundary Problem on top of TCP protocol ----
def send_msg(sock: socket, msg):  # ---- Use this to send
    # Prefix each message with a 4-byte length (network byte order)
    msg = struct.pack('>I', len(msg))   msg
    sock.sendall(msg)

def recv_msg(sock: socket):       # ---- Use this to receive
    # Read message length and unpack it into an integer
    raw_msglen = recvall(sock, 4)
    if not raw_msglen:
        return None
    msglen = struct.unpack('>I', raw_msglen)[0]
    # Read the message data
    return recvall(sock, msglen)

def recvall(sock: socket, n: int):
    # Helper function to receive n bytes or return None if EOF is hit
    try:
        data = bytearray()
        while len(data) < n:
            packet = sock.recv(n - len(data))
            if not packet:
                return None
            data.extend(packet)
        return data
    except Exception as e:
        print("Exception in recvall : "   str(e))

# ---- Server Communication Setup
class Server:

    def __init__(self):
        self.HOST = '127.0.0.1'  # Standard loopback interface address (localhost)
        self.PORT = 65416        # Port to listen on (non-privileged ports are > 1023)
        self.ThreadCount = 0
        self.server_cert = path.join(path.dirname(__file__), "server.crt")
        self.server_key = path.join(path.dirname(__file__), "server.key")
        self.client_cert = path.join(path.dirname(__file__), "client.crt")

        self._context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
        self._context.verify_mode = ssl.CERT_REQUIRED
        self._context.load_cert_chain(certfile=self.server_cert, keyfile=self.server_key)
        self._context.load_verify_locations(cafile=self.client_cert)

        self.sock = None

    def connect(self):
        try: # create socket
            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) ###<-- socket.socket() ???
            print ("Socket successfully created")
        except socket.error as err:
            print ("socket creation failed with error %s" %(err))

        try: # bind socket to an address
            self.sock.bind((self.HOST, self.PORT))
        except socket.error as e:
            print(str(e))

        print('Waiting for a Connection..')
        self.sock.listen(3)

    def threaded_client(self, conn: socket):
        try:
            conn.send(str.encode('Welcome to the Server'))
            while True:
                data = recv_msg(conn)
                print("data")
                print(data)
                if data is not None:
                    reply = 'Server Says: '   data.decode('utf-8')
                    if not data:
                        break
                    send_msg(conn, str.encode(reply))
        except Exception as e:
            print(traceback.format_exc())
            print(str(e))
        finally:
            print("Closing connection")
            conn.shutdown(socket.SHUT_RDWR)
            conn.close()

        #conn.close()

    def waitforconnection(self):
        while True:
            Client, addr = self.sock.accept()
            conn = self._context.wrap_socket(Client, server_side=True)

            print('Connected to: '   addr[0]   ':'   str(addr[1]))
            print("SSL established. Peer: {}".format(conn.getpeercert()))
            start_new_thread(self.threaded_client, (conn, )) # Calling threaded_client() on a new thread
            self.ThreadCount  = 1
            print('Thread Number: '   str(self.ThreadCount))
        #self.sock.close()

server = Server()
server.connect()
server.waitforconnection()

客戶端代碼：

import socket
import struct # Here to convert Python data types into byte streams (in string) and back 
import sys
import ssl
import socket
import selectors
import types
import io
import os
import time
import requests
from pathlib import Path
import mysql.connector as mysql
from loguru import logger as log
from utils.misc import read_py_config
import json
import rsa
import base64

class Client:
    def __init__(self):
        self.host, self.port = "127.0.0.1", 65416
        self.client_cert = os.path.join(os.path.dirname(__file__), "client.crt")
        self.client_key = os.path.join(os.path.dirname(__file__), "client.key")
        self.server_crt = os.path.join(os.path.dirname(__file__), "server.crt")
        
        self.sni_hostname = "example.com"
        self._context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile=self.server_crt)

        self._context.load_cert_chain(certfile=self.client_cert, keyfile=self.client_key)

        self._sock = None
        self._ssock = None

    def checkvalidclient(self):
        # ---- Client Communication Setup ----

        HOST = self.host  # The server's hostname or IP address
        PORT = self.port        # The port used by the server

        try:
            self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

            self._ssock = self._context.wrap_socket(self._sock, server_side=False, server_hostname=self.sni_hostname)

            self._ssock.connect((HOST, PORT))

            print ("Socket successfully created")
        except socket.error as err:
            print ("socket creation failed with error %s" %(err))

        print('Waiting for connection')

        Response = self._ssock.recv(1024)
        if Response is not None:
            print(Response.decode('utf-8'))
        while True:
            Input = input('Say Something: ')
            send_msg(self._ssock, str.encode(Input))
            Response = recv_msg(self._ssock)
            if Response is not None:
                print(Response.decode('utf-8'))

    def closesockconnection(self):
        self._ssock.close()

# ---- To Avoid Message Boundary Problem on top of TCP protocol ----
def send_msg(sock: socket, msg):  # ---- Use this to send
    # Prefix each message with a 4-byte length (network byte order)
    msg = struct.pack('>I', len(msg))   msg
    sock.sendall(msg)

def recv_msg(sock: socket):       # ---- Use this to receive
    # Read message length and unpack it into an integer
    raw_msglen = recvall(sock, 4)
    if not raw_msglen:
        return None
    msglen = struct.unpack('>I', raw_msglen)[0]
    # Read the message data
    return recvall(sock, msglen)

def recvall(sock: socket, n: int):
    # Helper function to receive n bytes or return None if EOF is hit
    data = bytearray()
    while len(data) < n:
        packet = sock.recv(n - len(data))
        if not packet:
            return None
        data.extend(packet)
    return data

還要確保（根據鏈接）證書創建是正確的。

還有另一個有用的鏈接： Exploring HTTPS With Python

其中涵蓋了 HTTPS，特別是 Wireshark 部分允許您監控從客戶端到服務器的流量。完成上述操作并部署 Wireshark 后，我看到資料已加密。對證書的任何編輯（手動）都會導致應用程式失敗。

仍然需要添加嘗試，除非通信在中途停止等。但希望它會為其他人順利進行。

感謝評論者，幫助我找到了解決方案。

轉載請註明出處，本文鏈接：https://www.uj5u.com/gongcheng/531636.html

標籤：Python插座ssl

上一篇：帶有自簽名CA的Android上的Rocket.chat

下一篇：使用遞回檢查整數是回文而不使用任何額外的反向函式