SYMBOL INDEX (468 symbols across 30 files)

FILE: SHAtter.py
  function generate_payload (line 6) | def generate_payload():
  function exploit (line 16) | def exploit():

FILE: alloc8.py
  function empty_img3 (line 59) | def empty_img3(size):
  function exploit (line 63) | def exploit(nor, version):
  function remove_exploit (line 110) | def remove_exploit(nor):

FILE: checkm8.py
  function libusb1_create_ctrl_transfer (line 10) | def libusb1_create_ctrl_transfer(device, request, timeout):
  function libusb1_async_ctrl_transfer (line 27) | def libusb1_async_ctrl_transfer(device, bmRequestType, bRequest, wValue,...
  function libusb1_no_error_ctrl_transfer (line 47) | def libusb1_no_error_ctrl_transfer(device, bmRequestType, bRequest, wVal...
  function usb_rop_callbacks (line 53) | def usb_rop_callbacks(address, func_gadget, callbacks):
  function asm_arm64_branch (line 74) | def asm_arm64_branch(src, dest):
  function asm_arm64_x7_trampoline (line 83) | def asm_arm64_x7_trampoline(dest):
  function asm_thumb_trampoline (line 88) | def asm_thumb_trampoline(src, dest):
  function prepare_shellcode (line 95) | def prepare_shellcode(name, constants=[]):
  function stall (line 118) | def stall(device):   libusb1_async_ctrl_transfer(device, 0x80, 6, 0x304,...
  function leak (line 119) | def leak(device):    libusb1_no_error_ctrl_transfer(device, 0x80, 6, 0x3...
  function no_leak (line 120) | def no_leak(device): libusb1_no_error_ctrl_transfer(device, 0x80, 6, 0x3...
  function usb_req_stall (line 122) | def usb_req_stall(device):   libusb1_no_error_ctrl_transfer(device,  0x2...
  function usb_req_leak (line 123) | def usb_req_leak(device):    libusb1_no_error_ctrl_transfer(device, 0x80...
  function usb_req_no_leak (line 124) | def usb_req_no_leak(device): libusb1_no_error_ctrl_transfer(device, 0x80...
  class DeviceConfig (line 126) | class DeviceConfig:
    method __init__ (line 127) | def __init__(self, version, cpid, large_leak, overwrite, overwrite_off...
  function payload (line 142) | def payload(cpid):
  function all_exploit_configs (line 429) | def all_exploit_configs():
  function exploit_config (line 462) | def exploit_config(serial_number):
  function exploit (line 474) | def exploit():

FILE: device_platform.py
  class DevicePlatform (line 1) | class DevicePlatform:
    method __init__ (line 2) | def __init__(self, cpid, cprv, scep, arch, srtg, rom_base, rom_size, r...
    method name (line 48) | def name(self):

FILE: dfu.py
  function acquire_device (line 8) | def acquire_device(timeout=5.0, match=None, fatal=True):
  function release_device (line 26) | def release_device(device):
  function reset_counters (line 30) | def reset_counters(device):
  function usb_reset (line 34) | def usb_reset(device):
  function send_data (line 43) | def send_data(device, data):
  function get_data (line 51) | def get_data(device, amount):
  function request_image_validation (line 62) | def request_image_validation(device):

FILE: dfuexec.py
  class PwnedDeviceConfig (line 12) | class PwnedDeviceConfig:
    method __init__ (line 13) | def __init__(self, version, cpid, aes_crypto_cmd, memmove, get_block_d...
  class PwnedDFUDevice (line 98) | class PwnedDFUDevice():
    method __init__ (line 99) | def __init__(self):
    method ecid_string (line 121) | def ecid_string(self):
    method execute (line 129) | def execute(self, cmd, receiveLength):
    method securerom_dump (line 152) | def securerom_dump(self):
    method aes (line 159) | def aes(self, data, action, key):
    method aes_hex (line 168) | def aes_hex(self, hexdata, action, key):
    method read_memory (line 175) | def read_memory(self, address, length):
    method write_memory (line 179) | def write_memory(self, address, data):
    method nor_dump (line 183) | def nor_dump(self, saveBackup):
    method boot_ibss (line 213) | def boot_ibss(self):
    method flash_nor (line 269) | def flash_nor(self, nor):
    method decrypt_keybag (line 290) | def decrypt_keybag(self, keybag):

FILE: image3.py
  class Image3 (line 4) | class Image3:
    method __init__ (line 5) | def __init__(self, data):
    method createImage3FromTags (line 17) | def createImage3FromTags(type, tags):
    method getTags (line 36) | def getTags(self, magic):
    method getKeybag (line 43) | def getKeybag(self):
    method getPayload (line 51) | def getPayload(self):
    method getDecryptedPayload (line 56) | def getDecryptedPayload(self):
    method shrink24KpwnCertificate (line 62) | def shrink24KpwnCertificate(self):
    method newImage3 (line 72) | def newImage3(self, decrypted=True):

FILE: image3_24Kpwn.py
  function exploit (line 6) | def exploit(img3, securerom):
  function remove_exploit (line 30) | def remove_exploit(img3):

FILE: libusbfinder/__init__.py
  class VersionConfig (line 3) | class VersionConfig:
    method __init__ (line 4) | def __init__(self, version, bottle, bottle_sha256, dylib_patches, dyli...
  function apply_patches (line 61) | def apply_patches(binary, patches):
  function libusb1_path_internal (line 66) | def libusb1_path_internal():
  function libusb1_path (line 112) | def libusb1_path():

FILE: limera1n.py
  class DeviceConfig (line 111) | class DeviceConfig:
    method __init__ (line 112) | def __init__(self, version, cpid, exploit_lr, max_size, constants):
  function create_control_transfer (line 126) | def create_control_transfer(device, request, timeout):
  function limera1n_libusb1_async_ctrl_transfer (line 143) | def limera1n_libusb1_async_ctrl_transfer(device, bmRequestType, bRequest...
  function generate_payload (line 158) | def generate_payload(constants, exploit_lr):
  function exploit (line 173) | def exploit():

FILE: nor.py
  class NorData (line 5) | class NorData():
    method __init__ (line 6) | def __init__(self, dump):
    method dump (line 32) | def dump(self):

FILE: recovery.py
  function acquire_device (line 8) | def acquire_device(timeout=10):
  function release_device (line 22) | def release_device(device):
  function send_command (line 26) | def send_command(device, command):
  function send_data (line 30) | def send_data(device, data):

FILE: rmsigchks.py
  class DeviceConfig (line 12) | class DeviceConfig:
    method __init__ (line 13) | def __init__(self, version, cpid, patches):
  function all_exploit_configs (line 18) | def all_exploit_configs():
  function exploit_config (line 47) | def exploit_config(serial_number):
  function main (line 60) | def main():

FILE: rmsigchks_t8015.py
  function makePTE_Page_16K (line 25) | def makePTE_Page_16K(addr):
  function makePTE_Table_16K (line 34) | def makePTE_Table_16K(addr):
  function main (line 41) | def main():

FILE: steaks4uce.py
  class DeviceConfig (line 65) | class DeviceConfig:
    method __init__ (line 66) | def __init__(self, version, constants):
  function generate_shellcode (line 99) | def generate_shellcode(constants):
  function exploit (line 112) | def exploit():

FILE: usb/__init__.py
  function _setup_log (line 54) | def _setup_log():

FILE: usb/_debug.py
  function enable_tracing (line 38) | def enable_tracing(enable):
  function _trace_function_call (line 42) | def _trace_function_call(logger, fname, *args, **named_args):
  function methodtrace (line 51) | def methodtrace(logger):
  function functiontrace (line 66) | def functiontrace(logger):

FILE: usb/_interop.py
  function _next (line 64) | def _next(iter):
  function _update_wrapper (line 75) | def _update_wrapper(wrapper, wrapped):
  function as_array (line 84) | def as_array(data=None):

FILE: usb/_objfinalizer.py
  class _AutoFinalizedObjectBase (line 36) | class _AutoFinalizedObjectBase(object):
    method _finalize_object (line 42) | def _finalize_object(self):
    method __new__ (line 51) | def __new__(cls, *args, **kwargs):
    method _do_finalize_object (line 64) | def _do_finalize_object(self):
    method finalize (line 73) | def finalize(self):
    method __del__ (line 83) | def __del__(self):
  function _do_finalize_object_ref (line 91) | def _do_finalize_object_ref(obj_ref):
  class AutoFinalizedObject (line 107) | class AutoFinalizedObject(_AutoFinalizedObjectBase):
    method __new__ (line 109) | def __new__(cls, *args, **kwargs):
    method finalize (line 142) | def finalize(self):
    method finalize (line 153) | def finalize(self):
  class AutoFinalizedObject (line 151) | class AutoFinalizedObject(_AutoFinalizedObjectBase):
    method __new__ (line 109) | def __new__(cls, *args, **kwargs):
    method finalize (line 142) | def finalize(self):
    method finalize (line 153) | def finalize(self):

FILE: usb/backend/__init__.py
  function _not_implemented (line 80) | def _not_implemented(func):
  class IBackend (line 83) | class IBackend(_objfinalizer.AutoFinalizedObject):
    method enumerate_devices (line 97) | def enumerate_devices(self):
    method get_device_descriptor (line 107) | def get_device_descriptor(self, dev):
    method get_configuration_descriptor (line 119) | def get_configuration_descriptor(self, dev, config):
    method get_interface_descriptor (line 133) | def get_interface_descriptor(self, dev, intf, alt, config):
    method get_endpoint_descriptor (line 149) | def get_endpoint_descriptor(self, dev, ep, intf, alt, config):
    method open_device (line 162) | def open_device(self, dev):
    method close_device (line 174) | def close_device(self, dev_handle):
    method set_configuration (line 182) | def set_configuration(self, dev_handle, config_value):
    method get_configuration (line 192) | def get_configuration(self, dev_handle):
    method set_interface_altsetting (line 203) | def set_interface_altsetting(self, dev_handle, intf, altsetting):
    method claim_interface (line 213) | def claim_interface(self, dev_handle, intf):
    method release_interface (line 226) | def release_interface(self, dev_handle, intf):
    method bulk_write (line 234) | def bulk_write(self, dev_handle, ep, intf, data, timeout):
    method bulk_read (line 249) | def bulk_read(self, dev_handle, ep, intf, buff, timeout):
    method intr_write (line 264) | def intr_write(self, dev_handle, ep, intf, data, timeout):
    method intr_read (line 279) | def intr_read(self, dev_handle, ep, intf, size, timeout):
    method iso_write (line 294) | def iso_write(self, dev_handle, ep, intf, data, timeout):
    method iso_read (line 309) | def iso_read(self, dev_handle, ep, intf, size, timeout):
    method ctrl_transfer (line 324) | def ctrl_transfer(self,
    method clear_halt (line 351) | def clear_halt(self, dev_handle, ep):
    method reset_device (line 355) | def reset_device(self, dev_handle):
    method is_kernel_driver_active (line 359) | def is_kernel_driver_active(self, dev_handle, intf):
    method detach_kernel_driver (line 367) | def detach_kernel_driver(self, dev_handle, intf):
    method attach_kernel_driver (line 375) | def attach_kernel_driver(self, dev_handle, intf):

FILE: usb/backend/libusb0.py
  class _PackPolicy (line 60) | class _PackPolicy(object):
  class _usb_descriptor_header (line 68) | class _usb_descriptor_header(Structure):
  class _usb_string_descriptor (line 73) | class _usb_string_descriptor(Structure):
  class _usb_endpoint_descriptor (line 79) | class _usb_endpoint_descriptor(Structure, _PackPolicy):
  class _usb_interface_descriptor (line 91) | class _usb_interface_descriptor(Structure, _PackPolicy):
  class _usb_interface (line 105) | class _usb_interface(Structure, _PackPolicy):
  class _usb_config_descriptor (line 109) | class _usb_config_descriptor(Structure, _PackPolicy):
  class _usb_device_descriptor (line 122) | class _usb_device_descriptor(Structure, _PackPolicy):
  class _usb_device (line 139) | class _usb_device(Structure, _PackPolicy):
  class _usb_bus (line 142) | class _usb_bus(Structure, _PackPolicy):
  class _DeviceDescriptor (line 165) | class _DeviceDescriptor:
    method __init__ (line 166) | def __init__(self, dev):
  function _load_library (line 191) | def _load_library(find_library=None):
  function _setup_prototypes (line 198) | def _setup_prototypes(lib):
  function _check (line 414) | def _check(ret):
  function _has_iso_transfer (line 433) | def _has_iso_transfer():
  class _LibUSB (line 437) | class _LibUSB(usb.backend.IBackend):
    method enumerate_devices (line 439) | def enumerate_devices(self):
    method get_device_descriptor (line 451) | def get_device_descriptor(self, dev):
    method get_configuration_descriptor (line 455) | def get_configuration_descriptor(self, dev, config):
    method get_interface_descriptor (line 463) | def get_interface_descriptor(self, dev, intf, alt, config):
    method get_endpoint_descriptor (line 475) | def get_endpoint_descriptor(self, dev, ep, intf, alt, config):
    method open_device (line 484) | def open_device(self, dev):
    method close_device (line 488) | def close_device(self, dev_handle):
    method set_configuration (line 492) | def set_configuration(self, dev_handle, config_value):
    method get_configuration (line 496) | def get_configuration(self, dev_handle):
    method set_interface_altsetting (line 516) | def set_interface_altsetting(self, dev_handle, intf, altsetting):
    method claim_interface (line 520) | def claim_interface(self, dev_handle, intf):
    method release_interface (line 524) | def release_interface(self, dev_handle, intf):
    method bulk_write (line 528) | def bulk_write(self, dev_handle, ep, intf, data, timeout):
    method bulk_read (line 536) | def bulk_read(self, dev_handle, ep, intf, buff, timeout):
    method intr_write (line 545) | def intr_write(self, dev_handle, ep, intf, data, timeout):
    method intr_read (line 554) | def intr_read(self, dev_handle, ep, intf, buff, timeout):
    method iso_write (line 563) | def iso_write(self, dev_handle, ep, intf, data, timeout):
    method iso_read (line 569) | def iso_read(self, dev_handle, ep, intf, buff, timeout):
    method ctrl_transfer (line 575) | def ctrl_transfer(self,
    method clear_halt (line 597) | def clear_halt(self, dev_handle, ep):
    method reset_device (line 601) | def reset_device(self, dev_handle):
    method detach_kernel_driver (line 605) | def detach_kernel_driver(self, dev_handle, intf):
    method __write (line 608) | def __write(self, fn, dev_handle, ep, intf, data, timeout):
    method __read (line 619) | def __read(self, fn, dev_handle, ep, intf, buff, timeout):
    method __iso_transfer (line 631) | def __iso_transfer(self, dev_handle, ep, intf, data, timeout):
  function get_backend (line 664) | def get_backend(find_library=None):

FILE: usb/backend/libusb1.py
  function _strerror (line 170) | def _strerror(errcode):
  class _libusb_endpoint_descriptor (line 178) | class _libusb_endpoint_descriptor(Structure):
  class _libusb_interface_descriptor (line 190) | class _libusb_interface_descriptor(Structure):
  class _libusb_interface (line 204) | class _libusb_interface(Structure):
  class _libusb_config_descriptor (line 208) | class _libusb_config_descriptor(Structure):
  class _libusb_device_descriptor (line 221) | class _libusb_device_descriptor(Structure):
  class _libusb_iso_packet_descriptor (line 239) | class _libusb_iso_packet_descriptor(Structure):
  class _libusb_transfer (line 246) | class _libusb_transfer(Structure):
  function _get_iso_packet_list (line 267) | def _get_iso_packet_list(transfer):
  function _load_library (line 273) | def _load_library(find_library=None):
  function _setup_prototypes (line 290) | def _setup_prototypes(lib):
  function _check (line 587) | def _check(ret):
  class _Device (line 600) | class _Device(_objfinalizer.AutoFinalizedObject):
    method __init__ (line 601) | def __init__(self, devid):
    method _finalize_object (line 603) | def _finalize_object(self):
  class _WrapDescriptor (line 608) | class _WrapDescriptor(object):
    method __init__ (line 609) | def __init__(self, desc, obj = None):
    method __getattr__ (line 612) | def __getattr__(self, name):
  class _ConfigDescriptor (line 616) | class _ConfigDescriptor(_objfinalizer.AutoFinalizedObject):
    method __init__ (line 617) | def __init__(self, desc):
    method _finalize_object (line 619) | def _finalize_object(self):
    method __getattr__ (line 621) | def __getattr__(self, name):
  class _DevIterator (line 626) | class _DevIterator(_objfinalizer.AutoFinalizedObject):
    method __init__ (line 627) | def __init__(self, ctx):
    method __iter__ (line 633) | def __iter__(self):
    method _finalize_object (line 636) | def _finalize_object(self):
  class _DeviceHandle (line 639) | class _DeviceHandle(object):
    method __init__ (line 640) | def __init__(self, dev):
  class _IsoTransferHandler (line 645) | class _IsoTransferHandler(_objfinalizer.AutoFinalizedObject):
    method __init__ (line 646) | def __init__(self, dev_handle, ep, buff, timeout):
    method _finalize_object (line 666) | def _finalize_object(self):
    method submit (line 669) | def submit(self, ctx = None):
    method __compute_size_transf_data (line 684) | def __compute_size_transf_data(self):
    method __set_packets_length (line 688) | def __set_packets_length(self, n, packet_length):
    method __callback (line 698) | def __callback(self, transfer):
  class _LibUSB (line 702) | class _LibUSB(usb.backend.IBackend):
    method __init__ (line 704) | def __init__(self, lib):
    method _finalize_object (line 711) | def _finalize_object(self):
    method enumerate_devices (line 716) | def enumerate_devices(self):
    method get_device_descriptor (line 720) | def get_device_descriptor(self, dev):
    method get_configuration_descriptor (line 753) | def get_configuration_descriptor(self, dev, config):
    method get_interface_descriptor (line 764) | def get_interface_descriptor(self, dev, intf, alt, config):
    method get_endpoint_descriptor (line 776) | def get_endpoint_descriptor(self, dev, ep, intf, alt, config):
    method open_device (line 785) | def open_device(self, dev):
    method close_device (line 789) | def close_device(self, dev_handle):
    method set_configuration (line 793) | def set_configuration(self, dev_handle, config_value):
    method get_configuration (line 797) | def get_configuration(self, dev_handle):
    method set_interface_altsetting (line 803) | def set_interface_altsetting(self, dev_handle, intf, altsetting):
    method claim_interface (line 810) | def claim_interface(self, dev_handle, intf):
    method release_interface (line 814) | def release_interface(self, dev_handle, intf):
    method bulk_write (line 818) | def bulk_write(self, dev_handle, ep, intf, data, timeout):
    method bulk_read (line 827) | def bulk_read(self, dev_handle, ep, intf, buff, timeout):
    method intr_write (line 836) | def intr_write(self, dev_handle, ep, intf, data, timeout):
    method intr_read (line 845) | def intr_read(self, dev_handle, ep, intf, buff, timeout):
    method iso_write (line 854) | def iso_write(self, dev_handle, ep, intf, data, timeout):
    method iso_read (line 859) | def iso_read(self, dev_handle, ep, intf, buff, timeout):
    method ctrl_transfer (line 864) | def ctrl_transfer(self,
    method clear_halt (line 888) | def clear_halt(self, dev_handle, ep):
    method reset_device (line 892) | def reset_device(self, dev_handle):
    method is_kernel_driver_active (line 896) | def is_kernel_driver_active(self, dev_handle, intf):
    method detach_kernel_driver (line 901) | def detach_kernel_driver(self, dev_handle, intf):
    method attach_kernel_driver (line 905) | def attach_kernel_driver(self, dev_handle, intf):
    method __write (line 908) | def __write(self, fn, dev_handle, ep, intf, data, timeout):
    method __read (line 924) | def __read(self, fn, dev_handle, ep, intf, buff, timeout):
  function get_backend (line 939) | def get_backend(find_library=None):

FILE: usb/backend/openusb.py
  class _usb_endpoint_desc (line 147) | class _usb_endpoint_desc(Structure):
  class _usb_interface_desc (line 157) | class _usb_interface_desc(Structure):
  class _usb_config_desc (line 168) | class _usb_config_desc(Structure):
  class _usb_device_desc (line 178) | class _usb_device_desc(Structure):
  class _openusb_request_result (line 194) | class _openusb_request_result(Structure):
  class _openusb_ctrl_request (line 198) | class _openusb_ctrl_request(Structure):
    method __init__ (line 199) | def __init__(self):
    class _openusb_ctrl_setup (line 213) | class _openusb_ctrl_setup(Structure):
  class _openusb_intr_request (line 226) | class _openusb_intr_request(Structure):
  class _openusb_bulk_request (line 235) | class _openusb_bulk_request(Structure):
  class _openusb_isoc_pkts (line 243) | class _openusb_isoc_pkts(Structure):
    class _openusb_isoc_packet (line 244) | class _openusb_isoc_packet(Structure):
  class _openusb_isoc_request (line 250) | class _openusb_isoc_request(Structure):
  function _load_library (line 266) | def _load_library(find_library=None):
  function _setup_prototypes (line 274) | def _setup_prototypes(lib):
  function _check (line 502) | def _check(ret):
  class _Context (line 510) | class _Context(_objfinalizer.AutoFinalizedObject):
    method __init__ (line 511) | def __init__(self):
    method _finalize_object (line 514) | def _finalize_object(self):
  class _BusIterator (line 517) | class _BusIterator(_objfinalizer.AutoFinalizedObject):
    method __init__ (line 518) | def __init__(self):
    method __iter__ (line 525) | def __iter__(self):
    method _finalize_object (line 528) | def _finalize_object(self):
  class _DevIterator (line 531) | class _DevIterator(_objfinalizer.AutoFinalizedObject):
    method __init__ (line 532) | def __init__(self, busid):
    method __iter__ (line 540) | def __iter__(self):
    method _finalize_object (line 543) | def _finalize_object(self):
  class _OpenUSB (line 546) | class _OpenUSB(usb.backend.IBackend):
    method enumerate_devices (line 548) | def enumerate_devices(self):
    method get_device_descriptor (line 554) | def get_device_descriptor(self, dev):
    method get_configuration_descriptor (line 569) | def get_configuration_descriptor(self, dev, config):
    method get_interface_descriptor (line 581) | def get_interface_descriptor(self, dev, intf, alt, config):
    method get_endpoint_descriptor (line 595) | def get_endpoint_descriptor(self, dev, ep, intf, alt, config):
    method open_device (line 610) | def open_device(self, dev):
    method close_device (line 616) | def close_device(self, dev_handle):
    method set_configuration (line 620) | def set_configuration(self, dev_handle, config_value):
    method get_configuration (line 624) | def get_configuration(self, dev_handle):
    method set_interface_altsetting (line 630) | def set_interface_altsetting(self, dev_handle, intf, altsetting):
    method claim_interface (line 634) | def claim_interface(self, dev_handle, intf):
    method release_interface (line 638) | def release_interface(self, dev_handle, intf):
    method bulk_write (line 642) | def bulk_write(self, dev_handle, ep, intf, data, timeout):
    method bulk_read (line 652) | def bulk_read(self, dev_handle, ep, intf, buff, timeout):
    method intr_write (line 662) | def intr_write(self, dev_handle, ep, intf, data, timeout):
    method intr_read (line 672) | def intr_read(self, dev_handle, ep, intf, buff, timeout):
    method ctrl_transfer (line 691) | def ctrl_transfer(self,
    method reset_device (line 717) | def reset_device(self, dev_handle):
    method clear_halt (line 721) | def clear_halt(self, dev_handle, ep):
  function get_backend (line 735) | def get_backend(find_library=None):

FILE: usb/control.py
  function _parse_recipient (line 65) | def _parse_recipient(recipient, direction):
  function get_status (line 92) | def get_status(dev, recipient = None):
  function clear_feature (line 111) | def clear_feature(dev, feature, recipient = None):
  function set_feature (line 131) | def set_feature(dev, feature, recipient = None):
  function get_descriptor (line 148) | def get_descriptor(dev, desc_size, desc_type, desc_index, wIndex = 0):
  function set_descriptor (line 175) | def set_descriptor(dev, desc, desc_type, desc_index, wIndex = None):
  function get_configuration (line 201) | def get_configuration(dev):
  function set_configuration (line 221) | def set_configuration(dev, bConfigurationNumber):
  function get_interface (line 229) | def get_interface(dev, bInterfaceNumber):
  function set_interface (line 246) | def set_interface(dev, bInterfaceNumber, bAlternateSetting):

FILE: usb/core.py
  function _set_attr (line 61) | def _set_attr(input, output, fields):
  function _try_get_string (line 65) | def _try_get_string(dev, index, langid = None, default_str_i0 = "",
  function _try_lookup (line 81) | def _try_lookup(table, value, default = ""):
  class _DescriptorInfo (line 91) | class _DescriptorInfo(str):
    method __repr__ (line 94) | def __repr__(self):
  function synchronized (line 97) | def synchronized(f):
  class _ResourceManager (line 107) | class _ResourceManager(object):
    method __init__ (line 108) | def __init__(self, dev, backend):
    method managed_open (line 118) | def managed_open(self):
    method managed_close (line 124) | def managed_close(self):
    method managed_set_configuration (line 130) | def managed_set_configuration(self, device, config):
    method managed_claim_interface (line 158) | def managed_claim_interface(self, device, intf):
    method managed_release_interface (line 171) | def managed_release_interface(self, device, intf):
    method managed_set_interface (line 187) | def managed_set_interface(self, device, intf, alt):
    method setup_request (line 207) | def setup_request(self, device, endpoint):
    method get_interface_and_endpoint (line 221) | def get_interface_and_endpoint(self, device, endpoint_address):
    method get_active_configuration (line 234) | def get_active_configuration(self, device):
    method release_all_interfaces (line 248) | def release_all_interfaces(self, device):
    method dispose (line 259) | def dispose(self, device, close_handle = True):
  class USBError (line 267) | class USBError(IOError):
    method __init__ (line 275) | def __init__(self, strerror, error_code = None, errno = None):
  class NoBackendError (line 286) | class NoBackendError(ValueError):
  class Endpoint (line 290) | class Endpoint(object):
    method __init__ (line 305) | def __init__(self, device, endpoint, interface = 0,
    method __repr__ (line 350) | def __repr__(self):
    method __str__ (line 353) | def __str__(self):
    method write (line 376) | def write(self, data, timeout = None):
    method read (line 389) | def read(self, size_or_buffer, timeout = None):
    method clear_halt (line 404) | def clear_halt(self):
    method _str (line 408) | def _str(self):
  class Interface (line 419) | class Interface(object):
    method __init__ (line 434) | def __init__(self, device, interface = 0,
    method __repr__ (line 480) | def __repr__(self):
    method __str__ (line 483) | def __str__(self):
    method endpoints (line 491) | def endpoints(self):
    method set_altsetting (line 495) | def set_altsetting(self):
    method __iter__ (line 501) | def __iter__(self):
    method __getitem__ (line 511) | def __getitem__(self, index):
    method _str (line 520) | def _str(self):
    method _get_full_descriptor_str (line 530) | def _get_full_descriptor_str(self):
  class Configuration (line 556) | class Configuration(object):
    method __init__ (line 570) | def __init__(self, device, configuration = 0):
    method __repr__ (line 605) | def __repr__(self):
    method __str__ (line 608) | def __str__(self):
    method interfaces (line 614) | def interfaces(self):
    method set (line 618) | def set(self):
    method __iter__ (line 622) | def __iter__(self):
    method __getitem__ (line 633) | def __getitem__(self, index):
    method _str (line 644) | def _str(self):
    method _get_full_descriptor_str (line 649) | def _get_full_descriptor_str(self):
  class Device (line 685) | class Device(_objfinalizer.AutoFinalizedObject):
    method __repr__ (line 721) | def __repr__(self):
    method __str__ (line 724) | def __str__(self):
    method configurations (line 737) | def configurations(self):
    method __init__ (line 741) | def __init__(self, dev, backend):
    method langids (line 804) | def langids(self):
    method serial_number (line 823) | def serial_number(self):
    method product (line 834) | def product(self):
    method manufacturer (line 845) | def manufacturer(self):
    method backend (line 856) | def backend(self):
    method set_configuration (line 860) | def set_configuration(self, configuration = None):
    method get_active_configuration (line 871) | def get_active_configuration(self):
    method set_interface_altsetting (line 877) | def set_interface_altsetting(self, interface = None, alternate_setting...
    method clear_halt (line 904) | def clear_halt(self, ep):
    method reset (line 911) | def reset(self):
    method write (line 918) | def write(self, endpoint, data, timeout = None):
    method read (line 951) | def read(self, endpoint, size_or_buffer, timeout = None):
    method ctrl_transfer (line 997) | def ctrl_transfer(self, bmRequestType, bRequest, wValue=0, wIndex=0,
    method is_kernel_driver_active (line 1053) | def is_kernel_driver_active(self, interface):
    method detach_kernel_driver (line 1066) | def detach_kernel_driver(self, interface):
    method attach_kernel_driver (line 1079) | def attach_kernel_driver(self, interface):
    method __iter__ (line 1091) | def __iter__(self):
    method __getitem__ (line 1096) | def __getitem__(self, index):
    method _finalize_object (line 1100) | def _finalize_object(self):
    method __get_timeout (line 1103) | def __get_timeout(self, timeout):
    method __set_def_tmo (line 1108) | def __set_def_tmo(self, tmo):
    method __get_def_tmo (line 1113) | def __get_def_tmo(self):
    method _str (line 1116) | def _str(self):
    method _get_full_descriptor_str (line 1120) | def _get_full_descriptor_str(self):
  function find (line 1177) | def find(find_all=False, backend = None, custom_match = None, **args):
  function show_devices (line 1273) | def show_devices(verbose=False, **kwargs):

FILE: usb/legacy.py
  class Endpoint (line 98) | class Endpoint(object):
    method __init__ (line 100) | def __init__(self, ep):
  class Interface (line 106) | class Interface(object):
    method __init__ (line 108) | def __init__(self, intf):
  class Configuration (line 117) | class Configuration(object):
    method __init__ (line 119) | def __init__(self, cfg):
  class DeviceHandle (line 135) | class DeviceHandle(_objfinalizer.AutoFinalizedObject):
    method __init__ (line 136) | def __init__(self, dev):
    method _finalize_object (line 140) | def _finalize_object(self):
    method bulkWrite (line 144) | def bulkWrite(self, endpoint, buffer, timeout = 100):
    method bulkRead (line 156) | def bulkRead(self, endpoint, size, timeout = 100):
    method interruptWrite (line 167) | def interruptWrite(self, endpoint, buffer, timeout = 100):
    method interruptRead (line 179) | def interruptRead(self, endpoint, size, timeout = 100):
    method controlMsg (line 190) | def controlMsg(self, requestType, request, buffer, value = 0, index = ...
    method clearHalt (line 213) | def clearHalt(self, endpoint):
    method claimInterface (line 221) | def claimInterface(self, interface):
    method releaseInterface (line 233) | def releaseInterface(self):
    method reset (line 238) | def reset(self):
    method resetEndpoint (line 243) | def resetEndpoint(self, endpoint):
    method setConfiguration (line 251) | def setConfiguration(self, configuration):
    method setAltInterface (line 262) | def setAltInterface(self, alternate):
    method getString (line 273) | def getString(self, index, length, langid = None):
    method getDescriptor (line 285) | def getDescriptor(self, desc_type, desc_index, length, endpoint = -1):
    method detachKernelDriver (line 297) | def detachKernelDriver(self, interface):
  class Device (line 309) | class Device(object):
    method __init__ (line 311) | def __init__(self, dev):
    method open (line 336) | def open(self):
  class Bus (line 343) | class Bus(object):
    method __init__ (line 345) | def __init__(self, devices):
  function busses (line 350) | def busses():

FILE: usb/libloader.py
  class LibraryException (line 51) | class LibraryException(OSError):
  class LibraryNotFoundException (line 54) | class LibraryNotFoundException(LibraryException):
  class NoLibraryCandidatesException (line 57) | class NoLibraryCandidatesException(LibraryNotFoundException):
  class LibraryNotLoadedException (line 60) | class LibraryNotLoadedException(LibraryException):
  class LibraryMissingSymbolsException (line 63) | class LibraryMissingSymbolsException(LibraryException):
  function locate_library (line 67) | def locate_library (candidates, find_library=ctypes.util.find_library):
  function load_library (line 101) | def load_library(lib, name=None, lib_cls=None):
  function load_locate_library (line 130) | def load_locate_library(candidates, cygwin_lib, name,

FILE: usb/util.py
  function endpoint_address (line 101) | def endpoint_address(address):
  function endpoint_direction (line 109) | def endpoint_direction(address):
  function endpoint_type (line 118) | def endpoint_type(bmAttributes):
  function ctrl_direction (line 128) | def ctrl_direction(bmRequestType):
  function build_request_type (line 137) | def build_request_type(direction, type, recipient):
  function create_buffer (line 153) | def create_buffer(length):
  function find_descriptor (line 164) | def find_descriptor(desc, find_all=False, custom_match=None, **args):
  function claim_interface (line 194) | def claim_interface(device, interface):
  function release_interface (line 207) | def release_interface(device, interface):
  function dispose_resources (line 219) | def dispose_resources(device):
  function get_langids (line 235) | def get_langids(dev):
  function get_string (line 285) | def get_string(dev, index, langid = None):

FILE: usbexec.py
  class ExecConfig (line 4) | class ExecConfig:
    method __init__ (line 5) | def __init__(self, info, aes_crypto_cmd):
    method match (line 9) | def match(self, info):
  class PwnedUSBDevice (line 36) | class PwnedUSBDevice():
    method memset (line 37) | def memset(self, address, c, length):          self.command(self.cmd_m...
    method memcpy (line 38) | def memcpy(self, dest, src, length):           self.command(self.cmd_m...
    method read_memory_ptr (line 39) | def read_memory_ptr(self, address):            return struct.unpack('<...
    method read_memory_uint8 (line 40) | def read_memory_uint8(self, address):          return struct.unpack('<...
    method read_memory_uint16 (line 41) | def read_memory_uint16(self, address):         return struct.unpack('<...
    method read_memory_uint32 (line 42) | def read_memory_uint32(self, address):         return struct.unpack('<...
    method read_memory_uint64 (line 43) | def read_memory_uint64(self, address):         return struct.unpack('<...
    method write_memory (line 44) | def write_memory(self, address, data):         self.command(self.cmd_m...
    method write_memory_ptr (line 45) | def write_memory_ptr(self, address, value):    self.write_memory(addre...
    method write_memory_uint8 (line 46) | def write_memory_uint8(self, address, value):  self.write_memory(addre...
    method write_memory_uint16 (line 47) | def write_memory_uint16(self, address, value): self.write_memory(addre...
    method write_memory_uint32 (line 48) | def write_memory_uint32(self, address, value): self.write_memory(addre...
    method write_memory_uint64 (line 49) | def write_memory_uint64(self, address, value): self.write_memory(addre...
    method cmd_arg_type (line 50) | def cmd_arg_type(self):                        return 'Q' if self.plat...
    method cmd_arg_size (line 51) | def cmd_arg_size(self):                        return 8 if self.platfo...
    method cmd_data_offset (line 52) | def cmd_data_offset(self, index):              return 16 + index * sel...
    method cmd_data_address (line 53) | def cmd_data_address(self, index):             return self.load_base()...
    method cmd_memcpy (line 54) | def cmd_memcpy(self, dest, src, length):       return struct.pack('<8s...
    method cmd_memset (line 55) | def cmd_memset(self, address, c, length):      return struct.pack('<8s...
    method load_base (line 57) | def load_base(self):
    method image_base (line 63) | def image_base(self):
    method usb_serial_number (line 69) | def usb_serial_number(self, key):
    method aes (line 79) | def aes(self, data, action, key):
    method read_memory (line 85) | def read_memory(self, address, length):
    method command (line 94) | def command(self, request_data, response_length):
    method execute (line 113) | def execute(self, response_length, *args):
    method __init__ (line 130) | def __init__(self):

FILE: utilities.py
  function apply_patches (line 3) | def apply_patches(binary, patches):
  function aes_decrypt (line 8) | def aes_decrypt(data, iv, key):
  function hex_dump (line 29) | def hex_dump(data, address):