def check_isotp_socket_possible():
try:
Vars.SOCKET_IMPOSSIBLE_REASON = ''
import isotp
import can
s = isotp.socket()
s.bind(get_test_interface_config("channel"), rxid=1, txid=2)
s.close()
try:
s = isotp.socket()
s.set_ll_opts(mtu=isotp.tpsock.LinkLayerProtocol.CAN_FD)
s.bind(get_test_interface_config("channel"), rxid=1, txid=2)
s.close()
Vars.CAN_FD_POSSIBLE = True
except:
Vars.CAN_FD_POSSIBLE = False
Vars.CAN_FD_IMPOSSIBLE_REASON = 'Interface %s does not support MTU of %d.' % (
get_test_interface_config("channel"),
isotp.tpsock.LinkLayerProtocol.CAN_FD)
Vars.ISOTP_SOCKET_POSSIBLE = True
except Exception as e:
Vars.SOCKET_IMPOSSIBLE_REASON = str(e)
Vars.ISOTP_SOCKET_POSSIBLE = False
Vars.ISOTP_STATUS_CHECKED = True
return Vars.ISOTP_SOCKET_POSSIBLE
def __init__(self,
interface,
rxid,
txid,
name=None,
tpsock=None,
*args,
**kwargs):
BaseConnection.__init__(self, name)
self.interface = interface
self.rxid = rxid
self.txid = txid
self.rxqueue = queue.Queue()
self.exit_requested = False
self.opened = False
self.tpsock_bind_args = args
self.tpsock_bind_kwargs = kwargs
if tpsock is None:
if 'isotp' not in sys.modules:
if _import_isotp_err is None:
raise ImportError('isotp module is not loaded')
else:
raise _import_isotp_err
self.tpsock = isotp.socket(timeout=0.1)
else:
self.tpsock = tpsock
def bind(self):
if (not test_mode):
self.socket = isotp.socket()
self.socket.set_opts(0x480, frame_txtime=0) # 0x400 NOFLOW_MODE, 0x80 FORCESTMIN
self.socket.bind("can0", isotp.Address(isotp.AddressingMode.Normal_29bits, rxid=self.rxid, txid=self.txid))
return True
def _isotp_flush_obj(self):
'''
刷新CAN对象，更新CAN对象参数
'''
self.isotp_sock_can_bus.close()
self.isotp_sock_can_bus = isotp.socket()
self.isotp_sock_can_bus.set_fc_opts(stmin=5, bs=10)
self.isotp_sock_can_bus.bind(self.channel,
rxid=self.isotp_rxid,
txid=self.isotp_txid)
def make_socket(self, tx_data_length=8, can_fd=False, *args, **kwargs):
mtu = isotp.tpsock.LinkLayerProtocol.CAN_FD if can_fd else isotp.tpsock.LinkLayerProtocol.CAN
if mtu == isotp.tpsock.LinkLayerProtocol.CAN:
assert tx_data_length == 8, "CAN bus only supports 8-bytes payloads"
s = isotp.socket(*args, **kwargs)
s.set_ll_opts(mtu=mtu, tx_dl=tx_data_length)
self.socket_list.append(s)
return s
def _get_socket(self):
import isotp
address = isotp.Address(0, rxid=self.response_id, txid=self.physical_id)
isotp_socket = isotp.socket(timeout=self.can_scan_timeout)
isotp_socket.set_opts(txpad=self.padding_byte, rxpad=self.padding_byte)
isotp_socket.bind(self.socketcan_interface, address)
return isotp_socket
def __init__(self, interface, rxid, txid, name=None, tpsock=None):
import isotp
BaseConnection.__init__(self, name)
self.interface = interface
self.rxid = rxid
self.txid = txid
self.rxqueue = queue.Queue()
self.exit_requested = False
self.opened = False
self.rxthread = threading.Thread(target=self.rxthread_task)
self.tpsock = isotp.socket(timeout=0.1) if tpsock is None else tpsock
def check_isotp_socket_possible():
try:
Vars.SOCKET_IMPOSSIBLE_REASON = ''
import isotp
import can
s = isotp.socket()
s.bind(Vars.interface_name, rxid=1, txid=2)
s.close()
Vars.ISOTP_SOCKET_POSSIBLE = True
except Exception as e:
Vars.SOCKET_IMPOSSIBLE_REASON = str(e)
Vars.ISOTP_SOCKET_POSSIBLE = False
return Vars.ISOTP_SOCKET_POSSIBLE
def __init__(self):
'''
参数初始化
'''
self.rsp_data = None
self.baudrate = 500000
self.channel = 'can1'
#self.timeout = 0.01
self.shd_recv_data = ''
self.isotp_txid = 0x720
self.isotp_rxid = 0x728
self.isotp_sock_can_bus = isotp.socket()
self.isotp_sock_can_bus.set_fc_opts(stmin=5, bs=10)
self.isotp_sock_can_bus.bind(self.channel,
rxid=self.isotp_rxid,
txid=self.isotp_txid)
#!/usr/bin/python3
import time
import isotp
import udsoncan
from udsoncan.connections import IsoTPSocketConnection
from udsoncan.client import Client
from udsoncan.exceptions import *
from udsoncan.services import *
from udsoncan import Request, Response
import random, datetime
#udsoncan.setup_logging()
isotp_socket = isotp.socket()
isotp_socket.set_opts(txpad=8, rxpad=8)
class CrackSecurityAccess():
client = None
ACCESS_LEVEL = 1
def __init__(self, client=None, timeout=1):
if conn:
self.client = client
self.timeout = timeout
def start(self):
if self.client is None:
from test.UdsTest import UdsTest from udsoncan.connections import * from test.stub import StubbedIsoTPSocket import socket import threading import time import unittest try: _STACK_UNVAILABLE_REASON = '' _interface_name = 'vcan0' import isotp import can s = isotp.socket() s.bind(_interface_name,1,2) s.close() _STACK_POSSIBLE = True except Exception as e: _STACK_UNVAILABLE_REASON = str(e) _STACK_POSSIBLE = False class TestIsoTPSocketConnection(UdsTest): def setUp(self): self.tpsock1 = StubbedIsoTPSocket(timeout=0.1) self.tpsock2 = StubbedIsoTPSocket(timeout=0.1) def test_open(self): conn = IsoTPSocketConnection(interface='vcan0', rxid=0x001, txid=0x002, tpsock=self.tpsock1, name='unittest') self.assertFalse(conn.is_open()) conn.open()
def scan_for_services(diagnostic_tx_arb_id,
diagnostic_rx_arb_id,
start_service_id,
end_service_id,
can_socket='can0',
skip_response_only_service_ids=True,
add_extra_payload_byte=True,
payload_extra_byte=b'\x00'):
# print("Starting Services Scan on {:03X}<==>{:03X} ...".format(diagnostic_tx_arb_id, diagnostic_rx_arb_id))
tx_id, rx_id = [diagnostic_tx_arb_id, diagnostic_rx_arb_id]
isotp_socket = isotp.socket(0.1)
isotp_socket.set_opts(txpad=0x00, rxpad=0x00)
address = isotp.Address(0, rxid=rx_id, txid=tx_id)
isotp_socket.bind(can_socket, address)
end_service_id = end_service_id & 0xFF
start_service_id = start_service_id & 0xFF
if end_service_id > start_service_id:
increment_direction = 1
else:
increment_direction = -1
non_supported_services_set = set([])
supported_services_set = set([])
for service_id in range(start_service_id, end_service_id,
increment_direction):
if skip_response_only_service_ids and (0x3E < service_id < 0x4F
or 0x7E < service_id < 0x83
or 0xBE < service_id < 0xFF):
continue
else:
payload = service_id
if payload >= 0x10:
l_payload = (len(hex(payload)) - 2) >> 1
else:
l_payload = 1
b_payload = payload.to_bytes(l_payload, 'big')
isotp_socket.send(b_payload + (
payload_extra_byte if add_extra_payload_byte else b''))
while True:
recv = isotp_socket.recv()
if recv is not None:
response_service_id = recv[0]
if (response_service_id == 0x7F and recv[2] == 0x7F) or (
response_service_id == 0x7F and recv[2] == 0x80):
isotp_socket.send(b'\x10\x03')
supported_services_set.add(service_id)
elif response_service_id == service_id + 0x40 or (
response_service_id == 0x7F and recv[2] != 0x11):
supported_services_set.add(service_id)
else:
non_supported_services_set.add(service_id)
else:
break
return supported_services_set
"can_mask": 0x7ff,
"extended": False
},
])
################################################################
################################################################
#initialize CAN ISOTP
################################################################
#CAN ISOTP is a higher level protocol used to transfer larger amounts of data than the base CAN allows
#this creates its own separate socket to the CAN bus on the same single wire can interface from the
#other standard can messaging that occurs in this script
SWCAN_ISOTP = isotp.socket() #default recv timeout is 0.1 seconds
#SWCAN_ISOTP.set_fc_opts(stmin=5, bs=10) #see https://can-isotp.readthedocs.io/en/latest/isotp/socket.html#socket.set_fc_opts
SWCAN_ISOTP.set_fc_opts(stmin=25, bs=10)
SWCAN_ISOTP.bind(
SWCANname, isotp.Address(rxid=1996, txid=1997)
) #note: rxid of wall is txid of car, and txid of wall is rxid of the car
################################################################
################################################################
GUI.start() #starts .run() (and maybe some other stuff?)
################################################################
TWCManager.MainThread.start()
import isotp
from Crypto.Cipher import DES3
s = isotp.socket(timeout=10)
s2 = isotp.socket(timeout=10)
# Configuring the sockets.
s.set_fc_opts(stmin=5, bs=10)
#s.set_general_opts(...)
#s.set_ll_opts(...)
key = "sixteen byte key"
print("The Triple DES key value :", key)
cipher = DES3.new(key, DES3.MODE_ECB)
try:
while True:
s.bind("can1", isotp.Address(rxid=0x123, txid=0x45))
s2.bind("can1", isotp.Address(rxid=0x45, txid=0x123))
#print(s.recv())
decrypted = cipher.decrypt(s.recv())
print(decrypted)
except KeyboardInterrupt:
print('\n\rKeyboard interrtupt')
def find_services(
self,
skip_response_only_service_ids=False,
scan_only_known_uds_services=True,
payload_extra_byte=b'\x00',
add_extra_payload_byte=False,
):
list_of_known_uds_services = [
0x10, 0x11, 0x27, 0x28, 0x3E, 0x83, 0x84, 0x85, 0x86, 0x87, 0x22,
0x23, 0x24, 0x2A, 0x2C, 0x2E, 0x3D, 0x14, 0x19, 0x2F, 0x34, 0x35,
0x36, 0x37
]
if self._diagnostic_services_scan_complete:
return self.diagnostic_services
import isotp
import time
isotp_socket = isotp.socket()
isotp_socket.set_opts(txpad=0x00, rxpad=0x00)
address = isotp.Address(0,
rxid=self.response_id,
txid=self.physical_request_id)
isotp_socket.bind(self.socket_can_interface, address)
if not (0 <= self.start_service_id <= 0xFF):
self.start_service_id = 0
if not (0 <= self.end_service_id <= 0xFF):
self.end_service_id = 0xFF
self.end_service_id = self.end_service_id & 0xFF
self.start_service_id = self.start_service_id & 0xFF
if self.end_service_id > self.start_service_id:
increment_direction = 1
else:
increment_direction = -1
for service_id in range(self.start_service_id, self.end_service_id,
increment_direction):
if skip_response_only_service_ids and (
0x3E < service_id < 0x4F or 0x7E < service_id < 0x83
or 0xBE < service_id < 0xFF):
continue
if scan_only_known_uds_services and not (
service_id in list_of_known_uds_services):
continue
payload = service_id
# fix to correct for the payload length
if payload >= 0x10:
payload_length = (len(hex(payload)) - 2) >> 1
else:
payload_length = 1
payload_bytes = payload.to_bytes(payload_length, 'big')
if add_extra_payload_byte:
payload_bytes += b'\x00'
# Some services only work with Extra Data
isotp_socket.send(payload_bytes + payload_extra_byte)
recv = isotp_socket.recv()
current_time = time.time()
while recv is None:
loop_time = time.time()
recv = isotp_socket.recv()
if current_time + self.can_scan_timeout < loop_time:
break
if recv is not None:
response_service_id = recv[0]
if response_service_id == 0x7F:
nrc = recv[2]
'''if nrc == 0x7F or nrc == 0x80:
isotp_socket.send(b'\x10' + self.enhanced_mode_session_byte)
recv = isotp_socket.recv()
time.sleep(0.1)
isotp_socket.send(b_payload + (payload_extra_byte if add_extra_payload_byte else b''))
continue'''
if nrc == 0x11:
self.unsupported_service.add(service_id)
else:
self.supported_services.add(service_id)
else:
self.supported_services.add(service_id)
self.diagnostic_services = self.supported_services
self._diagnostic_services_scan_complete = True
return self.supported_services
import isotp
s = isotp.socket()
s2 = isotp.socket()
s.set_fc_opts(stmin=5, bs=10)
text = b'The module allows to send big chunks of data by establishing a point to point connection and sending large chunk data'
s.bind("can0", isotp.Address(rxid=0x789, txid=0x56))
s2.bind("can0", isotp.Address(rxid=0x56, txid=0x789))
s2.send(text)
print("The message transmitted using CAN-ISOTP module is :", s.recv())
def create_isotp_socket(receiver_address, target_address):
socket = isotp.socket()
socket.bind(CAN_INTERFACE,
isotp.Address(rxid=receiver_address, txid=target_address))
return socket
def create_socket(rxid, txid):
socket = isotp.socket()
socket.set_opts(socket.flags.LISTEN_MODE)
socket.bind(CAN_INTERFACE, isotp.Address(rxid=rxid, txid=txid))
return socket
def make_socket(self, *args, **kwargs):
s = isotp.socket(*args, **kwargs)
self.socket_list.append(s)
return s
from udsoncan.connections import IsoTPSocketConnection
from udsoncan.client import Client
from udsoncan.exceptions import *
from udsoncan.services import *
from udsoncan import Request, Response
import random, datetime
#udsoncan.setup_logging()
aqua_patch.PatchMessageFormat()
if __name__ == '__main__':
isotp_socket = isotp.socket()
isotp_socket.set_opts(txpad=CarConfig.TXPADSIZE, rxpad=CarConfig.RXPADSIZE)
conn = IsoTPSocketConnection('can0', rxid=CarConfig.RXID, txid=CarConfig.TXID, tpsock=isotp_socket)
with Client(conn, request_timeout=2, config=CarConfig.car_client_config) as client:
try:
client.change_session(DiagnosticSessionControl.Session.defaultSession)
client.unlock_security_access(CarConfig.SECURITY_LEVEL)
# suppress error
for i in range(0,3):
conn.send(b'\x0a\x27')
time.sleep(0.5)
client.change_session(DiagnosticSessionControl.Session.programmingSession)
import isotp
import time
import os
import codecs
print('\n\rCAN ISO-TP test')
print('Bring up CAN1....')
#os.system("sudo /sbin/ip link set can1 up type can bitrate 500000")
time.sleep(0.1)
s = isotp.socket()
s2 = isotp.socket()
s.set_fc_opts(stmin=5, bs=10)
s3 = isotp.socket()
s4 = isotp.socket()
s3.set_fc_opts(stmin=5, bs=10)
s5 = isotp.socket()
s6 = isotp.socket()
s6.set_fc_opts(stmin=5, bs=10)
print('Ready')
#time1 = []
count = 0
try:
while True:
count += 1
s.bind("can1", isotp.Address(rxid=0x123, txid=0x45))
s2.bind("can1", isotp.Address(rxid=0x45, txid=0x123))
if s.recv() == b'start':
