def execute_route(self, meta_data, request_pdu):
""" Execute configured route based on requests meta data and request
PDU.
:param meta_data: A dict with meta data. It must at least contain
key 'unit_id'.
:param request_pdu: A bytearray containing request PDU.
:return: A bytearry containing reponse PDU.
"""
try:
function = create_function_from_request_pdu(request_pdu)
results =\
function.execute(meta_data['unit_id'], self.server.route_map)
try:
# ReadFunction's use results of callbacks to build response
# PDU...
return function.create_response_pdu(results)
except TypeError:
# ...other functions don't.
return function.create_response_pdu()
except ModbusError as e:
function_code = get_function_code_from_request_pdu(request_pdu)
return pack_exception_pdu(function_code, e.error_code)
except Exception as e:
log.exception('Could not handle request: {0}.'.format(e))
function_code = get_function_code_from_request_pdu(request_pdu)
return pack_exception_pdu(function_code,
ServerDeviceFailureError.error_code)
def execute_route(self, meta_data, request_pdu):
""" Execute configured route based on requests meta data and request
PDU.
:param meta_data: A dict with meta data. It must at least contain
key 'unit_id'.
:param request_pdu: A bytearray containing request PDU.
:return: A bytearry containing reponse PDU.
"""
try:
function = create_function_from_request_pdu(request_pdu)
results =\
function.execute(meta_data['unit_id'], self.route_map)
try:
# ReadFunction's use results of callbacks to build response
# PDU...
return function.create_response_pdu(results)
except TypeError:
# ...other functions don't.
return function.create_response_pdu()
except ModbusError as e:
function_code = get_function_code_from_request_pdu(request_pdu)
return pack_exception_pdu(function_code, e.error_code)
except Exception as e:
log.exception('Could not handle request: {0}.'.format(e))
function_code = get_function_code_from_request_pdu(request_pdu)
return pack_exception_pdu(function_code,
ServerDeviceFailureError.error_code)
def handle(self):
try:
request_adu = self.request.recv(1024)
response_adu = self.process(request_adu)
self.respond(response_adu)
except:
import traceback
log.exception('Error while handling request: {0}.'
.format(traceback.print_exc()))
raise
def handle(self):
try:
while True:
try:
mbap_header = recv_exactly(self.request.recv, 7)
remaining = self.get_meta_data(mbap_header)['length'] - 1
request_pdu = recv_exactly(self.request.recv, remaining)
except ValueError:
return
response_adu = self.process(mbap_header + request_pdu)
self.respond(response_adu)
except:
log.exception('Error while handling request')
raise
def handle(self):
try:
while True:
request_adu = self.request.recv(1024)
# When client terminates connection length of request_adu is 0.
if len(request_adu) == 0:
return
response_adu = self.process(request_adu)
self.respond(response_adu)
except:
import traceback
log.exception('Error while handling request: {0}.'
.format(traceback.print_exc()))
raise
def handle(self):
logging.debug("handle")
try:
while True:
try:
mbap_header = recv_exactly(self.request.recv, 7)
remaining = self.get_meta_data(mbap_header)['length'] - 1
request_pdu = recv_exactly(self.request.recv, remaining)
except ValueError:
return
response_adu = self.process(mbap_header + request_pdu)
self.respond(response_adu)
except:
import traceback
log.exception('Error while handling request: {0}.'.format(
traceback.print_exc()))
raise
def process(self, request_adu):
""" Process request ADU and return response.
:param request_adu: A bytearray containing the ADU request.
:return: A bytearray containing the response of the ADU request.
"""
log.debug('Lenght of received ADU is {0}.'.format(len(request_adu)))
log.info('<-- {0} - {1}.'.format(self.client_address[0],
hexlify(request_adu)))
try:
transaction_id, protocol_id, _, unit_id = \
unpack_mbap(request_adu[:7])
function = function_factory(request_adu[7:])
results = function.execute(unit_id, self.server.route_map)
try:
# ReadFunction's use results of callbacks to build response
# PDU...
response_pdu = function.create_response_pdu(results)
except TypeError:
# ...other functions don't.
response_pdu = function.create_response_pdu()
except ModbusError as e:
function_code = get_function_code_from_request_pdu(request_adu[7:])
response_pdu = pack_exception_pdu(function_code, e.error_code)
except Exception as e:
log.exception('Could not handle request: {0}.'.format(e))
function_code = get_function_code_from_request_pdu(request_adu[7:])
response_pdu = \
pack_exception_pdu(function_code,
ServerDeviceFailureError.error_code)
response_mbap = pack_mbap(transaction_id, protocol_id,
len(response_pdu) + 1, unit_id)
log.debug('Response MBAP {0}'.format(response_mbap))
log.debug('Response PDU {0}'.format(response_pdu))
response_adu = response_mbap + response_pdu
return response_adu
def handle(self):
try:
while True:
try:
message=self.request.recv(1024)
if not message: break
salt_key = b'6ea920bb0e8ad58ebf2dbf5634f14f26'
salt_iv = b'4893ed0de93bf86871845c06e2bef676'
def readfile ( file ) :
with open (file ,'rb') as f:
content = f.read ()
f.close()
return content
dh = readfile("umodbus/secrets/my_dh_file")
backend = default_backend()
hkdf_key = HKDF(
algorithm=hashes.SHA256(),
length=16,
salt=ba.unhexlify(salt_key),
info=b"keygen",
backend=backend)
hkdf_iv = HKDF(
algorithm=hashes.SHA256(),
length=16,
salt=ba.unhexlify(salt_iv),
info=b"ivgen",
backend=backend)
key = hkdf_key.derive(dh)
iv = hkdf_iv.derive(dh)
aes = algorithms.AES(key)
mode = modes.CBC(iv)
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
hash_received = message[(len(message)-32):len(message)]
message = message[0:(len(message)-32)]
decryptor = cipher.decryptor()
dec_msg = decryptor.update(message) + decryptor.finalize()
unpadder = padding.PKCS7(128).unpadder()
dec_msg = unpadder.update(dec_msg)
dt = dec_msg + unpadder.finalize()
dt = ba.unhexlify(dt)
h = hmac.HMAC(key, hashes.SHA256(), backend=backend)
h.update(dt)
hash_generated = h.finalize()
# print("hash rec:", hash_received)
# print("hash gen:", hash_generated)
if(hash_generated != hash_received):
print("hash mismatch! time to abort...")
break
else:
print("hash matched!")
#At this Point the message from the client has been received and is ready to be processed
mbap_header = dt[0:7]
remaining = self.get_meta_data(mbap_header)['length'] - 1
request_pdu = dt[7:8+remaining]
except ValueError:
return
response_adu = self.process(mbap_header + request_pdu)
#At this point the responce to the message has been structured and is ready to be send to the client
self.respond(response_adu)
except:
import traceback
log.exception('Error while handling request: {0}.'
.format(traceback.print_exc()))
raise
def handle(self):
try:
helloMsgServer = 'server'
helloMsgClient = 'client'
serverkey = RSA.generate(2048)
serverpbkey = serverkey.publickey().exportKey('PEM').decode(
'ascii')
serverprkey = serverkey.exportKey('PEM').decode('ascii')
print('\nServer Public keys:\n\n', serverpbkey,
'\n\n\nRSA server private key:\n\n', serverprkey)
sign = signData(helloMsgServer.encode(), serverprkey)
print("\n\nSign:\n\n", sign)
message = str(serverpbkey) + ";" + str(sign)
print("\n\nRSA Message:\n\n", message)
self.request.sendall(message.encode())
rsaResponse = self.request.recv(3072).strip()
rsaMsg = rsaResponse.decode()
clientpbkey = rsaMsg.split(';')[0]
signRcvd = rsaMsg.split(';')[1]
verify = verifySign(helloMsgClient.encode(), clientpbkey, signRcvd)
if verify:
print("\n\n---------Received Client RSA Public Key---------\n")
else:
raise Exception(
"\nClient Authentication Failure. RSA public key and sign don't match\n"
)
print('\nRSA client pub key\n\n', clientpbkey)
print(
"\n\n****************************RSA Exchange Completes and Authentication Done***************************"
)
#self.state = 0
dh_params = load_dh_params()
srkey = generate_dh_prvkey(dh_params)
response = dh_params.parameter_bytes(Encoding.PEM,
ParameterFormat.PKCS3)
self.request.sendall(response)
self.data = self.request.recv(3072).strip()
print(
"\n\n****************************Received Client's public Key****************************\n"
)
if bytearray(self.data)[0:18] == b'Client public key:':
# now we convert the binary message to bytearray so we can choose the public key
# part of it and use key serialization method to turn it into an object
client_pubkey = load_pem_public_key(
bytes(bytearray(self.data)[18:]), default_backend())
# now if the public key is loaded (we might not get to this point otherwise,
# something for you to check!)
if client_pubkey:
# client key is valid so we generate our own from the parameters
server_keypair = srkey
# we will send the public key to the client and we need to convert it to
# binary to send over the network
response = b'Server public key:' + server_keypair.public_key(
).public_bytes(Encoding.PEM,
PublicFormat.SubjectPublicKeyInfo)
session_key = server_keypair.exchange(client_pubkey)
#self.state = 0
self.request.sendall(response)
print(
"\n****************************Shared Secret key is generated***************************\n"
)
print(
"\n**********************DH Exchange Completes and Session Established**********************"
)
else:
# if we get here the client key is not right
response = b'Invalid client public key, hanging up'
self.request.sendall(response)
return
iv = 'nvXIK5RtUZpZQdJD'
while True:
try:
message = self.request.recv(1024)
if not message:
break
#print('\niv',iv)
self.iv = iv
print('\nCipher + Hash:\t\t-------->\t', (message))
obtained_key = hkdf_function(session_key)
self.obtained_key = obtained_key
plain, digest = aes_decrypt(message, obtained_key, iv)
print('\nDerived key:\t\t-------->\t', (obtained_key))
localDigest = getHash(plain)
verify = verifyHash(digest, localDigest)
if verify == False:
break
print("\nHash is verified.")
mbap_header = plain[0:7]
remaining = self.get_meta_data(mbap_header)['length'] - 1
request_pdu = plain[7:8 + remaining]
except ValueError:
print("issue")
return
response_adu = self.process(mbap_header + request_pdu)
print("\nResponse ADU:\t\t-------->\t", (response_adu))
#At this point the responce to the message has been structured and is ready to be send to the client
self.respond(response_adu)
except:
import traceback
log.exception('Error while handling request: {0}.'.format(
traceback.print_exc()))
raise
