Python 3.x 如何将tcp modbus与diffie hellman集成？

我有一个简单的modbus客户机服务器代码，还有一个diffie-hellman客户机服务器密钥交换。我的目标是将两者结合起来，以便当modbus客户端向modbus服务器发出请求时，第一步是进行密钥交换，然后加密从modbus客户端到服务器的数据传输，反之亦然

我知道在pythonsocketserver中，类

BaseRequestHandler

的

handle（）

方法被覆盖，用于客户端和服务器之间的通信，这是我为diffie-hellman密钥交换所做的

dh server.py

import socketserver

# request handler
class Dh_Handler(socketserver.BaseRequestHandler):

    # instantiate request handler, one per connection
    def __init__(self, request, client_addr, server):
        self.params = load_dh_params()  # store DH parameters
        self.state = 0  # tracking state
        socketserver.BaseRequestHandler.__init__(self, request, client_addr, server)    # pass variables to BaseRequestHandler

    # must override handle() to implement communication to client
    def handle(self):
        # calculate shared secret
        shared_key = dh_key_exchange()

        # key derivation used for symmetric encryption
        key = key_derivation(shared_key)

def main():
    host, port = '10.8.8.11', 502

    # instance of TCP server class, params: ip_address, request_handler
    dh_server = socketserver.TCPServer((host, port), Dh_Handler)

    # stop server via keyboard interrupt
    try:
        # infinite loop listen
        dh_server.serve_forever()
    except KeyboardInterrupt:
        dh_server.shutdown()

import socket

def main():
    # we specify the server's address or hostname and port
    host, port = '10.8.8.11', 502

    # create a tcp socket for IPv4
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # connect to the tcp socket
    sock.connect((host, port))

    # key exchange from server
    shared_key = dh_key_exchange(sock)

    # key derivation for symmetric encryption
    key = key_derivation(shared_key)

import socket

from umodbus import conf
from umodbus.client import tcp
import binascii

# Enable values to be signed (default is False).
conf.SIGNED_VALUES = True

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('10.8.8.11', 502))

# Returns a message or Application Data Unit (ADU) specific for doing
# Modbus TCP/IP.
message = tcp.write_multiple_coils(slave_id=1, starting_address=1, values=[1, 0, 1, 0])

# Response depends on Modbus function code. This particular returns the
# amount of coils written, in this case it is.

response = tcp.send_message(message, sock)

message = tcp.read_coils(slave_id=1, starting_address=1, quantity=4)
# message=b"".join([message,b'\x64'])
print(binascii.b2a_hex(message))
responce = tcp.send_message(message, sock)
print(responce)
sock.close()

import logging
from socketserver import TCPServer
from collections import defaultdict

from umodbus import conf
from umodbus.server.tcp import RequestHandler, get_server
from umodbus.utils import log_to_stream

# Add stream handler to logger 'uModbus'.
log_to_stream(level=logging.DEBUG)

# A very simple data store which maps addresses against their values.
data_store = defaultdict(int)

# Enable values to be signed (default is False).
conf.SIGNED_VALUES = True

TCPServer.allow_reuse_address = True
app = get_server(TCPServer, ('10.8.8.11', 502), RequestHandler)


@app.route(slave_ids=[1], function_codes=[1, 2], addresses=list(range(0, 10)))
def read_data_store(slave_id, function_code, address):
    """" Return value of address. """
    return data_store[address]


@app.route(slave_ids=[1], function_codes=[5, 15], addresses=list(range(0, 10)))
def write_data_store(slave_id, function_code, address, value):
    """" Set value for address. """
    data_store[address] = value


if __name__ == '__main__':
    try:
        app.serve_forever()
    finally:
        app.shutdown()
        app.server_close()

dh client.py

import socketserver

# request handler
class Dh_Handler(socketserver.BaseRequestHandler):

    # instantiate request handler, one per connection
    def __init__(self, request, client_addr, server):
        self.params = load_dh_params()  # store DH parameters
        self.state = 0  # tracking state
        socketserver.BaseRequestHandler.__init__(self, request, client_addr, server)    # pass variables to BaseRequestHandler

    # must override handle() to implement communication to client
    def handle(self):
        # calculate shared secret
        shared_key = dh_key_exchange()

        # key derivation used for symmetric encryption
        key = key_derivation(shared_key)

def main():
    host, port = '10.8.8.11', 502

    # instance of TCP server class, params: ip_address, request_handler
    dh_server = socketserver.TCPServer((host, port), Dh_Handler)

    # stop server via keyboard interrupt
    try:
        # infinite loop listen
        dh_server.serve_forever()
    except KeyboardInterrupt:
        dh_server.shutdown()

import socket

def main():
    # we specify the server's address or hostname and port
    host, port = '10.8.8.11', 502

    # create a tcp socket for IPv4
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # connect to the tcp socket
    sock.connect((host, port))

    # key exchange from server
    shared_key = dh_key_exchange(sock)

    # key derivation for symmetric encryption
    key = key_derivation(shared_key)

import socket

from umodbus import conf
from umodbus.client import tcp
import binascii

# Enable values to be signed (default is False).
conf.SIGNED_VALUES = True

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('10.8.8.11', 502))

# Returns a message or Application Data Unit (ADU) specific for doing
# Modbus TCP/IP.
message = tcp.write_multiple_coils(slave_id=1, starting_address=1, values=[1, 0, 1, 0])

# Response depends on Modbus function code. This particular returns the
# amount of coils written, in this case it is.

response = tcp.send_message(message, sock)

message = tcp.read_coils(slave_id=1, starting_address=1, quantity=4)
# message=b"".join([message,b'\x64'])
print(binascii.b2a_hex(message))
responce = tcp.send_message(message, sock)
print(responce)
sock.close()

import logging
from socketserver import TCPServer
from collections import defaultdict

from umodbus import conf
from umodbus.server.tcp import RequestHandler, get_server
from umodbus.utils import log_to_stream

# Add stream handler to logger 'uModbus'.
log_to_stream(level=logging.DEBUG)

# A very simple data store which maps addresses against their values.
data_store = defaultdict(int)

# Enable values to be signed (default is False).
conf.SIGNED_VALUES = True

TCPServer.allow_reuse_address = True
app = get_server(TCPServer, ('10.8.8.11', 502), RequestHandler)


@app.route(slave_ids=[1], function_codes=[1, 2], addresses=list(range(0, 10)))
def read_data_store(slave_id, function_code, address):
    """" Return value of address. """
    return data_store[address]


@app.route(slave_ids=[1], function_codes=[5, 15], addresses=list(range(0, 10)))
def write_data_store(slave_id, function_code, address, value):
    """" Set value for address. """
    data_store[address] = value


if __name__ == '__main__':
    try:
        app.serve_forever()
    finally:
        app.shutdown()
        app.server_close()

modbus客户端.py

import socketserver

# request handler
class Dh_Handler(socketserver.BaseRequestHandler):

    # instantiate request handler, one per connection
    def __init__(self, request, client_addr, server):
        self.params = load_dh_params()  # store DH parameters
        self.state = 0  # tracking state
        socketserver.BaseRequestHandler.__init__(self, request, client_addr, server)    # pass variables to BaseRequestHandler

    # must override handle() to implement communication to client
    def handle(self):
        # calculate shared secret
        shared_key = dh_key_exchange()

        # key derivation used for symmetric encryption
        key = key_derivation(shared_key)

def main():
    host, port = '10.8.8.11', 502

    # instance of TCP server class, params: ip_address, request_handler
    dh_server = socketserver.TCPServer((host, port), Dh_Handler)

    # stop server via keyboard interrupt
    try:
        # infinite loop listen
        dh_server.serve_forever()
    except KeyboardInterrupt:
        dh_server.shutdown()

import socket

def main():
    # we specify the server's address or hostname and port
    host, port = '10.8.8.11', 502

    # create a tcp socket for IPv4
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # connect to the tcp socket
    sock.connect((host, port))

    # key exchange from server
    shared_key = dh_key_exchange(sock)

    # key derivation for symmetric encryption
    key = key_derivation(shared_key)

import socket

from umodbus import conf
from umodbus.client import tcp
import binascii

# Enable values to be signed (default is False).
conf.SIGNED_VALUES = True

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('10.8.8.11', 502))

# Returns a message or Application Data Unit (ADU) specific for doing
# Modbus TCP/IP.
message = tcp.write_multiple_coils(slave_id=1, starting_address=1, values=[1, 0, 1, 0])

# Response depends on Modbus function code. This particular returns the
# amount of coils written, in this case it is.

response = tcp.send_message(message, sock)

message = tcp.read_coils(slave_id=1, starting_address=1, quantity=4)
# message=b"".join([message,b'\x64'])
print(binascii.b2a_hex(message))
responce = tcp.send_message(message, sock)
print(responce)
sock.close()

import logging
from socketserver import TCPServer
from collections import defaultdict

from umodbus import conf
from umodbus.server.tcp import RequestHandler, get_server
from umodbus.utils import log_to_stream

# Add stream handler to logger 'uModbus'.
log_to_stream(level=logging.DEBUG)

# A very simple data store which maps addresses against their values.
data_store = defaultdict(int)

# Enable values to be signed (default is False).
conf.SIGNED_VALUES = True

TCPServer.allow_reuse_address = True
app = get_server(TCPServer, ('10.8.8.11', 502), RequestHandler)


@app.route(slave_ids=[1], function_codes=[1, 2], addresses=list(range(0, 10)))
def read_data_store(slave_id, function_code, address):
    """" Return value of address. """
    return data_store[address]


@app.route(slave_ids=[1], function_codes=[5, 15], addresses=list(range(0, 10)))
def write_data_store(slave_id, function_code, address, value):
    """" Set value for address. """
    data_store[address] = value


if __name__ == '__main__':
    try:
        app.serve_forever()
    finally:
        app.shutdown()
        app.server_close()

modbus服务器.py

import socketserver

# request handler
class Dh_Handler(socketserver.BaseRequestHandler):

    # instantiate request handler, one per connection
    def __init__(self, request, client_addr, server):
        self.params = load_dh_params()  # store DH parameters
        self.state = 0  # tracking state
        socketserver.BaseRequestHandler.__init__(self, request, client_addr, server)    # pass variables to BaseRequestHandler

    # must override handle() to implement communication to client
    def handle(self):
        # calculate shared secret
        shared_key = dh_key_exchange()

        # key derivation used for symmetric encryption
        key = key_derivation(shared_key)

def main():
    host, port = '10.8.8.11', 502

    # instance of TCP server class, params: ip_address, request_handler
    dh_server = socketserver.TCPServer((host, port), Dh_Handler)

    # stop server via keyboard interrupt
    try:
        # infinite loop listen
        dh_server.serve_forever()
    except KeyboardInterrupt:
        dh_server.shutdown()

import socket

def main():
    # we specify the server's address or hostname and port
    host, port = '10.8.8.11', 502

    # create a tcp socket for IPv4
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # connect to the tcp socket
    sock.connect((host, port))

    # key exchange from server
    shared_key = dh_key_exchange(sock)

    # key derivation for symmetric encryption
    key = key_derivation(shared_key)

import socket

from umodbus import conf
from umodbus.client import tcp
import binascii

# Enable values to be signed (default is False).
conf.SIGNED_VALUES = True

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('10.8.8.11', 502))

# Returns a message or Application Data Unit (ADU) specific for doing
# Modbus TCP/IP.
message = tcp.write_multiple_coils(slave_id=1, starting_address=1, values=[1, 0, 1, 0])

# Response depends on Modbus function code. This particular returns the
# amount of coils written, in this case it is.

response = tcp.send_message(message, sock)

message = tcp.read_coils(slave_id=1, starting_address=1, quantity=4)
# message=b"".join([message,b'\x64'])
print(binascii.b2a_hex(message))
responce = tcp.send_message(message, sock)
print(responce)
sock.close()

import logging
from socketserver import TCPServer
from collections import defaultdict

from umodbus import conf
from umodbus.server.tcp import RequestHandler, get_server
from umodbus.utils import log_to_stream

# Add stream handler to logger 'uModbus'.
log_to_stream(level=logging.DEBUG)

# A very simple data store which maps addresses against their values.
data_store = defaultdict(int)

# Enable values to be signed (default is False).
conf.SIGNED_VALUES = True

TCPServer.allow_reuse_address = True
app = get_server(TCPServer, ('10.8.8.11', 502), RequestHandler)


@app.route(slave_ids=[1], function_codes=[1, 2], addresses=list(range(0, 10)))
def read_data_store(slave_id, function_code, address):
    """" Return value of address. """
    return data_store[address]


@app.route(slave_ids=[1], function_codes=[5, 15], addresses=list(range(0, 10)))
def write_data_store(slave_id, function_code, address, value):
    """" Set value for address. """
    data_store[address] = value


if __name__ == '__main__':
    try:
        app.serve_forever()
    finally:
        app.shutdown()
        app.server_close()

最好的方法是什么？我可以创建一个侦听两个不同端口的服务器吗？一个用于密钥交换，另一个用于加密modbus传输或在socketserver中使用线程。使用选择器处理每个连接怎么样

非常感谢您的帮助