"""

def __init__(self, view):

self._view = view

self._address = 0

self._length = 0

self._function = None

self._instruction = None

if view is not None:

self._project = view.project

def __len__(self):

return self._length

@property

def view(self):

return self._view

@view.setter

def view(self, value):

self._view = value

@property

def address(self):

return self._address

@address.setter

def address(self, value):

self._address = value

@property

def length(self):

return self._length

@length.setter

def length(self, value):

self._length = value

@property

def function(self):

return self._function

@function.setter

def function(self, value):

self._function = value

@property

def instruction(self):

return self._instruction

@instruction.setter

def instruction(self, value):

self._instruction = value

@property

def project(self):

return self._project

@project.setter

def project(self, value):

def __iter__(self):

binaryninja._init_plugins()

count = ctypes.c_ulonglong()

commands = core.BNGetAllPluginCommands(count)

assert commands is not None, "core.BNGetAllPluginCommands returned None"

try:

for i in range(0, count.value):

yield PluginCommand(commands[i])

finally:

"""

_registered_commands = []

def __init__(self, cmd):

self._command = core.BNPluginCommand()

ctypes.memmove(ctypes.byref(self._command), ctypes.byref(cmd), ctypes.sizeof(core.BNPluginCommand))

self._name = str(cmd.name)

self._description = str(cmd.description)

self._type = PluginCommandType(cmd.type)

@staticmethod

def _global_action(action):

try:

action()

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._global_action")

@staticmethod

def _default_action(view, action):

try:

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

action(view_obj)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._default_action")

@staticmethod

def _address_action(view, addr, action):

try:

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

action(view_obj, addr)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._address_action")

@staticmethod

def _range_action(view, addr, length, action):

try:

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

action(view_obj, addr, length)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._range_action")

@staticmethod

def _function_action(view, func, action):

try:

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

func_obj = function.Function(view_obj, core.BNNewFunctionReference(func))

action(view_obj, func_obj)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._function_action")

@staticmethod

def _low_level_il_function_action(view, func, action):

try:

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

owner = function.Function(view_obj, core.BNGetLowLevelILOwnerFunction(func))

func_obj = lowlevelil.LowLevelILFunction(owner.arch, core.BNNewLowLevelILFunctionReference(func), owner)

action(view_obj, func_obj)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._low_level_il_function_action")

@staticmethod

def _low_level_il_instruction_action(view, func, instr, action):

try:

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

owner = function.Function(view_obj, core.BNGetLowLevelILOwnerFunction(func))

func_obj = lowlevelil.LowLevelILFunction(owner.arch, core.BNNewLowLevelILFunctionReference(func), owner)

action(view_obj, func_obj[instr])

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._low_level_il_instruction_action")

@staticmethod

def _medium_level_il_function_action(view, func, action):

try:

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

owner = function.Function(view_obj, core.BNGetMediumLevelILOwnerFunction(func))

func_obj = mediumlevelil.MediumLevelILFunction(

owner.arch, core.BNNewMediumLevelILFunctionReference(func), owner

)

action(view_obj, func_obj)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._medium_level_il_function_action")

@staticmethod

def _medium_level_il_instruction_action(view, func, instr, action):

try:

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

owner = function.Function(view_obj, core.BNGetMediumLevelILOwnerFunction(func))

func_obj = mediumlevelil.MediumLevelILFunction(

owner.arch, core.BNNewMediumLevelILFunctionReference(func), owner

)

action(view_obj, func_obj[instr])

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._medium_level_il_instruction_action")

@staticmethod

def _high_level_il_function_action(view, func, action):

try:

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

owner = function.Function(view_obj, core.BNGetHighLevelILOwnerFunction(func))

func_obj = highlevelil.HighLevelILFunction(owner.arch, core.BNNewHighLevelILFunctionReference(func), owner)

action(view_obj, func_obj)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._high_level_il_function_action")

@staticmethod

def _high_level_il_instruction_action(view, func, instr, action):

try:

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

owner = function.Function(view_obj, core.BNGetHighLevelILOwnerFunction(func))

func_obj = highlevelil.HighLevelILFunction(owner.arch, core.BNNewHighLevelILFunctionReference(func), owner)

action(view_obj, func_obj[instr])

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._high_level_il_instruction_action")

@staticmethod

def _project_action(project, action):

try:

project_obj = Project(handle=core.BNNewProjectReference(project))

action(project_obj)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._project_action")

@staticmethod

def _global_is_valid(is_valid):

try:

if is_valid is None:

return True

return is_valid()

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._global_is_valid")

return False

@staticmethod

def _default_is_valid(view, is_valid):

try:

if is_valid is None:

return True

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

return is_valid(view_obj)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._default_is_valid")

return False

@staticmethod

def _address_is_valid(view, addr, is_valid):

try:

if is_valid is None:

return True

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

return is_valid(view_obj, addr)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._address_is_valid")

return False

@staticmethod

def _range_is_valid(view, addr, length, is_valid):

try:

if is_valid is None:

return True

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

return is_valid(view_obj, addr, length)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._range_is_valid")

return False

@staticmethod

def _function_is_valid(view, func, is_valid):

try:

if is_valid is None:

return True

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

func_obj = function.Function(view_obj, core.BNNewFunctionReference(func))

return is_valid(view_obj, func_obj)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._function_is_valid")

return False

@staticmethod

def _low_level_il_function_is_valid(view, func, is_valid):

try:

if is_valid is None:

return True

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

owner = function.Function(view_obj, core.BNGetLowLevelILOwnerFunction(func))

func_obj = lowlevelil.LowLevelILFunction(owner.arch, core.BNNewLowLevelILFunctionReference(func), owner)

return is_valid(view_obj, func_obj)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._low_level_il_function_is_valid")

return False

@staticmethod

def _low_level_il_instruction_is_valid(view, func, instr, is_valid):

try:

if instr == 0xffffffffffffffff:

return False

if is_valid is None:

return True

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

owner = function.Function(view_obj, core.BNGetLowLevelILOwnerFunction(func))

func_obj = lowlevelil.LowLevelILFunction(owner.arch, core.BNNewLowLevelILFunctionReference(func), owner)

return is_valid(view_obj, func_obj[instr])

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._low_level_il_instruction_is_valid")

return False

@staticmethod

def _medium_level_il_function_is_valid(view, func, is_valid):

try:

if is_valid is None:

return True

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

owner = function.Function(view_obj, core.BNGetMediumLevelILOwnerFunction(func))

func_obj = mediumlevelil.MediumLevelILFunction(

owner.arch, core.BNNewMediumLevelILFunctionReference(func), owner

)

return is_valid(view_obj, func_obj)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._medium_level_il_function_is_valid")

return False

@staticmethod

def _medium_level_il_instruction_is_valid(view, func, instr, is_valid):

try:

if instr == 0xffffffffffffffff:

return False

if is_valid is None:

return True

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

owner = function.Function(view_obj, core.BNGetMediumLevelILOwnerFunction(func))

func_obj = mediumlevelil.MediumLevelILFunction(

owner.arch, core.BNNewMediumLevelILFunctionReference(func), owner

)

return is_valid(view_obj, func_obj[instr])

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._medium_level_il_instruction_is_valid")

return False

@staticmethod

def _high_level_il_function_is_valid(view, func, is_valid):

try:

if is_valid is None:

return True

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

owner = function.Function(view_obj, core.BNGetHighLevelILOwnerFunction(func))

func_obj = highlevelil.HighLevelILFunction(owner.arch, core.BNNewHighLevelILFunctionReference(func), owner)

return is_valid(view_obj, func_obj)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._high_level_il_function_is_valid")

return False

@staticmethod

def _high_level_il_instruction_is_valid(view, func, instr, is_valid):

try:

if instr == 0xffffffffffffffff:

return False

if is_valid is None:

return True

file_metadata = filemetadata.FileMetadata(handle=core.BNGetFileForView(view))

view_obj = binaryview.BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view))

owner = function.Function(view_obj, core.BNGetHighLevelILOwnerFunction(func))

func_obj = highlevelil.HighLevelILFunction(owner.arch, core.BNNewHighLevelILFunctionReference(func), owner)

return is_valid(view_obj, func_obj[instr])

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._high_level_il_instruction_is_valid")

return False

@staticmethod

def _project_is_valid(project, is_valid):

try:

if is_valid is None:

return True

project_obj = Project(handle=core.BNNewProjectReference(project))

return is_valid(project_obj)

except Exception:

log_error_for_exception("Unhandled Python exception in PluginCommand._project_is_valid")

return False

@classmethod

def register_global(

cls, name: str, description: str, action: Callable[[], None],

is_valid: Optional[Callable[[], bool]] = None

):

r"""

binaryninja._init_plugins()

action_obj = ctypes.CFUNCTYPE(None, ctypes.c_void_p)(lambda ctxt: cls._global_action(action))

is_valid_obj = ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)(lambda ctxt: cls._global_is_valid(is_valid))

cls._registered_commands.append((action_obj, is_valid_obj))

core.BNRegisterPluginCommandGlobal(name, description, action_obj, is_valid_obj, None)

@classmethod

def register(

cls, name: str, description: str, action: Callable[['binaryview.BinaryView'], None],

is_valid: Optional[Callable[['binaryview.BinaryView'], bool]] = None

):

r"""

binaryninja._init_plugins()

action_obj = ctypes.CFUNCTYPE(None, ctypes.c_void_p,

ctypes.POINTER(core.BNBinaryView

))(lambda ctxt, view: cls._default_action(view, action))

is_valid_obj = ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p,

ctypes.POINTER(core.BNBinaryView

))(lambda ctxt, view: cls._default_is_valid(view, is_valid))

cls._registered_commands.append((action_obj, is_valid_obj))

core.BNRegisterPluginCommand(name, description, action_obj, is_valid_obj, None)

@classmethod

def register_for_address(

cls, name: str, description: str, action: Callable[['binaryview.BinaryView', int], None],

is_valid: Optional[Callable[['binaryview.BinaryView', int], bool]] = None

):

r"""

binaryninja._init_plugins()

action_obj = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(

core.BNBinaryView

), ctypes.c_ulonglong)(lambda ctxt, view, addr: cls._address_action(view, addr, action))

is_valid_obj = ctypes.CFUNCTYPE(

ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.c_ulonglong

)(lambda ctxt, view, addr: cls._address_is_valid(view, addr, is_valid))

cls._registered_commands.append((action_obj, is_valid_obj))

core.BNRegisterPluginCommandForAddress(name, description, action_obj, is_valid_obj, None)

@classmethod

def register_for_range(

cls, name: str, description: str, action: Callable[['binaryview.BinaryView', int, int], None],

is_valid: Optional[Callable[['binaryview.BinaryView', int, int], bool]] = None

):

r"""

binaryninja._init_plugins()

action_obj = ctypes.CFUNCTYPE(

None, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong

)(lambda ctxt, view, addr, length: cls._range_action(view, addr, length, action))

is_valid_obj = ctypes.CFUNCTYPE(

ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong

)(lambda ctxt, view, addr, length: cls._range_is_valid(view, addr, length, is_valid))

cls._registered_commands.append((action_obj, is_valid_obj))

core.BNRegisterPluginCommandForRange(name, description, action_obj, is_valid_obj, None)

@classmethod

def register_for_function(

cls, name: str, description: str, action: Callable[['binaryview.BinaryView', 'function.Function'], None],

is_valid: Optional[Callable[['binaryview.BinaryView', 'function.Function'], bool]] = None

):

r"""

binaryninja._init_plugins()

action_obj = ctypes.CFUNCTYPE(

None, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.POINTER(core.BNFunction)

)(lambda ctxt, view, func: cls._function_action(view, func, action))

is_valid_obj = ctypes.CFUNCTYPE(

ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.POINTER(core.BNFunction)

)(lambda ctxt, view, func: cls._function_is_valid(view, func, is_valid))

cls._registered_commands.append((action_obj, is_valid_obj))

core.BNRegisterPluginCommandForFunction(name, description, action_obj, is_valid_obj, None)

@classmethod

def register_for_low_level_il_function(

cls, name: str, description: str, action: Callable[['binaryview.BinaryView', 'lowlevelil.LowLevelILFunction'],

None],

is_valid: Optional[Callable[['binaryview.BinaryView', 'lowlevelil.LowLevelILFunction'], bool]] = None

):

r"""

binaryninja._init_plugins()

action_obj = ctypes.CFUNCTYPE(

None, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.POINTER(core.BNLowLevelILFunction)

)(lambda ctxt, view, func: cls._low_level_il_function_action(view, func, action))

is_valid_obj = ctypes.CFUNCTYPE(

ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView),

ctypes.POINTER(core.BNLowLevelILFunction)

)(lambda ctxt, view, func: cls._low_level_il_function_is_valid(view, func, is_valid))

cls._registered_commands.append((action_obj, is_valid_obj))

core.BNRegisterPluginCommandForLowLevelILFunction(name, description, action_obj, is_valid_obj, None)

@classmethod

def register_for_low_level_il_instruction(

cls, name: str, description: str, action: Callable[['binaryview.BinaryView', 'lowlevelil.LowLevelILInstruction'],

None],

is_valid: Optional[Callable[['binaryview.BinaryView', 'lowlevelil.LowLevelILInstruction'], bool]] = None

):

r"""

binaryninja._init_plugins()

action_obj = ctypes.CFUNCTYPE(

None, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.POINTER(core.BNLowLevelILFunction),

ctypes.c_ulonglong

)(lambda ctxt, view, func, instr: cls._low_level_il_instruction_action(view, func, instr, action))

is_valid_obj = ctypes.CFUNCTYPE(

ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView),

ctypes.POINTER(core.BNLowLevelILFunction), ctypes.c_ulonglong

)(lambda ctxt, view, func, instr: cls._low_level_il_instruction_is_valid(view, func, instr, is_valid))

cls._registered_commands.append((action_obj, is_valid_obj))

core.BNRegisterPluginCommandForLowLevelILInstruction(name, description, action_obj, is_valid_obj, None)

@classmethod

def register_for_medium_level_il_function(

cls, name: str, description: str, action: Callable[['binaryview.BinaryView', 'mediumlevelil.MediumLevelILFunction'],

None],

is_valid: Optional[Callable[['binaryview.BinaryView', 'mediumlevelil.MediumLevelILFunction'], bool]] = None

):

r"""

binaryninja._init_plugins()

action_obj = ctypes.CFUNCTYPE(

None, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.POINTER(core.BNMediumLevelILFunction)

)(lambda ctxt, view, func: cls._medium_level_il_function_action(view, func, action))

is_valid_obj = ctypes.CFUNCTYPE(

ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView),

ctypes.POINTER(core.BNMediumLevelILFunction)

)(lambda ctxt, view, func: cls._medium_level_il_function_is_valid(view, func, is_valid))

cls._registered_commands.append((action_obj, is_valid_obj))

core.BNRegisterPluginCommandForMediumLevelILFunction(name, description, action_obj, is_valid_obj, None)

@classmethod

def register_for_medium_level_il_instruction(

cls, name: str, description: str,

action: Callable[['binaryview.BinaryView', 'mediumlevelil.MediumLevelILInstruction'], None],

is_valid: Optional[Callable[['binaryview.BinaryView', 'mediumlevelil.MediumLevelILInstruction'], bool]] = None

):

r"""

binaryninja._init_plugins()

action_obj = ctypes.CFUNCTYPE(

None, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.POINTER(core.BNMediumLevelILFunction),

ctypes.c_ulonglong

)(lambda ctxt, view, func, instr: cls._medium_level_il_instruction_action(view, func, instr, action))

is_valid_obj = ctypes.CFUNCTYPE(

ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView),

ctypes.POINTER(core.BNMediumLevelILFunction), ctypes.c_ulonglong

)(lambda ctxt, view, func, instr: cls._medium_level_il_instruction_is_valid(view, func, instr, is_valid))

cls._registered_commands.append((action_obj, is_valid_obj))

core.BNRegisterPluginCommandForMediumLevelILInstruction(name, description, action_obj, is_valid_obj, None)

@classmethod

def register_for_high_level_il_function(

cls, name: str, description: str, action: Callable[['binaryview.BinaryView', 'highlevelil.HighLevelILFunction'],

None],

is_valid: Optional[Callable[['binaryview.BinaryView', 'highlevelil.HighLevelILFunction'], bool]] = None

):

r"""

binaryninja._init_plugins()

action_obj = ctypes.CFUNCTYPE(

None, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.POINTER(core.BNHighLevelILFunction)

)(lambda ctxt, view, func: cls._high_level_il_function_action(view, func, action))

is_valid_obj = ctypes.CFUNCTYPE(

ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView),

ctypes.POINTER(core.BNHighLevelILFunction)

)(lambda ctxt, view, func: cls._high_level_il_function_is_valid(view, func, is_valid))

cls._registered_commands.append((action_obj, is_valid_obj))

core.BNRegisterPluginCommandForHighLevelILFunction(name, description, action_obj, is_valid_obj, None)

@classmethod

def register_for_high_level_il_instruction(

cls, name: str, description: str, action: Callable[['binaryview.BinaryView', 'highlevelil.HighLevelILInstruction'],

None],

is_valid: Optional[Callable[['binaryview.BinaryView', 'highlevelil.HighLevelILInstruction'], bool]] = None

):

r"""

binaryninja._init_plugins()

action_obj = ctypes.CFUNCTYPE(

None, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.POINTER(core.BNHighLevelILFunction),

ctypes.c_ulonglong

)(lambda ctxt, view, func, instr: cls._high_level_il_instruction_action(view, func, instr, action))

is_valid_obj = ctypes.CFUNCTYPE(

ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView),

ctypes.POINTER(core.BNHighLevelILFunction), ctypes.c_ulonglong

)(lambda ctxt, view, func, instr: cls._high_level_il_instruction_is_valid(view, func, instr, is_valid))

cls._registered_commands.append((action_obj, is_valid_obj))

core.BNRegisterPluginCommandForHighLevelILInstruction(name, description, action_obj, is_valid_obj, None)

@classmethod

def register_for_project(

cls, name: str, description: str, action: Callable[['Project'], None],

is_valid: Optional[Callable[['Project'], bool]] = None

):

r"""

binaryninja._init_plugins()

action_obj = ctypes.CFUNCTYPE(None, ctypes.c_void_p,

ctypes.POINTER(core.BNProject

))(lambda ctxt, project: cls._project_action(project, action))

is_valid_obj = ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p,

ctypes.POINTER(core.BNProject

))(

lambda ctxt, project: cls._project_is_valid(project, is_valid))

cls._registered_commands.append((action_obj, is_valid_obj))

core.BNRegisterPluginCommandForProject(name, description, action_obj, is_valid_obj, None)

@classmethod

def get_valid_list(cls, context: PluginCommandContext):

"""Dict of registered plugins"""

commands = list(cls)

result = {}

for cmd in commands:

if cmd.is_valid(context):

result[cmd.name] = cmd

return result

def is_valid(self, context: PluginCommandContext):

if self._command.type == PluginCommandType.ProjectPluginCommand:

if context.project is None:

return False

if not self._command.projectIsValid:

return True

return self._command.projectIsValid(self._command.context, context.project.handle)

elif self._command.type == PluginCommandType.GlobalPluginCommand:

if not self._command.globalIsValid:

return True

return self._command.globalIsValid(self._command.context)

if context.view is None:

return False

if self._command.type == PluginCommandType.DefaultPluginCommand:

if not self._command.defaultIsValid:

return True

return self._command.defaultIsValid(self._command.context, context.view.handle)

elif self._command.type == PluginCommandType.AddressPluginCommand:

if not self._command.addressIsValid:

return True

return self._command.addressIsValid(self._command.context, context.view.handle, context.address)

elif self._command.type == PluginCommandType.RangePluginCommand:

if context.length == 0:

return False

if not self._command.rangeIsValid:

return True

return self._command.rangeIsValid(

self._command.context, context.view.handle, context.address, context.length

)

elif self._command.type == PluginCommandType.FunctionPluginCommand:

if context.function is None:

return False

if not self._command.functionIsValid:

return True

return self._command.functionIsValid(self._command.context, context.view.handle, context.function.handle)

elif self._command.type == PluginCommandType.LowLevelILFunctionPluginCommand:

if context.function is None:

return False

if not self._command.lowLevelILFunctionIsValid:

return True

return self._command.lowLevelILFunctionIsValid(

self._command.context, context.view.handle, context.function.handle

)

elif self._command.type == PluginCommandType.LowLevelILInstructionPluginCommand:

if context.instruction is None:

return False

if not isinstance(context.instruction, lowlevelil.LowLevelILInstruction):

return False

if not self._command.lowLevelILInstructionIsValid:

return True

return self._command.lowLevelILInstructionIsValid(

self._command.context, context.view.handle, context.instruction.function.handle,

context.instruction.instr_index

)

elif self._command.type == PluginCommandType.MediumLevelILFunctionPluginCommand:

if context.function is None:

return False

if not self._command.mediumLevelILFunctionIsValid:

return True

return self._command.mediumLevelILFunctionIsValid(

self._command.context, context.view.handle, context.function.handle

)

elif self._command.type == PluginCommandType.MediumLevelILInstructionPluginCommand:

if context.instruction is None:

return False

if not isinstance(context.instruction, mediumlevelil.MediumLevelILInstruction):

return False

if not self._command.mediumLevelILInstructionIsValid:

return True

return self._command.mediumLevelILInstructionIsValid(

self._command.context, context.view.handle, context.instruction.function.handle,

context.instruction.instr_index

)

elif self._command.type == PluginCommandType.HighLevelILFunctionPluginCommand:

if context.function is None:

return False

if not self._command.highLevelILFunctionIsValid:

return True

return self._command.highLevelILFunctionIsValid(

self._command.context, context.view.handle, context.function.handle

)

elif self._command.type == PluginCommandType.HighLevelILInstructionPluginCommand:

if context.instruction is None:

return False

if not isinstance(context.instruction, highlevelil.HighLevelILInstruction):

return False

if not self._command.highLevelILInstructionIsValid:

return True

return self._command.highLevelILInstructionIsValid(

self._command.context, context.view.handle, context.instruction.function.handle,

context.instruction.instr_index

)

return False

def execute(self, context: PluginCommandContext):

r"""

if not self.is_valid(context):

return

if self._command.type == PluginCommandType.GlobalPluginCommand:

self._command.globalCommand(self._command.context)

elif self._command.type == PluginCommandType.DefaultPluginCommand:

self._command.defaultCommand(self._command.context, context.view.handle)

elif self._command.type == PluginCommandType.AddressPluginCommand:

self._command.addressCommand(self._command.context, context.view.handle, context.address)

elif self._command.type == PluginCommandType.RangePluginCommand:

self._command.rangeCommand(self._command.context, context.view.handle, context.address, context.length)

elif self._command.type == PluginCommandType.FunctionPluginCommand: