def __init__(self,
prelooping_delay=1,
engine=None,
driver=None,
dstats=True,
fp_sil=False):
Thread.__init__(self, verbose=debug_threads)
self.engine = engine
self.maindone = 1
self.setDaemon(
True) #don't wait for this thread to quit when we exit XXX
self.prelooping_delay = prelooping_delay
self.restartparser = False
self.sniffer = sniffer()
self.callbacks = []
self.done = 0
self.driver = driver
self.dstats = dstats
if self.sniffer.listen() == 0:
#print "sniffer failed to listen"
self.sniffer = None
self.fp_sil = fp_sil
return
def readpcap(address):
with open(address, 'rb') as f:
f.read(24) #header
while (True):
notend = f.read(1)
if notend:
f.read(3) #second -1
f.read(4) #msecond
f.read(4) #size
size = f.read(4) #size
size = struct.unpack("I", size)
rawData = f.read(size[0])
show = sniffer.sniffer(rawData)
show.listen_log()
print("-------------------------------------------------")
else:
print("reading file finished")
break
def receiver(attack,port,ports):
s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
while(True):
data=s.recvfrom(1024)
try:
portscan=sniffer.sniffer(data[0])
data=portscan.computetcpflag()
if(data["Port"]!=12345):
return
else:
#print(data["Port"])
pass
if(attack==1):
if(data["RST"]==1):
ports['unfilterd'].append(data["destPort"])
elif(attack==2):
if(data["ACK"]==1 and data["SYN"]==1):
#ports.append(data["destPort"])
ports["open"].append(data["destPort"])
elif(data["RST"]==1):
ports["closed"].append(data["destPort"])
else:
ports["filterd"].append(data["destPort"])
elif(attack==3):
if(data["RST"]==1):
ports['closed'].append(data["destPort"])
elif(attack==4):
if(data["RST"]==1 and data["size"]>0):
ports['open'].append(data["destPort"])
elif(data["RST"]==1 and data["size"]==0):
ports['closed'].append(data["destPort"])
else:
ports['filtered'].append(data["destPort"])
except:
pass
def test_sniff(self):
self.assertTrue(100 <= sniffer('tcp'), 'less then 100')
def __init__(self, parent = None):
super(Main_widget, self).__init__(parent)
self.sdsready = False
self.ecunamemap = {}
self.plugins = {}
self.setWindowTitle(_("DDT4All"))
self.ecu_scan = ecu.Ecu_scanner()
self.ecu_scan.qapp = app
options.ecu_scanner = self.ecu_scan
print ("%i " + _("loaded ECUs in database.")) % self.ecu_scan.getNumEcuDb()
if self.ecu_scan.getNumEcuDb() == 0:
msgbox = gui.QMessageBox()
msgbox.setIcon(gui.QMessageBox.Warning)
msgbox.setText("No database found")
msgbox.setInformativeText("Check documentation")
msgbox.exec_()
self.paramview = None
self.docview = webkit.QWebView()
self.docview.load(core.QUrl("https://github.com/cedricp/ddt4all/wiki"))
self.docview.settings().setAttribute(webkit.QWebSettings.JavascriptEnabled, True)
self.docview.settings().setAttribute(webkit.QWebSettings.PluginsEnabled, True)
self.docview.settings().setAttribute(webkit.QWebSettings.AutoLoadImages, True)
self.screennames = []
self.statusBar = gui.QStatusBar()
self.setStatusBar(self.statusBar)
self.connectedstatus = gui.QLabel()
self.connectedstatus.setAlignment(core.Qt.AlignHCenter | core.Qt.AlignVCenter)
self.protocolstatus = gui.QLabel()
self.progressstatus = gui.QProgressBar()
self.infostatus = gui.QLabel()
self.connectedstatus.setFixedWidth(100)
self.protocolstatus.setFixedWidth(200)
self.progressstatus.setFixedWidth(150)
self.infostatus.setFixedWidth(200)
self.refreshtimebox = gui.QSpinBox()
self.refreshtimebox.setRange(100, 2000)
self.refreshtimebox.setSingleStep(100)
self.refreshtimebox.valueChanged.connect(self.changeRefreshTime)
refrestimelabel = gui.QLabel(_("Refresh rate (ms):"))
self.cantimeout = gui.QSpinBox()
self.cantimeout.setRange(0, 1000)
self.cantimeout.setSingleStep(200)
self.cantimeout.setValue(options.cantimeout)
self.cantimeout.valueChanged.connect(self.changeCanTimeout)
cantimeoutlabel = gui.QLabel(_("Can timeout (ms) [0:AUTO] :"))
self.statusBar.addWidget(self.connectedstatus)
self.statusBar.addWidget(self.protocolstatus)
self.statusBar.addWidget(self.progressstatus)
self.statusBar.addWidget(refrestimelabel)
self.statusBar.addWidget(self.refreshtimebox)
self.statusBar.addWidget(cantimeoutlabel)
self.statusBar.addWidget(self.cantimeout)
self.statusBar.addWidget(self.infostatus)
self.tabbedview = gui.QTabWidget()
self.setCentralWidget(self.tabbedview)
self.scrollview = gui.QScrollArea()
self.scrollview.setWidgetResizable(False)
self.snifferview = sniffer.sniffer()
self.tabbedview.addTab(self.docview, _("Documentation"))
self.tabbedview.addTab(self.scrollview, _("Screen"))
self.tabbedview.addTab(self.snifferview, _("CAN Sniffer"))
if options.simulation_mode:
self.buttonEditor = dataeditor.buttonEditor()
self.requesteditor = dataeditor.requestEditor()
self.dataitemeditor = dataeditor.dataEditor()
self.ecuparameditor = dataeditor.ecuParamEditor()
self.tabbedview.addTab(self.requesteditor, _("Requests"))
self.tabbedview.addTab(self.dataitemeditor, _("Data"))
self.tabbedview.addTab(self.buttonEditor, _("Buttons"))
self.tabbedview.addTab(self.ecuparameditor, _("Ecu parameters"))
screen_widget = gui.QWidget()
self.treedock_widget = gui.QDockWidget(self)
self.treedock_widget.setWidget(screen_widget)
self.treeview_params = gui.QTreeWidget()
self.treeview_params.setSortingEnabled(True)
self.treeview_params.sortByColumn(0, core.Qt.AscendingOrder)
self.screenmenu = gui.QMenuBar()
treedock_layout = gui.QVBoxLayout()
treedock_layout.addWidget(self.screenmenu)
treedock_layout.addWidget(self.treeview_params)
screen_widget.setLayout(treedock_layout)
self.treeview_params.setHeaderLabels([_("Screens")])
self.treeview_params.clicked.connect(self.changeScreen)
actionmenu = self.screenmenu.addMenu(_("Action"))
cat_action = gui.QAction(_("New Category"), actionmenu)
screen_action = gui.QAction(_("New Screen"), actionmenu)
rename_action = gui.QAction(_("Rename"), actionmenu)
actionmenu.addAction(cat_action)
actionmenu.addAction(screen_action)
actionmenu.addAction(rename_action)
cat_action.triggered.connect(self.newCategory)
screen_action.triggered.connect(self.newScreen)
rename_action.triggered.connect(self.screenRename)
self.treedock_logs = gui.QDockWidget(self)
self.logview = gui.QTextEdit()
self.logview.setReadOnly(True)
self.treedock_logs.setWidget(self.logview)
self.treedock_ecu = gui.QDockWidget(self)
self.treeview_ecu = gui.QListWidget(self.treedock_ecu)
self.treedock_ecu.setWidget(self.treeview_ecu)
self.treeview_ecu.clicked.connect(self.changeECU)
self.eculistwidget = Ecu_list(self.ecu_scan, self.treeview_ecu)
self.treeview_eculist = gui.QDockWidget(self)
self.treeview_eculist.setWidget(self.eculistwidget)
self.addDockWidget(core.Qt.LeftDockWidgetArea, self.treeview_eculist)
self.addDockWidget(core.Qt.LeftDockWidgetArea, self.treedock_ecu)
self.addDockWidget(core.Qt.LeftDockWidgetArea, self.treedock_widget)
self.addDockWidget(core.Qt.BottomDockWidgetArea, self.treedock_logs)
self.toolbar = self.addToolBar(_("File"))
self.diagaction = gui.QAction(gui.QIcon("icons/dtc.png"), _("Read DTC"), self)
self.diagaction.triggered.connect(self.readDtc)
self.diagaction.setEnabled(False)
self.log = gui.QAction(gui.QIcon("icons/log.png"), _("Full log"), self)
self.log.setCheckable(True)
self.log.setChecked(options.log_all)
self.log.triggered.connect(self.changeLogMode)
self.expert = gui.QAction(gui.QIcon("icons/expert.png"), _("Expert mode (enable writing)"), self)
self.expert.setCheckable(True)
self.expert.setChecked(options.promode)
self.expert.triggered.connect(self.changeUserMode)
self.autorefresh = gui.QAction(gui.QIcon("icons/autorefresh.png"), _("Auto refresh"), self)
self.autorefresh.setCheckable(True)
self.autorefresh.setChecked(options.auto_refresh)
self.autorefresh.triggered.connect(self.changeAutorefresh)
self.refresh = gui.QAction(gui.QIcon("icons/refresh.png"), _("Refresh (one shot)"), self)
self.refresh.triggered.connect(self.refreshParams)
self.refresh.setEnabled(not options.auto_refresh)
self.hexinput = gui.QAction(gui.QIcon("icons/hex.png"), _("Manual command"), self)
self.hexinput.triggered.connect(self.hexeditor)
self.hexinput.setEnabled(False)
self.sdscombo = gui.QComboBox()
self.sdscombo.setFixedWidth(300)
self.sdscombo.currentIndexChanged.connect(self.changeSds)
self.sdscombo.setEnabled(False)
self.zoominbutton = gui.QPushButton("Zoom In")
self.zoomoutbutton = gui.QPushButton("Zoom Out")
self.zoominbutton.clicked.connect(self.zoomin)
self.zoomoutbutton.clicked.connect(self.zoomout)
self.toolbar.addSeparator()
self.toolbar.addAction(self.log)
self.toolbar.addAction(self.expert)
self.toolbar.addSeparator()
self.toolbar.addAction(self.autorefresh)
self.toolbar.addAction(self.refresh)
self.toolbar.addSeparator()
self.toolbar.addAction(self.diagaction)
self.toolbar.addSeparator()
self.toolbar.addAction(self.hexinput)
self.toolbar.addSeparator()
self.toolbar.addWidget(self.sdscombo)
self.toolbar.addSeparator()
self.toolbar.addWidget(self.zoominbutton)
self.toolbar.addWidget(self.zoomoutbutton)
if options.simulation_mode:
self.toolbar.addSeparator()
self.ui_edit_button = gui.QPushButton("UI Edit")
self.ui_edit_button.setCheckable(True)
self.toolbar.addSeparator()
self.toolbar.addWidget(self.ui_edit_button)
self.ui_edit_button.clicked.connect(self.toggle_edit)
vehicle_dir = "vehicles"
if not os.path.exists(vehicle_dir):
os.mkdir(vehicle_dir)
ecu_files = []
for filename in os.listdir(vehicle_dir):
basename, ext = os.path.splitext(filename)
if ext == '.ecu':
ecu_files.append(basename)
menu = self.menuBar()
diagmenu = menu.addMenu(_("File"))
xmlopenaction = diagmenu.addAction("Open XML")
newecuction = diagmenu.addAction(_("Create New ECU"))
saveecuaction = diagmenu.addAction(_("Save current ECU"))
diagmenu.addSeparator()
savevehicleaction = diagmenu.addAction(_("Save ECU list"))
savevehicleaction.triggered.connect(self.saveEcus)
saveecuaction.triggered.connect(self.saveEcu)
newecuction.triggered.connect(self.newEcu)
xmlopenaction.triggered.connect(self.openxml)
diagmenu.addSeparator()
zipdbaction = diagmenu.addAction(_("Zip database"))
zipdbaction.triggered.connect(self.zipdb)
diagmenu.addSeparator()
for ecuf in ecu_files:
ecuaction = diagmenu.addAction(ecuf)
ecuaction.triggered.connect(lambda state, a=ecuf: self.loadEcu(a))
plugins_menu = menu.addMenu(_("Plugins"))
category_menus = {}
plugins = glob.glob("./ddtplugins/*.py")
for plugin in plugins:
try:
modulename = os.path.basename(plugin).replace(".py", "")
plug = imp.load_source(modulename, plugin)
category = plug.category
name = plug.plugin_name
need_hw = plug.need_hw
#if options.simulation_mode and need_hw:
# continue
if not category in category_menus:
category_menus[category] = plugins_menu.addMenu(category)
plug_action = category_menus[category].addAction(name)
plug_action.triggered.connect(lambda state, a=plug.plugin_entry: self.launchPlugin(a))
self.plugins[modulename] = plug
except Exception as e:
print _("Cannot load plugin %s, %s") % (plugin, traceback.format_exc())
self.setConnected(True)
print "-" * 50
return int( raw_input("Option: ") )
def output_format():
subprocess.call('clear', shell=True)
print "-" * 50
print "\t Select an option:"
print "\t\t1) Console"
print "\t\t2) txt file"
print "\t\t3) Back"
print "-" * 50
return int( raw_input("Option: ") )
while True:
option = print_menu()
while option != 3:
format = output_format()
subprocess.call('clear', shell=True)
if option == 1:
scan(format)
elif option == 2:
sniffer(format)
elif option == 3:
sys.exit()
else:
print "Invalid option"
raw_input("Enter to continue")
break
if option == 3:
sys.exit()
def test_sniff(self):
self.assertTrue(10 <= sniffer('icmp'), 'less then 10')
def init_sniffer(self):
self.sniffer = sniffer(self.options, self.parser, self.database)
self.sniffer.start()
def initiate():
global_data.init = True
snf.sniffer()
mqtt_enabled = config.getboolean('mqtt','mqtt_enabled')
mqtt_host = config.get('mqtt','mqtt_host')
mqtt_port = config.get('mqtt','mqtt_port')
mqtt_topic = config.get('mqtt','mqtt_topic')
logger = logging.getLogger(__name__)
hdlr = logging.FileHandler(log_filename)
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
logger.setLevel(logging.DEBUG)
msg = InverterMsg.InverterMsg()
logging.getLogger("scapy.runtime").setLevel(logging.ERROR) # Suppress warning messages from Scapy
if mqtt_enabled:
logger.debug('publishing to MQTT: %s : %s' % (mqtt_topic,"OmnikExport running"))
publish.single(mqtt_topic,"OmnikExport running",hostname=mqtt_host,port=mqtt_port)
logger.info('sniffing data with filter %s on %s. Callback function = %s' % ("tcp and host "+ip,sniff_iface,MQTTcallback))
sn=sniffer.sniffer(sniff_iface,"tcp and host "+ip,minInterval=10,minPacketLength=120,callback=MQTTcallback)
sn.daemon=True
sn.start()
while True:
time.sleep(5)
if mqtt_enabled:
publish.single(mqtt_topic,"OmnikExport stopping",hostname=mqtt_host,port=mqtt_port)
import curses
import time
import sniffer
import threading
snif = sniffer.sniffer()
def getSet(n):
if (n % 2 == 1):
return list(snif.save.allURLs)
else:
return list(snif.save.badURLs)
def main(window):
curses.curs_set(0)
h, w = window.getmaxyx()
curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_BLACK)
curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE)
string = "Safety Sniffer"
window.addstr(0, w // 2 - len(string) // 2, string)
col = 1
while True:
window.clear()
window.attron(curses.color_pair(col % 2))
str2 = "All Websites Visited"
window.addstr(1, w // 4 - len(str2) // 2, str2)
window.attroff(curses.color_pair(col % 2))
window.attron(curses.color_pair((col + 1) % 2))
def test_sniff(self):
self.assertTrue(50 <= sniffer('udp'), 'less then 50')
def set_sniffer(self):
self.snif = sniffer(self.iface, self.n_pkts)
self.snif.sniff()
self.lista = self.snif.formato()
msg = InverterMsg.InverterMsg()
logging.getLogger("scapy.runtime").setLevel(
logging.ERROR) # Suppress warning messages from Scapy
if mqtt_enabled:
logger.debug('publishing to MQTT: %s : %s' %
(mqtt_topic, "OmnikExport running"))
publish.single(mqtt_topic,
"OmnikExport running",
hostname=mqtt_host,
port=mqtt_port)
logger.info('sniffing data with filter %s on %s. Callback function = %s' %
("tcp and host " + ip, sniff_iface, MQTTcallback))
sn = sniffer.sniffer(sniff_iface,
"tcp and host " + ip,
minInterval=10,
minPacketLength=120,
callback=MQTTcallback)
sn.daemon = True
sn.start()
while True:
time.sleep(5)
if mqtt_enabled:
publish.single(mqtt_topic,
"OmnikExport stopping",
hostname=mqtt_host,
port=mqtt_port)
backoff.backoff(**eval_dict).plot()
# FIXME: diagnostic, packet_loss and retxs plots can only be created if rtt is True.
if create_plots["rtt"] == True:
print(
"_______________________________________________________________")
print("Creating rtt plot!")
print(
"***************************************************************")
rtt.rtt(**eval_dict).plot()
if create_plots["throughput"] == True:
print(
"_______________________________________________________________")
print("Creating throughput plot!")
print(
"***************************************************************")
tp.tp(**eval_dict).plot()
# The plots with only one plot type!
if create_plots["channel_occupation"] == True:
print("_______________________________________________________________")
print("Creating channel occupation plot!")
print("***************************************************************")
channel_occupation.channel_occupation(**eval_dict)
if create_plots["sniffer"] == True:
print("_______________________________________________________________")
print("Creating sniffer energy plot!")
print("***************************************************************")
sniffer.sniffer(**eval_dict)
print("Done.")
def init_sniffer(self):
self.sniffer = sniffer(self.options, self.parser, self.database)
self.sniffer.start()