def _load(module, globals_dict=None, symb_list=None):
"""Loads a Python module to make variables, objects and functions
available globally.
The idea is to load the module using importlib, then copy the
symbols to the global symbol table.
"""
if globals_dict is None:
globals_dict = six.moves.builtins.__dict__
try:
mod = importlib.import_module(module)
if '__all__' in mod.__dict__:
# import listed symbols
for name in mod.__dict__['__all__']:
if symb_list is not None:
symb_list.append(name)
globals_dict[name] = mod.__dict__[name]
else:
# only import non-private symbols
for name, sym in six.iteritems(mod.__dict__):
if _validate_local(name):
if symb_list is not None:
symb_list.append(name)
globals_dict[name] = sym
except Exception:
log_interactive.error("Loading module %s", module, exc_info=True)
def _load(module, globals_dict=None, symb_list=None):
"""Loads a Python module to make variables, objects and functions
available globally.
The idea is to load the module using importlib, then copy the
symbols to the global symbol table.
"""
if globals_dict is None:
globals_dict = six.moves.builtins.__dict__
try:
mod = importlib.import_module(module)
if '__all__' in mod.__dict__:
# import listed symbols
for name in mod.__dict__['__all__']:
if symb_list is not None:
symb_list.append(name)
globals_dict[name] = mod.__dict__[name]
else:
# only import non-private symbols
for name, sym in six.iteritems(mod.__dict__):
if _validate_local(name):
if symb_list is not None:
symb_list.append(name)
globals_dict[name] = sym
except Exception:
log_interactive.error("Loading module %s", module, exc_info=True)
def enter_state(self, prev_state, next_state):
# type: (EcuState, EcuState) -> bool
"""
Obtains a transition function from the system state graph and executes
it. On success, the cleanup function is added for a later cleanup of
the new state.
:param prev_state: Current state
:param next_state: Desired state
:return: True, if state could be changed successful
"""
edge = (prev_state, next_state)
funcs = self.state_graph.get_transition_tuple_for_edge(edge)
if funcs is None:
log_interactive.error("[!] No transition function for %s", edge)
return False
trans_func, trans_kwargs, clean_func = funcs
state_changed = trans_func(self.socket, self.configuration,
trans_kwargs)
if state_changed:
self.target_state = next_state
if clean_func is not None:
self.cleanup_functions += [clean_func]
return True
else:
log_interactive.info("[-] Transition for edge %s failed", edge)
return False
def send(self, x):
# type: (Union[Packet, bytes]) -> int
if isinstance(x, UDS):
pkt = DoIP(payload_type=0x8001,
source_address=self.source_address,
target_address=self.target_address) / x
else:
pkt = x
try:
x.sent_time = time.time() # type: ignore
except AttributeError:
pass
try:
return super(UDS_DoIPSocket, self).send(pkt)
except Exception as e:
# Workaround:
# This catch block is currently necessary to detect errors
# during send. In automotive application it's not uncommon that
# a destination socket goes down. If any function based on
# SndRcvHandler is used, all exceptions are silently handled
# in the send part. This means, a caller of the SndRcvHandler
# can not detect if an error occurred. This workaround closes
# the socket if a send error was detected.
log_interactive.error("Exception: %s", e)
self.close()
return 0
def sendpfast(x, pps=None, mbps=None, realtime=None, loop=0, file_cache=False, iface=None):
"""Send packets at layer 2 using tcpreplay for performance
pps: packets per second
mpbs: MBits per second
realtime: use packet's timestamp, bending time with realtime value
loop: number of times to process the packet list
file_cache: cache packets in RAM instead of reading from disk at each iteration
iface: output interface """
if iface is None:
iface = conf.iface
argv = [conf.prog.tcpreplay, "--intf1=%s" % iface ]
if pps is not None:
argv.append("--pps=%i" % pps)
elif mbps is not None:
argv.append("--mbps=%f" % mbps)
elif realtime is not None:
argv.append("--multiplier=%f" % realtime)
else:
argv.append("--topspeed")
if loop:
argv.append("--loop=%i" % loop)
if file_cache:
argv.append("--enable-file-cache")
f = get_temp_file()
argv.append(f)
wrpcap(f, x)
try:
subprocess.check_call(argv)
except KeyboardInterrupt:
log_interactive.info("Interrupted by user")
except Exception,e:
log_interactive.error("while trying to exec [%s]: %s" % (argv[0],e))
def scan(self, timeout=None):
# type: (Optional[int]) -> None
"""
Executes all testcases for a given time.
:param timeout: Time for execution.
:return: None
"""
kill_time = time.time() + (timeout or 0xffffffff)
while kill_time > time.time():
test_case_executed = False
log_interactive.debug("[i] Scan paths %s", self.state_paths)
for p, test_case in product(self.state_paths,
self.configuration.test_cases):
log_interactive.info("[i] Scan path %s", p)
terminate = kill_time < time.time()
if terminate:
log_interactive.debug(
"[-] Execution time exceeded. Terminating scan!")
break
final_state = p[-1]
if test_case.has_completed(final_state):
log_interactive.debug("[+] State %s for %s completed",
repr(final_state), test_case)
continue
try:
if not self.enter_state_path(p):
log_interactive.error("[-] Error entering path %s", p)
continue
log_interactive.info("[i] Execute %s for path %s",
str(test_case), p)
self.execute_test_case(test_case)
test_case_executed = True
except (OSError, ValueError, Scapy_Exception) as e:
log_interactive.critical("[-] Exception: %s", e)
if self.configuration.debug:
raise e
if isinstance(e, OSError):
log_interactive.critical(
"[-] OSError occurred, closing socket")
self.socket.close()
if cast(SuperSocket, self.socket).closed and \
self.reconnect_handler is None:
log_interactive.critical(
"Socket went down. Need to leave scan")
raise e
finally:
self.cleanup_state()
if not test_case_executed:
log_interactive.info(
"[i] Execute failure or scan completed. Exit scan!")
break
self.cleanup_state()
self.reset_target()
def sendpfast(x, pps=None, mbps=None, realtime=None, loop=0, file_cache=False, iface=None, replay_args=None, # noqa: E501
parse_results=False):
"""Send packets at layer 2 using tcpreplay for performance
pps: packets per second
mpbs: MBits per second
realtime: use packet's timestamp, bending time with real-time value
loop: number of times to process the packet list
file_cache: cache packets in RAM instead of reading from disk at each iteration # noqa: E501
iface: output interface
replay_args: List of additional tcpreplay args (List[str])
parse_results: Return a dictionary of information outputted by tcpreplay (default=False) # noqa: E501
:returns stdout, stderr, command used"""
if iface is None:
iface = conf.iface
argv = [conf.prog.tcpreplay, "--intf1=%s" % iface]
if pps is not None:
argv.append("--pps=%i" % pps)
elif mbps is not None:
argv.append("--mbps=%f" % mbps)
elif realtime is not None:
argv.append("--multiplier=%f" % realtime)
else:
argv.append("--topspeed")
if loop:
argv.append("--loop=%i" % loop)
if file_cache:
argv.append("--preload-pcap")
# Check for any additional args we didn't cover.
if replay_args is not None:
argv.extend(replay_args)
f = get_temp_file()
argv.append(f)
wrpcap(f, x)
results = None
try:
log_runtime.info(argv)
with subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as cmd: # noqa: E501
stdout, stderr = cmd.communicate()
log_runtime.info(stdout)
log_runtime.warning(stderr)
if parse_results:
results = _parse_tcpreplay_result(stdout, stderr, argv)
except KeyboardInterrupt:
log_interactive.info("Interrupted by user")
except Exception:
if conf.interactive:
log_interactive.error("Cannot execute [%s]", argv[0], exc_info=True) # noqa: E501
else:
raise
finally:
os.unlink(f)
return results
def save_session(fname="", session=None, pickleProto=-1):
# type: (str, Optional[Dict[str, Any]], int) -> None
"""Save current Scapy session to the file specified in the fname arg.
params:
- fname: file to save the scapy session in
- session: scapy session to use. If None, the console one will be used
- pickleProto: pickle proto version (default: -1 = latest)"""
from scapy import utils
from scapy.config import conf, ConfClass
if not fname:
fname = conf.session
if not fname:
conf.session = fname = utils.get_temp_file(keep=True)
log_interactive.info("Saving session into [%s]", fname)
if not session:
try:
from IPython import get_ipython
session = get_ipython().user_ns
except Exception:
session = six.moves.builtins.__dict__["scapy_session"]
if not session:
log_interactive.error("No session found ?!")
return
ignore = session.get("_scpybuiltins", [])
hard_ignore = ["scapy_session", "In", "Out"]
to_be_saved = session.copy()
for k in list(to_be_saved):
i = to_be_saved[k]
if k[0] == "_":
del(to_be_saved[k])
elif hasattr(i, "__module__") and i.__module__.startswith("IPython"):
del(to_be_saved[k])
elif isinstance(i, ConfClass):
del(to_be_saved[k])
elif k in ignore or k in hard_ignore:
del(to_be_saved[k])
elif isinstance(i, (type, types.ModuleType)):
if k[0] != "_":
log_interactive.warning("[%s] (%s) can't be saved.", k,
type(to_be_saved[k]))
del(to_be_saved[k])
try:
os.rename(fname, fname + ".bak")
except OSError:
pass
f = gzip.open(fname, "wb")
six.moves.cPickle.dump(to_be_saved, f, pickleProto)
f.close()
def save_session(fname=None, session=None, pickleProto=-1):
"""Save current Scapy session to the file specified in the fname arg.
params:
- fname: file to save the scapy session in
- session: scapy session to use. If None, the console one will be used
- pickleProto: pickle proto version (default: -1 = latest)"""
from scapy import utils
from scapy.config import conf, ConfClass
if fname is None:
fname = conf.session
if not fname:
conf.session = fname = utils.get_temp_file(keep=True)
log_interactive.info("Use [%s] as session file" % fname)
if session is None:
try:
session = get_ipython().user_ns
except Exception:
session = six.moves.builtins.__dict__["scapy_session"]
to_be_saved = session.copy()
if "__builtins__" in to_be_saved:
del (to_be_saved["__builtins__"])
for k in list(to_be_saved):
i = to_be_saved[k]
if hasattr(i, "__module__") and (
k[0] == "_"
or i.__module__.startswith("IPython")): # noqa: E501
del (to_be_saved[k])
if isinstance(i, ConfClass):
del (to_be_saved[k])
elif isinstance(i, (type, type, types.ModuleType)):
if k[0] != "_":
log_interactive.error("[%s] (%s) can't be saved.", k,
type(to_be_saved[k])) # noqa: E501
del (to_be_saved[k])
try:
os.rename(fname, fname + ".bak")
except OSError:
pass
f = gzip.open(fname, "wb")
six.moves.cPickle.dump(to_be_saved, f, pickleProto)
f.close()
del f
def save_session(fname=None, session=None, pickleProto=-1):
"""Save current Scapy session to the file specified in the fname arg.
params:
- fname: file to save the scapy session in
- session: scapy session to use. If None, the console one will be used
- pickleProto: pickle proto version (default: -1 = latest)"""
from scapy import utils
if fname is None:
fname = conf.session
if not fname:
conf.session = fname = utils.get_temp_file(keep=True)
log_interactive.info("Use [%s] as session file" % fname)
if session is None:
try:
session = get_ipython().user_ns
except:
session = six.moves.builtins.__dict__["scapy_session"]
to_be_saved = session.copy()
if "__builtins__" in to_be_saved:
del(to_be_saved["__builtins__"])
for k in list(to_be_saved):
i = to_be_saved[k]
if hasattr(i, "__module__") and (k[0] == "_" or i.__module__.startswith("IPython")):
del(to_be_saved[k])
if isinstance(i, ConfClass):
del(to_be_saved[k])
elif isinstance(i, (type, type, types.ModuleType)):
if k[0] != "_":
log_interactive.error("[%s] (%s) can't be saved.", k, type(to_be_saved[k]))
del(to_be_saved[k])
try:
os.rename(fname, fname+".bak")
except OSError:
pass
f=gzip.open(fname,"wb")
six.moves.cPickle.dump(to_be_saved, f, pickleProto)
f.close()
del f
def scan(self):
scan_complete = False
while not scan_complete:
scan_complete = True
log_interactive.info("[i] Scan paths %s", self.get_state_paths())
for p in self.get_state_paths():
log_interactive.info("[i] Scan path %s", p)
final_state = p[-1]
for e in self.enumerators:
if e.state_completed[final_state]:
log_interactive.debug("[+] State %s for %s completed",
repr(final_state), e)
continue
if not self.enter_state_path(p):
log_interactive.error("[-] Error entering path %s", p)
continue
log_interactive.info("[i] EXECUTE SCAN %s for path %s",
e.__class__.__name__, p)
self.execute_enumerator(e)
scan_complete = False
self.reset_target()
def send(self, x):
# type: (Packet) -> int
try:
x.sent_time = time.time()
except AttributeError:
pass
try:
return super(UDS_HSFZSocket, self).send(
HSFZ(src=self.src, dst=self.dst) / x)
except Exception as e:
# Workaround:
# This catch block is currently necessary to detect errors
# during send. In automotive application it's not uncommon that
# a destination socket goes down. If any function based on
# SndRcvHandler is used, all exceptions are silently handled
# in the send part. This means, a caller of the SndRcvHandler
# can not detect if an error occurred. This workaround closes
# the socket if a send error was detected.
log_interactive.error("Exception: %s", e)
self.close()
return 0
def _activate_routing(
self,
source_address, # type: int
target_address, # type: int
activation_type, # type: int
reserved_oem=b"" # type: bytes
): # type: (...) -> None
resp = self.sr1(DoIP(payload_type=0x5,
activation_type=activation_type,
source_address=source_address,
reserved_oem=reserved_oem),
verbose=False,
timeout=1)
if resp and resp.payload_type == 0x6 and \
resp.routing_activation_response == 0x10:
self.target_address = target_address or \
resp.logical_address_doip_entity
log_interactive.info(
"Routing activation successful! Target address set to: 0x%x",
self.target_address)
else:
log_interactive.error("Routing activation failed! Response: %s",
repr(resp))
def __init__(self, *args, **kargs):
log_interactive.error(self.name)
def __init__(self, *args, **kargs):
log_interactive.error(self.name)
