def setup(): # Find connected sniffers ports = UART.find_sniffer() if len(ports) > 0: # Initialize the sniffer on the first port found with baudrate 1000000. # If you are using an old firmware version <= 2.0.0, simply remove the baudrate parameter here. sniffer = Sniffer.Sniffer(portnum=ports[0], baudrate=1000000) else: print("No sniffers found!") return sniffer.start() tls_dev_addr = [0xde, 0xde, 0x96, 0xdf, 0x92, 0x4a, True] for _ in range(10): time.sleep(1) devlist = sniffer.getDevices() found_dev = [ dev for dev in devlist.devices if dev.address == tls_dev_addr ] if found_dev: follow(sniffer, found_dev[0]) break
def setup(): global mySniffer # Find connected sniffers ports = UART.find_sniffer() if len(ports) > 0: # Initialize the sniffer on the first COM port found with baudrate 1000000. # If you are using an old firmware version <= 2.0.0, simply remove the baudrate parameter here. mySniffer = Sniffer.Sniffer(portnum=ports[0], baudrate=1000000) else: print("No sniffers found!") return # Start the sniffer module. This call is mandatory. mySniffer.start() # Wait to allow the sniffer to discover device mySniffer. time.sleep(5) # Retrieve list of discovered devicemySniffer. d = mySniffer.getDevices() # Find device with name "Example". dev = d.find('Example') if dev is not None: # Follow (sniff) device "Example". This call sends a REQ_FOLLOW command over UART. mySniffer.follow(dev) else: print("Could not find device")
def start(self) -> None: interface = self.get_interfaces()[0] baudrate = self.get_baud_rates(interface) sniffer = Sniffer.Sniffer(interface, baudrate["default"]) sniffer.subscribe("NEW_BLE_PACKET", self.new_packet) sniffer.setAdvHopSequence([37, 38, 39]) sniffer.start() sniffer.scan() self.sniffer = sniffer while True: time.sleep(10)
def setup(): sniffer = Sniffer.Sniffer("/dev/ttyACM0") sniffer.start() tls_dev_addr = [0xde, 0xde, 0x96, 0xdf, 0x92, 0x4a, True] for _ in range(10): time.sleep(1) devlist = sniffer.getDevices() found_dev = [dev for dev in devlist.devices if dev.address == tls_dev_addr] if found_dev: follow(sniffer, found_dev[0]) break
def setup(): sniffer = Sniffer.Sniffer("/dev/cu.usbmodem0006821628261") sniffer.start() tls_dev_addr = [0xDE, 0xDE, 0x96, 0xDF, 0x92, 0x4A, True] for _ in range(10): time.sleep(1) devlist = sniffer.getDevices() print(devlist) found_dev = [ dev for dev in devlist.devices if dev.address == tls_dev_addr ] if found_dev: follow(sniffer, found_dev[0]) break
def sniffer_capture(interface, baudrate, fifo, control_in, control_out): """Start the sniffer to capture packets""" global fn_capture, fn_ctrl_in, fn_ctrl_out, write_new_packets with open(fifo, 'wb', 0) as fn_capture: capture_write(make_pcap_header()) with open(control_out, 'wb', 0) as fn_ctrl_out: logging.info("control_out open: {}".format(fn_ctrl_out)) control_write(CTRL_ARG_LOG, CTRL_CMD_SET, "") logging.info("Log started at " + time.strftime("%c")) validate_interface(interface, fifo) if baudrate is None: baudrate = get_default_baudrate(interface, fifo) with open(control_in, 'rb', 0) as fn_ctrl_in: logging.info("control_in open: {}".format(fn_ctrl_in)) # Initialize the sniffer and discover devices. sniffer = Sniffer.Sniffer(interface, baudrate) sniffer.subscribe("NEW_BLE_PACKET", new_packet) sniffer.subscribe("DEVICE_ADDED", device_added) sniffer.subscribe("DEVICE_UPDATED", device_added) sniffer.subscribe("DEVICE_REMOVED", device_removed) sniffer.setAdvHopSequence([37, 38, 39]) logging.info("sniffer created") sniffer.start() logging.info("sniffer started") sniffer.scan() logging.info("scanning started") # First read initial control values control_read_initial_values(sniffer) # Then write default values control_write_defaults() logging.info("defaults written") # Start receiving packets write_new_packets = True # Start the control loop logging.info("control loop") control_loop(sniffer) logging.info("exiting control loop")
def setup(serport, delay=3): """ Tries to connect to and initialize the sniffer using the specific serial port @param serport: The name of the serial port to connect to ("COM14", "/dev/tty.usbmodem1412311", etc.) @type serport: str @param delay: Time to wait for the UART connection to be established (in seconds) @param delay: int """ global mySniffer # Initialize the device on the specified serial port print "Connecting to sniffer on " + serport mySniffer = Sniffer.Sniffer(serport) # Start the sniffer mySniffer.start() # Wait a bit for the connection to initialise time.sleep(delay)
def setup(): global mySniffer # Initialize the sniffer on COM port COM19. # mySniffer = Sniffer.Sniffer("COM19") # Or initialize and let the sniffer discover the hardware. mySniffer = Sniffer.Sniffer() # Start the sniffer module. This call is mandatory. mySniffer.start() # Wait to allow the sniffer to discover device mySniffer. time.sleep(5) # Retrieve list of discovered devicemySniffer. d = mySniffer.getDevices() # Find device with name "Example". dev = d.find('Example') if dev is not None: # Follow (sniff) device "Example". This call sends a REQ_FOLLOW command over UART. mySniffer.follow(dev) else: print "Could not find device"
def sniffer_capture(interface, fifo, control_in, control_out): """Start the sniffer to capture packets""" global fn_capture, fn_ctrl_in, fn_ctrl_out, write_new_packets with open(fifo, 'wb', 0) as fn_capture: capture_write(make_pcap_header()) with open(control_out, 'wb', 0) as fn_ctrl_out: control_write(CTRL_ARG_LOG, CTRL_CMD_SET, "") logging.info("Log started at " + time.strftime("%c")) validate_interface(interface, fifo) # Initialize the sniffer and discover devices. sniffer = Sniffer.Sniffer(interface) sniffer.subscribe("NEW_BLE_PACKET", new_packet) sniffer.subscribe("DEVICE_ADDED", device_added) sniffer.subscribe("DEVICE_UPDATED", device_added) sniffer.subscribe("DEVICE_REMOVED", device_removed) sniffer.setAdvHopSequence([37, 38, 39]) sniffer.start() sniffer.scan() with open(control_in, 'rb', 0) as fn_ctrl_in: print('control in file opened') # First read initial control values control_read_initial_values(sniffer) # Then write default values control_write_defaults() # Start receiving packets write_new_packets = True # Start the control loop control_loop(sniffer)
def sniffer_capture(interface, baudrate, fifo, control_in, control_out): """Start the sniffer to capture packets""" global fn_capture, fn_ctrl_in, fn_ctrl_out, write_new_packets, extcap_log_handler try: fn_capture = open(fifo, 'wb', 0) if control_out is not None: fn_ctrl_out = open(control_out, 'wb', 0) setup_extcap_log_handler() if control_in is not None: fn_ctrl_in = open(control_in, 'rb', 0) logging.info("Log started at %s", time.strftime("%c")) capture_write(Pcap.get_global_header()) validate_interface(interface, fifo) if baudrate is None: baudrate = get_default_baudrate(interface, fifo) sniffer = Sniffer.Sniffer(interface, baudrate) sniffer.subscribe("NEW_BLE_PACKET", new_packet) sniffer.subscribe("DEVICE_ADDED", device_added) sniffer.subscribe("DEVICE_UPDATED", device_added) sniffer.subscribe("DEVICE_REMOVED", device_removed) sniffer.setAdvHopSequence([37, 38, 39]) logging.info("Sniffer created") sniffer.start() logging.info("sniffer started") sniffer.scan() logging.info("scanning started") if fn_ctrl_in is not None and fn_ctrl_out is not None: # First read initial control values control_read_initial_values(sniffer) # Then write default values control_write_defaults() logging.info("defaults written") # Start receiving packets write_new_packets = True # Start the control loop logging.info("control loop") control_loop(sniffer) logging.info("exiting control loop") else: logging.info("") # Start receiving packets write_new_packets = True while True: # Wait for keyboardinterrupt pass except OSError: # We'll get OSError=22 when/if wireshark kills the pipe(s) on capture # stop. teardown_extcap_log_handler() finally: # In case we got something else than OSError. teardown_extcap_log_handler() sniffer.doExit() if fn_capture is not None and not fn_capture.closed: fn_capture.close() if fn_ctrl_in is not None and not fn_ctrl_in.closed: fn_ctrl_in.close() if fn_ctrl_out is not None and not fn_ctrl_out.closed: fn_ctrl_out.close() fn_capture = None fn_ctrl_out = None fn_ctrl_in = None logging.info("exiting")
global udp_socket udp_socket = socket(AF_INET, SOCK_STREAM) print udp_host, udp_port, type(udp_port) udp_socket.connect((udp_host, udp_port)) except socket_error, msg: print 'Failed to create socket. Error Code: %s | Message: %s' % (str( msg[0]), str(msg[1])) sys.exit() print 'UDP Socket created, Host: %s Port: %s' % (udp_host, udp_port) # initialize sniffer over the serial connection print "Connecting to sniffer on " + device_addr global ble_sniffer ble_sniffer = Sniffer.Sniffer(device_addr) ble_sniffer.start() def scan_devices_and_follow(): global ble_sniffer global udp_socket #devices = {} while True: packets = ble_sniffer.getPackets() for packet in packets: if packet.blePacket is not None: try: addr = ':'.join( ["%02X" % x for x in packet.blePacket.advAddress]) # Display the raw BLE packet payload