def exception(self):
"""Set passed to False and reason to the exception message.
:return:
"""
self.passed = False
self.reason = "Exception caught: [{}]".format(sysexcinfo())
def execute(self):
"""Execute the test."""
count = self.args.count
timeout = self.args.timeout
packetcount = 0
pcap_writer = None
radio = None
TLog.generic("{:<13}: ({})".format("Channel", self.args.channel))
TLog.generic("{:<13}: ({})".format("File", self.args.filepath))
TLog.generic("{:<13}: ({})".format("Count", count))
TLog.generic("{:<13}: ({})".format("Time-Out", timeout))
try:
# Get the Sniffer interface driver
radio = Dot154Radio()
# Create pcap file to dump the packet
pcap_writer = PcapDumper(PCAP_DLT_IEEE802_15_4, self.args.filepath)
# Turn ON radio sniffer
radio.sniffer_on(self.args.channel)
# kick start timer, if user set some timeout
if timeout != 0:
# Create Timer for timeout check
timer = Timer()
timer.timeout = timeout
while True:
packet = radio.read_raw_packet()
if packet is not None:
packetcount += 1
pcap_frame = PcapFrame(packet)
pcap_writer.write_to_pcapfile(pcap_frame.get_pcap_frame())
if timeout != 0:
if timer.is_timeout():
break
if packetcount == count:
break
except: # noqa: E722
self.result.setstatus(passed=False,
reason="Exception caught: {}".format(
sysexcinfo()))
finally:
# Close file handler
if pcap_writer:
pcap_writer.close()
# Turn OFF radio sniffer and exit
if radio:
# Execution Done
self.output_handler(
packets_received=radio.get_received_packets())
radio.sniffer_off()
def execute(self):
"""Execute the test."""
dst_pan = None
send_packet = False
pcap_reader = None
radio = None
# Get Destination PAN address
if self.args.pan:
dst_pan = self.args.pan
delay_sec = self.args.delay / 1000
TLog.generic("{:<13}: ({})".format("Channel", self.args.channel))
TLog.generic("{:<13}: ({})".format("File", self.args.pcapfile))
TLog.generic("{:<13}: ({})".format("Delay (seconds)", delay_sec))
if dst_pan:
TLog.generic("{:<15}: ({})".format("Destination PAN",
hex(dst_pan)))
TLog.generic("")
try:
radio = Dot154Radio()
pcap_reader = PcapDumpReader(self.args.pcapfile)
radio.radio_on()
radio.set_channel(self.args.channel)
while True:
packet = pcap_reader.read_next_packet()
if packet:
if not dst_pan and not is_ack_packet(packet):
send_packet = True
elif dst_pan and dst_pan == get_dst_pan_from_packet(
packet):
send_packet = True
if send_packet:
radio.inject_raw_packet(packet[0:-2])
send_packet = False
time.sleep(delay_sec)
else:
break
except: # noqa: E722
self.result.setstatus(passed=False,
reason="Exception caught: {}".format(
sysexcinfo()))
finally:
# Close file handler
if pcap_reader:
pcap_reader.close()
# Turn OFF radio and exit
if radio:
self.output_handler(
packets_received=radio.get_received_packets(),
packets_transmitted=radio.get_transmitted_packets())
radio.radio_off()
def execute(self):
"""Execute the test."""
TLog.generic(
"Connecting to the the serial port ({}) timeout ({})".format(
self.args.port, self.args.timeout))
TLog.generic("Scanning for baud rates: {}".format(self.args.bauds))
reason = "No good baud rate found"
best = {"baud_rate": 0, "percentage_ascii": 0}
try:
for baud in self.args.bauds.split(","):
percentage_ascii = self.check_baud(int(baud))
if percentage_ascii == 100:
TLog.success("Found correct baud rate: {}".format(baud))
return
if percentage_ascii > best["percentage_ascii"]:
best["percentage_ascii"] = percentage_ascii
best["baud_rate"] = int(baud)
if best["percentage_ascii"] > 90:
TLog.success(
"Found good baud rate {} with {}% ASCII data".format(
best["baud_rate"], best["percentage_ascii"]))
return
TLog.generic(
"Baud rate {} has max. ASCII percentage of {} %".format(
best["baud_rate"], best["percentage_ascii"]))
except: # noqa: E722
reason = "Exception caught: {}".format(sysexcinfo())
self.result.setstatus(passed=False, reason=reason)
def scan(self):
"""
Scan for BLE devices in the proximity.
:return:
"""
TLog.generic("Scanning BLE devices for {} second(s)".format(
self.args.timeout))
try:
devices = Ble.scan(iface=self.args.iface, tout=self.args.timeout)
for device in devices:
self.found = True
TLog.success("(name={})(address={})".format(
device.getValueText(Ble.ADTYPE_NAME) or "Unknown",
device.addr))
if self.args.verbose is True:
TLog.success(" (rssi={}dB)".format(device.rssi))
TLog.success(" (connectable={})".format(
device.connectable))
for scan_data in device.getScanData():
TLog.success(" ({}={})".format(
scan_data[1], scan_data[2]))
except: # noqa: E722
self.reason = "Exception caught: {}".format(sysexcinfo())
if self.found is False and self.reason is None:
self.reason = "No BLE devices found"
def enumerate(self):
"""
Enumerate the services and/or characteristics of the specified BLE device.
:return:
"""
# Documentation is wrong, the first keyword argument is deviceAddr instead of
# deviceAddress. http://ianharvey.github.io/bluepy-doc/
if self.args.services is False and self.args.chars is False:
TLog.fail(
"Specify the enumerations option(s). Either or both - services, chars"
)
self.reason = "Incomplete arguments"
return
TLog.generic(
"Enumerating services/characteristics of the device {}".format(
self.args.addr
)
)
device = BlePeripheral()
try:
device.connect(
self.args.addr,
addrType=(
ADDR_TYPE_RANDOM
if self.args.randaddrtype
else ADDR_TYPE_PUBLIC
),
)
self.found = True
if self.args.services is True:
services = device.getServices()
for service in services:
TLog.success(
"(service uuid={})(handlestart={})(handleend={})".format(
service.uuid, hex(service.hndStart), hex(service.hndEnd)
)
)
if self.args.chars is True:
chars = device.getCharacteristics()
for char in chars:
TLog.success(
"(characteristic uuid={})(handle={})".format(
char.uuid, hex(char.getHandle())
)
)
if self.args.verbose is True:
support_property = char.propertiesToString()
supports_read = char.supportsRead()
TLog.success(" (supported_properties={})".format(support_property))
if supports_read is True:
TLog.success(" (value={})".format(char.read()))
except: # noqa: E722
self.reason = "Exception caught: {}".format(sysexcinfo())
finally:
device.disconnect()
if self.found is False and self.reason is None:
self.reason = "Couldn't find any devices"
def execute(self):
"""Execute the test."""
TLog.generic(
"Connecting to the the serial port ({}) with baud ({})".format(
self.args.port, self.args.baud))
TLog.generic("Using chars({}) and length({})".format(
self.args.chars, self.args.length))
found = False
reason = "Couldn't find a valid command"
commands = []
tries = 0
sock = None
try:
sock = Serial(self.args.port,
self.args.baud,
timeout=self.args.timeout)
for word in itertools.product(self.args.chars,
repeat=self.args.length):
cmd = self.args.prefix + "".join(word) + self.args.append
sock.write(cmd.encode())
received_data = sock.readfull(self.args.buffsize)
sock.flush()
tries += 1
if tries % 20 == 0:
# Print something to engage the user :)
TLog.generic("Tried {} commands till now".format(tries))
if self.args.verbose is True:
TLog.trydo("Command=({}) response({})".format(
cmd.rstrip(), received_data))
if self.args.match is not None:
if self.args.match.lower() in received_data.decode().lower(
):
TLog.success(
"Command=({}) found. --match criteria in Response=({})"
.format(cmd.rstrip(), received_data))
found = True
commands.append(cmd.rstrip())
if self.args.stop is True:
break
elif self.args.nomatch is not None:
if self.args.nomatch.lower() not in received_data.decode(
).lower():
TLog.success(
"Command=({}) found. --nomatch criteria in response=({})"
.format(cmd.rstrip(), received_data))
found = True
commands.append(cmd.rstrip())
if self.args.stop is True:
break
except: # noqa: E722
reason = "Exception caught: {}".format(sysexcinfo())
finally:
if sock:
sock.close()
if found is True:
TLog.success("Valid commands found: ({})".format(commands))
else:
self.result.setstatus(passed=False, reason=reason)
def execute(self):
"""
Execute the plugin.
Enumerate the services and/or characteristics of the specified BLE device.
Returns:
Nothing
"""
# Documentation is wrong, the first keyword argument is deviceAddr instead of
# deviceAddress. http://ianharvey.github.io/bluepy-doc/
if self.args.services is False and self.args.chars is False:
reason = "Incomplete args. Enumerate what? Either or both - services, chars"
self.result.setstatus(passed=False, reason=reason)
return
TLog.generic(
"Enumerating services/characteristics of the device {}".format(
self.args.addr
)
)
device = BlePeripheral()
try:
device.connect(
self.args.addr,
addrType=(
ADDR_TYPE_RANDOM
if self.args.randaddrtype
else ADDR_TYPE_PUBLIC
),
)
if self.args.services is True:
services = device.getServices()
for service in services:
self.output_handler(service_uuid=str(service.uuid),
service_uuid_name=service.uuid.getCommonName(),
handle_start=hex(service.hndStart),
handle_end=hex(service.hndEnd))
if self.args.chars is True:
chars = device.getCharacteristics()
for char in chars:
chardict = {"char_uuid": str(char.uuid),
"char_uuid_name": char.uuid.getCommonName(),
"handle": hex(char.getHandle()),
"supported_properties": char.propertiesToString()}
if char.supportsRead():
chardict["readvalue"] = char.read()
self.output_handler(**chardict)
except: # noqa: E722
self.result.setstatus(passed=False,
reason="Exception caught: {}".format(sysexcinfo()))
finally:
device.disconnect()
def check_baud(self, baud):
"""
Scan a serial connection for ASCII data with a given baud rate.
:param baud: The baud rate to use for the serial connection
:return: Percentage of ASCII characters present in the received data
"""
sock = None
output = {
"baud": baud,
"ascii_percent": -1,
"received_data": None,
"ascii_data": None,
"status": None,
"exception": None
}
TLog.trydo("Checking baud rate: {}".format(baud))
try:
sock = Serial(self.args.port, baud, timeout=self.args.timeout)
output["received_data"] = sock.read(self.args.count)
sock.flush()
output["ascii_data"] = "".join([
chr(entry) for entry in output["received_data"]
if chr(entry) in string.printable
])
received_length = len(output["received_data"])
ascii_length = len(output["ascii_data"])
if received_length == 0:
output["status"] = "No data received"
TLog.fail("\t{}".format(output["status"]))
else:
output["status"] = "Data received"
output["ascii_percent"] = round(
ascii_length / received_length * 100, 2)
if self.args.verbose:
TLog.success("\tdata: {}, ASCII: {}".format(
output["received_data"], output["ascii_data"]))
TLog.success("\tASCII ratio: {}/{}, {} %".format(
ascii_length, received_length, output["ascii_percent"]))
except: # noqa: E722
output["exception"] = sysexcinfo()
TLog.fail("\tError: {}".format(output["exception"]))
finally:
if sock:
sock.close()
self.output_handler(logkwargs=LOGNO, **output)
return output["ascii_percent"]
def enumerate(self):
"""
Enumerate the services and/or characteristsics of the specified BLE device
:return:
"""
# documentation is wrong, the first keyword argument is deviceAddr instead of deviceAddress as per the doc
# Doc: http://ianharvey.github.io/bluepy-doc/
if self.args.services is False and self.args.chars is False:
TLog.fail(
"Specify the enumerations option(s). Either or both - services, chars"
)
self.reason = "Incomplete arguments"
return
TLog.generic(
"Enumerating services/characteristics of the device {}".format(
self.args.addr))
d = BlePeripheral()
try:
d.connect(self.args.addr,
addrType=(Ble.ADDR_TYPE_RANDOM if self.args.randaddrtype
else Ble.ADDR_TYPE_PUBLIC))
self.found = True
if self.args.services is True:
svcs = d.getServices()
for s in svcs:
TLog.success(
"(service uuid={})(handlestart={})(handleend={})".
format(s.uuid, hex(s.hndStart), hex(s.hndEnd)))
if self.args.chars is True:
chrs = d.getCharacteristics()
for c in chrs:
TLog.success("(characteristic uuid={})(handle={})".format(
c.uuid, hex(c.getHandle())))
if self.args.verbose is True:
sr = c.supportsRead()
TLog.success(" (supports_read={})".format(sr))
if sr is True:
TLog.success(" (value={})".format(c.read()))
except:
self.reason = "Exception caught: {}".format(sysexcinfo())
finally:
d.disconnect()
if self.found is False and self.reason is None:
self.reason = "Couldnt find any devices"
def execute(self):
"""
Execute the plugin.
Scan for BLE devices in the proximity.
Returns:
Nothing
"""
found = False
TLog.generic("Scanning BLE devices for {} second(s)".format(
self.args.timeout))
try:
devices = Ble.scan(iface=self.args.iface, tout=self.args.timeout)
for device in devices:
found = True
outdict = {
"name": device.getValueText(Ble.ADTYPE_NAME) or "Unknown",
"addr": device.addr,
"addrtype": device.addrType,
"rssi": "{} dBm".format(device.rssi),
"connectable": device.connectable,
"adtype_data": []
}
for scan_data in device.getScanData():
outdict["adtype_data"].append({
"adtype": scan_data[0],
"description": scan_data[1],
"value": scan_data[2]
})
self.output_handler(**outdict)
except: # noqa: E722
self.result.setstatus(passed=False,
reason="Exception caught: {}".format(
sysexcinfo()))
if found is False:
TLog.fail("No BLE devices found")
def check_baud(self, baud):
"""
Scan a serial connection for ASCII data with a given baud rate.
:param baud: The baud rate to use for the serial connection
:return: Percentage of ASCII characters present in the received data
"""
sock = None
percentage_ascii = -1
TLog.success("Checking baud rate: {}".format(baud))
try:
sock = Serial(self.args.port, baud, timeout=self.args.timeout)
received = sock.read(self.args.count)
sock.flush()
ascii_data = "".join([
chr(entry) for entry in received
if chr(entry) in string.printable
])
received_length = len(received)
ascii_length = len(ascii_data)
if received_length == 0:
TLog.fail("\tNo data received")
else:
percentage_ascii = round(ascii_length / received_length * 100,
2)
if self.args.verbose:
TLog.success("\tdata: {}, ASCII: {}".format(
received, ascii_data))
TLog.success("\tASCII ratio: {}/{}, {} %".format(
ascii_length, received_length, percentage_ascii))
except: # noqa: E722
TLog.fail("\tError: {}".format(sysexcinfo()))
finally:
if sock:
sock.close()
return percentage_ascii
def execute(self):
"""Execute the test."""
if self.args.start < 11 or self.args.start > 26:
self.result.setstatus(passed=False, reason="Invalid start channel")
return
if self.args.end < 11 or self.args.end > 26:
self.result.setstatus(passed=False, reason="Invalid end channel")
return
if self.args.end < self.args.start:
self.result.setstatus(passed=False,
reason="Invalid start or end channel")
return
if self.args.filepath is not None:
self.filename = self.args.filepath
# Print user input
TLog.generic("{:<13}: ({})".format("Start channel", self.args.start))
TLog.generic("{:<13}: ({})".format("End channel", self.args.end))
if self.filename is not None:
TLog.generic("{:<13}: ({})".format("Log file", self.filename))
TLog.generic("")
# get channel mask
ch_mask = self.get_channel_mask()
try:
# Get Network Scanner
nwkscanner = ZigbeeNetworkScan()
# Capture the scan start time
start_time = time.time()
# Start network scan with channel mask
result_dict = nwkscanner.scan(ch_mask)
# Capture the scan start time
end_time = time.time()
if result_dict is not None:
self.found = True
self.output_handler(logkwargs=LOGNO, **result_dict)
# Display result on console
self.display_scan_result(result_dict)
TLog.success("{:<17} {}".format("Scan duration",
end_time - start_time))
TLog.generic("")
# Write result in log file
if self.filename is not None:
self.write_result_to_logfile(result_dict)
else:
self.found = False
self.reason = "Couldn't find any Zigbee device on network"
except: # noqa: E722
self.found = False
self.reason = "Exception caught: {}".format(sysexcinfo())
finally:
self.result.setstatus(passed=self.found, reason=self.reason)
