def execute(self): """Execute the test.""" TLog.generic( "Reading data from i2c eeprom at address({}) using device({})". format(self.args.addr, self.args.url)) device = None try: device = I2cEepromManager.get_flash_device(self.args.url, self.args.chip, address=self.slaveaddr) length = self.args.length or (len(device) - self.args.addr) TLog.success("(chip size={} bytes)".format(len(device))) TLog.trydo("Reading {} bytes from start address {}".format( length, self.args.addr)) if self.args.addr + length > len(device): raise IndexError("Length is out of range of the chip size") start_time = time() data = device.read(self.args.addr, length) end_time = time() if self.args.wfile: TLog.trydo("Writing data to the file ({})".format( self.args.wfile)) output_file = open(self.args.wfile, "w+b") output_file.write(data) output_file.close() else: TLog.success("(data={})".format([hex(x) for x in data])) TLog.success( "Done. Total bytes read ({}) Time taken to read = {} secs". format(len(data), round(end_time - start_time, 2))) except: # noqa: E722 self.result.exception() finally: I2cEepromManager.close(device)
def execute(self): """Execute the test.""" TLog.generic( "Publishing message on topic ({}) to MQTT Broker ({}) on port " "({})".format(self.args.rhost, self.args.topic, self.args.rport)) credentials = None if self.args.user and self.args.passwd: credentials = { "username": self.args.user, "password": self.args.passwd } TLog.trydo( "Using authentication (username={})(password={})".format( self.args.user, self.args.passwd)) try: SimpleMqttClient.pub( self.args.topic, payload=self.args.msg, hostname=self.args.rhost, port=self.args.rport, auth=credentials, client_id=self.args.id, ) TLog.success("Done") except: # noqa: E722 self.result.exception()
def execute(self): """Execute the test.""" TLog.generic( "Sending request to server({}) on port({})".format( self.args.rhost, self.args.rport ) ) TLog.trydo("Searching imaginary database") TLog.success("Found matching entry in database - ({})".format("FooEntry")) snd = "GET / HTTP/1.1" TLog.generic( "Sending command to server ({}) on port ({})".format( self.args.rhost, self.args.rport ) ) if self.args.verbose is True: TLog.generic("More verbose output. Sending payload ({})".format(snd)) TLog.fail("No response received") TLog.generic("Re-sending command") response = "Response received from the server" # In case of failure (Nothing to do in case of success) if response: self.result.setstatus(passed=True, reason="Server is vulnerable") else: self.result.setstatus(passed=False, reason="Server is not vulnerable")
def execute(self): """Execute the test.""" TLog.generic("Sending request to server({}) on port({})".format( self.args.rhost, self.args.rport)) TLog.trydo("Searching imaginary database") self.output_handler(found_entry_in_db="FooEntry") # Or if you need to print extra message for only the console # but not required for the actual result output (chaining plugins) self.output_handler( msg="Found matching entry in database - ({})".format("FooEntry"), logkwargs=LOGNO, found_entry_in_db="FooEntry2") snd = "GET / HTTP/1.1" TLog.generic("Sending command to server ({}) on port ({})".format( self.args.rhost, self.args.rport)) if self.args.verbose is True: TLog.generic( "More verbose output. Sending payload ({})".format(snd)) TLog.fail("No response received") TLog.generic("Re-sending command") response = "Response received from the server" # In case of failure (Nothing to do in case of success) if response: self.output_handler(status="Server is vulnerable", services_available=["ssh", "foo"]) else: self.result.setstatus(passed=False, reason="Server is not vulnerable")
def execute(self): """Execute the mDNS discovery.""" service_names = list(MDNS_SERVICE_TYPES) if self.args.list: self.output_handler(supported_device_types=service_names) return TLog.generic("Search local network for mDNS enabled devices") if self.args.device: if self.args.device not in service_names: self.result.setstatus(passed=False, reason="Unknown device type specified") return service_names = [self.args.device] cnt = 0 for name in service_names: if self.args.verbose: TLog.trydo("Looking for {} devices".format(name)) details = MdnsDiscovery(name, scan_timeout=self.args.timeout) details.scan() for device in details.devices: cnt += 1 self.output_handler(device_number=cnt, name=device.name, address=device.address, port=device.port, server=device.server, type=device.type, priority=device.priority, weight=device.weight, properties=device.properties) self.output_handler(total_devices_discovered=cnt)
def execute(self): """Execute the test.""" TLog.generic( "Fuzzing the value ({}), iterations ({}) for handle ({}) on BLE device ({})" .format(self.args.value, self.args.iter, hex(self.args.handle), self.args.addr)) try: device = BlePeripheral() device.connect( self.args.addr, addrType=(Ble.ADDR_TYPE_RANDOM if self.args.randaddrtype else Ble.ADDR_TYPE_PUBLIC), ) for _ in range(self.args.iter): value = self.args.value while value.find("xx") >= 0: value = value.replace( "xx", "{:02x}".format(randint(0, 0xFF)), 1 # nosec ) TLog.trydo("Writing the fuzzed value ({})".format(value)) device.writeCharacteristic( self.args.handle, bytes.fromhex(value), withResponse=(not self.args.noresponse), ) except: # noqa: E722 self.result.exception() finally: device.disconnect()
def execute(self): """Execute the test.""" TLog.generic( "Subscribing to topic ({}) on MQTT broker ({}) on port ({})". format(self.args.topic, self.args.rhost, self.args.rport)) try: credentials = None if self.args.user and self.args.passwd: credentials = { "username": self.args.user, "password": self.args.passwd } TLog.trydo( "Using authentication (username={})(password={})".format( self.args.user, self.args.passwd)) messages = SimpleMqttClient.sub( self.args.topic, hostname=self.args.rhost, port=self.args.rport, client_id=self.args.id, auth=credentials, msg_count=self.args.count, ) for message in messages: TLog.success("(topic={})(payload={})".format( message.topic, str(message.payload))) except: # noqa: E722 self.result.exception()
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 test.""" TLog.generic( "Attempting to send file ({}) to DICOM server ({}) on port ({})". format(self.args.file, self.args.rhost, self.args.rport)) TLog.generic("Using Calling AET ({}) Called AET ({})".format( self.args.aetscu, self.args.aetscp)) file = None assoc = None try: app_entity = AE(ae_title=self.args.aetscu) app_entity.requested_contexts = StoragePresentationContexts input_file = open(self.args.file, "rb") dataset = dcmread(input_file, force=True) # 0 means assign random port in pynetdicom if self.args.lport != 0: TLog.generic("Using source port number ({})".format( self.args.lport)) if (self.args.lport < 1024) and (os.geteuid() != 0): TLog.fail("Oops! Need to run as root for privileged port") raise ValueError( "Using privileged port ({}) without root privileges". format(self.args.lport)) assoc = app_entity.associate( self.args.rhost, self.args.rport, bind_address=("", self.args.lport), ae_title=self.args.aetscp, ) TLog.trydo("Server implementation version name ({})".format( assoc.acceptor.implementation_version_name)) TLog.trydo("Server implementation class UID ({})".format( assoc.acceptor.implementation_class_uid)) if assoc.is_established: status = assoc.send_c_store(dataset) if status.Status == 0x0000: TLog.success("C-STORE Success (status=0x{0:04x})".format( status.Status)) else: reason = "C-STORE Failed to store file (status=0x{0:04x})".format( status.Status) TLog.fail(reason) self.result.setstatus(passed=False, reason=reason) else: self.result.setstatus( passed=False, reason="Could not establish association with the server", ) except: # noqa: E722 self.result.exception() finally: if assoc: assoc.release() if file: file.close()
def execute(self): """Execute the test.""" modbus_client = ModbusTcpClient(self.args.rhost, port=self.args.rport) try: if self.args.item < 0 or self.args.item >= len(WRITE_ITEMS): raise AttributeError( "Unknown --item specified ({})".format(self.args.item) ) if self.args.count < 1: raise AttributeError( "Invalid --count specified ({})".format(self.args.count) ) TLog.generic( "Sending write command to Modbus Server ({}) on port ({})".format( self.args.rhost, self.args.rport ) ) TLog.generic( "(item={})(address={})(count={})(unit={})".format( WRITE_ITEMS[self.args.item], self.args.address, self.args.count, self.args.unit, ) ) modbus_client.connect() if self.args.item == COIL: value = bool(self.args.value != 0) TLog.trydo("Writing value(s): {}".format(value)) response = modbus_client.write_coils( self.args.address, [value] * self.args.count, unit=self.args.unit ) if response.isError() is True: raise Exception(str(response)) elif self.args.item == REG: TLog.trydo("Writing value(s): {}".format(self.args.value)) response = modbus_client.write_registers( self.args.address, [self.args.value] * self.args.count, unit=self.args.unit, ) if response.isError() is True: raise Exception(str(response)) else: raise AttributeError( "Unknown --item specified ({})".format(self.args.item) ) TLog.success("Values successfully written") except: # noqa: E722 self.result.exception() finally: modbus_client.close()
def execute(self): """Execute the test.""" TLog.generic( "Sending Unauthorized command ({}) to Kankun smart plug on ({}) port ({})" .format(self.args.cmd, self.args.rhost, self.args.rport)) op = None print("--cmd ({}) cmd is on? ({})".format(self.args.cmd, (self.args.cmd == "on"))) if self.args.cmd.lower() == "on": op = "open" elif self.args.cmd.lower() == "off": op = "close" else: self.result.setstatus(passed=False, reason="Unknown --cmd ({})".format( self.args.cmd)) return m = self.createmsg(op) ret = None TLog.trydo("Sending {} command: ({})".format(op, m)) # Step 1: Send command and receive the confirmation ID response ret = self.send_recv(self.args.rhost, self.args.rport, m) if ret is None: self.result.setstatus( passed=False, reason="Communication error while sending message({})".format( m), ) return TLog.success("Received response: ({})".format(ret.decode("utf-8"))) # Get the confirmation ID cid = self.get_confirmid(ret) if cid is None: self.result.setstatus( passed=False, reason="Couldn't extract confirmation id from ({})".format( ret), ) return TLog.success("Received Confirmation ID: ({})".format(cid)) m = self.createmsg("confirm", cid) TLog.trydo("Sending confirm command: ({})".format(m)) # Step 2: Send Confirmation command with the confirmation ID and receive ack response ret = self.send_recv(self.args.rhost, self.args.rport, m) if ret is None: self.result.setstatus( passed=False, reason="Communication error while sending message({})".format( m), ) return TLog.success("Received response: ({})".format(ret.decode("utf-8")))
def unlock(self, mac, name=None): """ Unlock the specified Tapplock. Args: mac(str): The BLE address of the Tapplock name(str): The name of the Tapplock as advertised over BLE Returns: Nothing """ device = BlePeripheral() try: TLog.trydo("Unlocking Tapplock ({})".format(mac)) # Get key1 and serial pairing_data = None if self.args.default is False: remote_mac = ":".join(mac.upper().split(":")[::-1]) md5_hash = md5(remote_mac.encode()).hexdigest() # nosec key1 = md5_hash[0:8] serial = md5_hash[16:24] TLog.generic( "(Calculated hash={})(key1={})(serial={})".format( md5_hash, key1, serial ) ) pairing_data = self.PAIRPREXIX + key1 + serial else: TLog.generic( "(default key1={})(default serial={})".format( self.DEFKEY, self.DEFSERIAL ) ) pairing_data = self.DEFPAIR # Calculate the checksum checksum = 0 for byte in bytes.fromhex(pairing_data): checksum = checksum + (byte % 255) checksum_string = "{:04x}".format(checksum) # Create the pairing data pairing_data = pairing_data + checksum_string[2:4] + checksum_string[0:2] device.connect(mac, addrType=ADDR_TYPE_RANDOM) device.writeCharacteristic(self.UNLOCKHNDL, bytes.fromhex(pairing_data)) device.writeCharacteristic(self.UNLOCKHNDL, bytes.fromhex(self.UNLOCKCMD)) self.output_handler(tlogtype=TLog.TRYDO, logkwargs=LOGPRETTY, name=name, addr=device.addr, sent_pair_data=pairing_data, sent_unlock_cmd=self.UNLOCKCMD) 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 execute(self): """Execute the plugin.""" TLog.generic( "Subscribing to topic ({}) on AWS IoT endpoint ({}) on port ({})". format(self.args.topic, self.args.rhost, self.args.rport)) if not self.args.websocket: # As of Christmas eve 2019, only two connection types are available # 1. TLSv1.2 Mutual Authentication # - X.509 certificate-based secured MQTT connection to AWS IoT # 2. Websocket SigV4 # - IAM credential-based secured MQTT connection over Websocket # to AWS IoT # Source: https://s3.amazonaws.com/aws-iot-device-sdk-python-docs/html/index.html if not self.args.privatekey: raise FileNotFoundError("Thing Private Key file not specified") if not self.args.cert: raise FileNotFoundError("Thing Certificate file not specified") thing = None timer = Timer(self.args.timeout) try: thing = AwsMqttClient(self.args.id, useWebsocket=self.args.websocket) thing.easy_config( host=self.args.rhost, port=self.args.rport, use_websocket=self.args.websocket, rootca=self.args.rootca, privatekey=self.args.privatekey, cert=self.args.cert, user=self.args.user, passwd=self.args.passwd, timeout=self.args.timeout, ) if self.args.user and self.args.passwd: TLog.trydo( "Using authentication (username={})(password={})".format( self.args.user, self.args.passwd)) thing.connect() thing.subscribe(self.args.topic, 1, self.subcb) while not timer.is_timeout(): sleep(1) except: # noqa: E722 self.result.exception() finally: if thing: thing.easy_disconnect()
def execute(self): TLog.generic( "Writing data to i2c eeprom at address({}) using device({})". format(self.args.addr, self.args.url)) d = None f = None try: stime = None etime = None data = None saddr = self.args.addr if self.args.rfile: TLog.trydo("Reading data from the file ({})".format( self.args.rfile)) f = open(self.args.rfile, "r+b") data = f.read() f.close() elif self.args.data: data = bytes.fromhex(self.args.data) else: raise AttributeError( "Specify either --data or --rfile (but not both)") d = I2cEepromManager.get_flash_device(self.args.url, self.args.chip, address=self.slaveaddr) TLog.success("(chip size={} bytes)".format(len(d))) ln = len(data) TLog.trydo("Writing {} byte(s) at start address {}".format( ln, saddr)) if self.args.addr + ln > len(d): raise IndexError("Length is out of range of the chip size") stime = time() d.write(saddr, data) etime = time() TLog.success( "wrote {} byte(s) of data from address {}. Time taken {} secs". format(len(data), saddr, round(etime - stime, 2))) except: self.result.exception() finally: I2cEepromManager.close(d)
def execute(self): c = ModbusTcpClient(self.args.rhost, port=self.args.rport) try: # Check what to write to i.e. coils, registers etc if self.args.item < 0 or self.args.item >= len(self.ITEMS): raise AttributeError("Unknown --item specified ({})".format( self.args.item)) if self.args.count < 1: raise AttributeError("Invalid --count specified ({})".format( self.args.count)) TLog.generic( "Sending write command to Modbus Server ({}) on port ({})". format(self.args.rhost, self.args.rport)) TLog.generic("(item={})(address={})(count={})(unit={})".format( self.ITEMS[self.args.item], self.args.address, self.args.count, self.args.unit)) c.connect() if self.args.item == self.COIL: val = True if self.args.value != 0 else False TLog.trydo("Writing value(s) ({})".format(val)) # below r = class pymodbus.bit_write_message.WriteMultipleCoilsResponse r = c.write_coils(self.args.address, [val] * self.args.count, unit=self.args.unit) if r.isError() == True: raise Exception(str(r)) elif self.args.item == self.REG: TLog.trydo("Writing value(s) ({})".format(self.args.value)) # below r = class pymodbus.register_write_message.WriteMultipleRegistersResponse r = c.write_registers(self.args.address, [self.args.value] * self.args.count, unit=self.args.unit) if r.isError() == True: raise Exception(str(r)) else: raise AttributeError("Unknown --item specified ({})".format( self.args.item)) TLog.success("Values successfully written") except: self.result.exception() finally: c.close()
def execute(self): """Execute the test.""" TLog.generic( "Reading data from SPI flash at address({}) using device ({})".format( self.args.addr, self.args.url ) ) device = None try: device = SpiFlashManager.get_flash_device( self.args.url, freq=self.args.freq ) length = self.args.length or (len(device) - self.args.addr) TLog.success( "(chip found={})(chip size={} bytes)(using frequency={})".format( device, len(device), int(device.spi_frequency) ) ) TLog.trydo( "Reading {} bytes from start address {}".format(length, self.args.addr) ) if self.args.addr + length > len(device): raise IndexError("Length is out of range of the chip size") start_time = time() data = device.read(self.args.addr, length) end_time = time() if self.args.wfile: TLog.trydo("Writing data to the file ({})".format(self.args.wfile)) local_file = open(self.args.wfile, "w+b") data.tofile(local_file) local_file.close() else: TLog.success("(data={})".format([hex(x) for x in data])) TLog.success( "Done. Total bytes read ({}) Time taken to read = {} s".format( len(data), round(end_time - start_time, 2) ) ) except: # noqa: E722 self.result.exception() finally: SpiFlashManager.close(device)
def execute(self): """Execute the test.""" TLog.generic( "Writing data to i2c eeprom at address({}) using device({})". format(self.args.addr, self.args.url)) device = None try: start_address = self.args.addr if self.args.rfile: TLog.trydo("Reading data from the file ({})".format( self.args.rfile)) input_file = open(self.args.rfile, "r+b") data = input_file.read() input_file.close() elif self.args.data: data = bytes.fromhex(self.args.data) else: raise AttributeError( "Specify either --data or --rfile (but not both)") device = I2cEepromManager.get_flash_device(self.args.url, self.args.chip, address=self.slaveaddr) TLog.success("(chip size={} bytes)".format(len(device))) length_data = len(data) TLog.trydo("Writing {} byte(s) at start address {}".format( length_data, start_address)) if self.args.addr + length_data > len(device): raise IndexError("Length is out of range of the chip size") start_time = time() device.write(start_address, data) end_time = time() TLog.success( "wrote {} byte(s) of data from address {}. Time taken {} secs". format(len(data), start_address, round(end_time - start_time, 2))) except: # noqa: E722 self.result.exception() finally: I2cEepromManager.close(device)
def execute(self): """Execute the test.""" TLog.generic( "Reading data from SPI flash at address({}) using device ({})".format( self.args.addr, self.args.url ) ) device = None try: device = SpiFlashManager.get_flash_device( self.args.url, freq=self.args.freq ) length = self.args.length or (len(device) - self.args.addr) self.output_handler(chip=device, size=len(device), frequency=int(device.spi_frequency)) TLog.trydo( "Reading {} bytes from start address {}".format(length, self.args.addr) ) if self.args.addr + length > len(device): raise IndexError("Length is out of range of the chip size") start_time = time() data = device.read(self.args.addr, length) end_time = time() if self.args.wfile: TLog.trydo("Writing data to the file ({})".format(self.args.wfile)) local_file = open(self.args.wfile, "w+b") data.tofile(local_file) local_file.close() else: self.output_handler(msg="data: {}".format([hex(x) for x in data]), logkwargs=LOGNO, data=data) self.output_handler(bytes_read=len(data), time_taken_secs=round(end_time - start_time, 2)) except: # noqa: E722 self.result.exception() finally: SpiFlashManager.close(device)
def execute(self): """Execute the test.""" TLog.generic( "Reading data from i2c eeprom at address({}) using device({})". format(self.args.addr, self.args.url)) device = None try: device = I2cEepromManager.get_flash_device(self.args.url, self.args.chip, address=self.slaveaddr) length = self.args.length or (len(device) - self.args.addr) TLog.trydo("Reading {} bytes from start address {}".format( length, self.args.addr)) if self.args.addr + length > len(device): raise IndexError("Length is out of range of the chip size") start_time = time() data = device.read(self.args.addr, length) end_time = time() if self.args.wfile: TLog.trydo("Writing data to the file ({})".format( self.args.wfile)) output_file = open(self.args.wfile, "w+b") output_file.write(data) output_file.close() else: self.output_handler(msg="data: {}".format( [hex(x) for x in data]), logkwargs=LOGNO, data=data) self.output_handler(chip_size=len(device), bytes_read=len(data), time_taken_secs=round(end_time - start_time, 2)) except: # noqa: E722 self.result.exception() finally: I2cEepromManager.close(device)
def execute(self): """Execute the mDNS discovery.""" service_names = list(MDNS_SERVICE_TYPES) if self.args.list: TLog.trydo("Supported Device types") for name in service_names: TLog.success("{}".format(name)) return TLog.generic("Search local network for mDNS enabled devices") if self.args.device: if self.args.device not in service_names: self.result.setstatus(passed=False, reason="Unknown device type specified") return service_names = [self.args.device] cnt = 0 for name in service_names: if self.args.verbose: TLog.trydo("Looking for {} devices".format(name)) details = MdnsDiscovery(name, scan_timeout=self.args.timeout) details.scan() for device in details.devices: cnt += 1 TLog.success("Device {}".format(cnt)) TLog.success(" (name={})".format(device.name)) TLog.success(" (address={})".format(device.address)) TLog.success(" (port={})".format(device.port)) TLog.success(" (server={})".format(device.server)) TLog.success(" (type={})".format(device.type)) TLog.success(" (priority={})".format(device.priority)) TLog.success(" (weight={})".format(device.weight)) TLog.success(" (properties={})".format(device.properties)) TLog.success("") TLog.success("Total devices discovered = {}".format(cnt))
def execute(self): """Execute the test.""" TLog.generic( "Attempting to connect with DICOM server ({}) on port ({})".format( self.args.rhost, self.args.rport)) TLog.generic("Using Calling AET ({}) Called AET ({})".format( self.args.aetscu, self.args.aetscp)) assoc = None try: app_entity = AE(ae_title=self.args.aetscu) app_entity.requested_contexts = VerificationPresentationContexts assoc = app_entity.associate(self.args.rhost, self.args.rport, ae_title=self.args.aetscp) TLog.trydo("Server implementation version name ({})".format( assoc.acceptor.implementation_version_name)) TLog.trydo("Server implementation class UID ({})".format( assoc.acceptor.implementation_class_uid)) if assoc.is_established: data_set = assoc.send_c_echo() if data_set: TLog.success("C-ECHO response status (0x{0:04x})".format( data_set.Status)) else: self.result.setstatus( passed=False, reason="Could not establish association with the server", ) except: # noqa: E722 self.result.exception() finally: if assoc: assoc.release()
def unlock(self, mac): """ Unlock the specified Tapplock. :param mac: The BLE address of the Tapplock :return: """ device = BlePeripheral() try: TLog.trydo("Unlocking Tapplock ({})".format(mac)) # Get key1 and serial pairing_data = None if self.args.default is False: remote_mac = ":".join(mac.upper().split(":")[::-1]) md5_hash = md5(remote_mac.encode()).hexdigest() # nosec key1 = md5_hash[0:8] serial = md5_hash[16:24] TLog.generic("(Calculated hash={})(key1={})(serial={})".format( md5_hash, key1, serial)) pairing_data = self.PAIRPREXIX + key1 + serial else: TLog.generic("(default key1={})(default serial={})".format( self.DEFKEY, self.DEFSERIAL)) pairing_data = self.DEFPAIR # Calculate the checksum checksum = 0 for byte in bytes.fromhex(pairing_data): checksum = checksum + (byte % 255) checksum_string = "{:04x}".format(checksum) # Create the pairing data pairing_data = pairing_data + checksum_string[ 2:4] + checksum_string[0:2] device.connect(mac, addrType=ADDR_TYPE_RANDOM) TLog.trydo("Sending pair data({})".format(pairing_data)) device.writeCharacteristic(self.UNLOCKHNDL, bytes.fromhex(pairing_data)) TLog.trydo("Sending unlock command({})".format(self.UNLOCKCMD)) device.writeCharacteristic(self.UNLOCKHNDL, bytes.fromhex(self.UNLOCKCMD)) finally: device.disconnect()
def execute(self): TLog.generic( "Writing data to spi flash at address({}) using device({})".format( self.args.addr, self.args.url)) d = None try: stime = None etime = None data = None saddr = self.args.addr if self.args.rfile: TLog.trydo("Reading data from the file ({})".format( self.args.rfile)) f = open(self.args.rfile, "r+b") data = f.read() f.close() elif self.args.data: data = bytes.fromhex(self.args.data) else: raise AttributeError( "Specify either --data or --rfile (but not both)") d = SpiFlashManager.get_flash_device(self.args.url, freq=self.args.freq) TLog.success( "(chip found={})(chip size={} bytes)(using frequency={})". format(d, len(d), int(d.spi_frequency))) ln = len(data) eaddr = saddr + ln - 1 TLog.trydo("Writing {} byte(s) at start address {}".format( ln, saddr)) if self.args.addr + ln > len(d): raise IndexError("Length is out of range of the chip size") # We can't write on any arbitrary address for an aritrary length unless it is aligned to the page size # Get erase page size, start/end enclosing page addresses and length esz = d.get_erase_size() spaddr = saddr - saddr % esz epaddr = eaddr + esz - (eaddr % esz) - 1 pln = epaddr - spaddr + 1 TLog.trydo( "Page aligned start address({}) end address({}) lenght({})". format(spaddr, epaddr, pln)) # Backup the data from chip stime = time() tmpdata = d.read(spaddr, pln) etime = time() TLog.success( "Backed up page aligned {} byte(s) from address {}. Time taken {} secs" .format(pln, spaddr, round(etime - stime, 2))) tmpdata = tmpdata.tobytes() # We can only write on erased data # Now erase the enclosing pages (of the start and end addresses) d.unlock() stime = time() d.erase(spaddr, pln) etime = time() TLog.success( "Erased {} byte(s) of data from address {}. Time taken {} secs" .format(pln, spaddr, round(etime - stime, 2))) # Now overwrite with the updated data i.e. backedup data containing the changes wdata = tmpdata[0:saddr % esz] + data + tmpdata[saddr % esz + ln:] stime = time() d.write(spaddr, wdata) etime = time() TLog.success( "wrote {} byte(s) of data from address {}. Time taken {} secs". format(pln, spaddr, round(etime - stime, 2))) except: self.result.exception() finally: SpiFlashManager.close(d)
def execute(self): """Execute the test.""" TLog.generic( "Writing data to SPI flash at address({}) using device ({})". format(self.args.addr, self.args.url)) device = None try: start_address = self.args.addr if self.args.rfile: TLog.trydo("Reading data from the file ({})".format( self.args.rfile)) local_file = open(self.args.rfile, "r+b") data = local_file.read() local_file.close() elif self.args.data: data = bytes.fromhex(self.args.data) else: raise AttributeError( "Specify either --data or --rfile (but not both)") device = SpiFlashManager.get_flash_device(self.args.url, freq=self.args.freq) self.output_handler(chip=device, size=len(device), frequency=int(device.spi_frequency)) data_length = len(data) end_address = start_address + data_length - 1 TLog.trydo("Writing {} byte(s) at start address {}".format( data_length, start_address)) if self.args.addr + data_length > len(device): raise IndexError("Length is out of range of the chip size") # We can't write on any arbitrary address for an arbitrary length # unless it is aligned to the page size # Get erase page size, start/end enclosing page addresses and length esz = device.get_erase_size() spaddr = start_address - start_address % esz epaddr = end_address + esz - (end_address % esz) - 1 pln = epaddr - spaddr + 1 TLog.trydo( "Page aligned start address({}) end address({}) length({})". format(spaddr, epaddr, pln)) # Backup the data from chip start_time = time() tmpdata = device.read(spaddr, pln) end_time = time() self.output_handler(bytes_backedup_page_aligned=pln, from_address=spaddr, time_taken_secs=round(end_time - start_time, 2)) # commenting below line as pyspiflash 0.6.3 read() returns bytes instead # of ByteArray (array) sept 2020 # tmpdata = tmpdata.tobytes() # We can only write on erased data # Now erase the enclosing pages (of the start and end addresses) device.unlock() start_time = time() device.erase(spaddr, pln) end_time = time() self.output_handler(bytes_erased=pln, from_address=spaddr, time_taken_secs=round(end_time - start_time, 2)) # Now overwrite with the updated data i.e. backed up data containing the changes wdata = (tmpdata[0:start_address % esz] + data + tmpdata[start_address % esz + data_length:]) start_time = time() device.write(spaddr, wdata) end_time = time() self.output_handler(bytes_written=pln, from_address=spaddr, time_taken_secs=round(end_time - start_time, 2)) except: # noqa: E722 self.result.exception() finally: SpiFlashManager.close(device)
def execute(self): """Execute the test.""" TLog.generic( "Attempting to search for patient ({}) on DICOM server ({}) on port ({})" .format(self.args.name, self.args.rhost, self.args.rport)) TLog.generic( "Using Calling AET ({}) Called AET ({}) Information model ({})". format(self.args.aetscu, self.args.aetscp, self.args.model)) assoc = None try: app_entity = AE(ae_title=self.args.aetscu) app_entity.requested_contexts = ( QueryRetrievePresentationContexts + BasicWorklistManagementPresentationContexts) data_set = Dataset() data_set.PatientName = self.args.name # May need to move this as cmdline argument for other SOP Class UIDs data_set.QueryRetrieveLevel = "PATIENT" # 0 means assign random port in pynetdicom if self.args.lport != 0: TLog.generic("Using source port number ({})".format( self.args.lport)) if (self.args.lport < 1024) and (os.geteuid() != 0): TLog.fail("Oops! Need to run as root for privileged port") raise ValueError( "Using privileged port ({}) without root privileges". format(self.args.lport)) assoc = app_entity.associate( self.args.rhost, self.args.rport, bind_address=("", self.args.lport), ae_title=self.args.aetscp, ) TLog.trydo("Server implementation version name ({})".format( assoc.acceptor.implementation_version_name)) TLog.trydo("Server implementation class UID ({})".format( assoc.acceptor.implementation_class_uid)) if assoc.is_established: responses = assoc.send_c_find(data_set, query_model=self.args.model) if responses: for (status, identifier) in responses: TLog.success("C-FIND query status: (0x{0:04x})".format( status.Status)) # As per pynetdicom if status is either of below, then responses contain valid identifier # datasets, else None. Ref: pynetdicom/pynetdicom/apps/findscu/findscu.py if status.Status in (0xFF00, 0xFF01): TLog.success( "C-FIND query Identifier: ({})".format( identifier)) else: reason = "Did not receive any response data sets" TLog.fail(reason) self.result.setstatus(passed=False, reason=reason) else: self.result.setstatus( passed=False, reason="Could not establish association with the server", ) except: # noqa: E722 self.result.exception() finally: if assoc: assoc.release()