diff options
Diffstat (limited to 'python/types.py')
| -rw-r--r-- | python/types.py | 900 |
1 files changed, 532 insertions, 368 deletions
diff --git a/python/types.py b/python/types.py index 944f03d0..e4392434 100644 --- a/python/types.py +++ b/python/types.py @@ -26,8 +26,10 @@ from abc import abstractmethod # Binary Ninja components from . import _binaryninjacore as core -from .enums import (StructureVariant, SymbolType, SymbolBinding, TypeClass, - NamedTypeReferenceClass, ReferenceType, VariableSourceType, TypeReferenceType, MemberAccess, MemberScope) +from .enums import ( + StructureVariant, SymbolType, SymbolBinding, TypeClass, NamedTypeReferenceClass, ReferenceType, VariableSourceType, + TypeReferenceType, MemberAccess, MemberScope +) from . import callingconvention from . import function as _function from . import variable @@ -41,7 +43,7 @@ BoolWithConfidenceType = Union[bool, 'BoolWithConfidence'] OffsetWithConfidenceType = Union[int, 'OffsetWithConfidence'] ParamsType = Union[List['Type'], List['FunctionParameter'], List[Tuple['Type', str]]] MembersType = Union[List['StructureMember'], List['Type'], List[Tuple['Type', str]]] -EnumMembersType = Union[List[Tuple[str,int]], List[str], List['EnumerationMember']] +EnumMembersType = Union[List[Tuple[str, int]], List[str], List['EnumerationMember']] SomeType = Union['TypeBuilder', 'Type'] TypeContainer = Union['binaryview.BinaryView', 'typelibrary.TypeLibrary'] NameSpaceType = Optional[Union[str, List[str], 'NameSpace']] @@ -53,9 +55,10 @@ MemberName = str MemberIndex = int MemberOffset = int + class QualifiedName: - def __init__(self, name:Optional[QualifiedNameType]=None): - self._name:List[str] = [] + def __init__(self, name: Optional[QualifiedNameType] = None): + self._name: List[str] = [] if isinstance(name, str): self._name = [name] elif isinstance(name, bytes): @@ -146,15 +149,15 @@ class QualifiedName: return self._name @name.setter - def name(self, value:List[str]) -> None: + def name(self, value: List[str]) -> None: self._name = value @dataclass(frozen=True) class TypeReferenceSource: - name:QualifiedName - offset:int - ref_type:TypeReferenceType + name: QualifiedName + offset: int + ref_type: TypeReferenceType def __repr__(self): if self.ref_type == TypeReferenceType.DirectTypeReferenceType: @@ -180,14 +183,14 @@ class NameSpace(QualifiedName): return result @staticmethod - def _from_core_struct(name:core.BNNameSpace) -> 'NameSpace': + def _from_core_struct(name: core.BNNameSpace) -> 'NameSpace': result = [] for i in range(0, name.nameCount): result.append(name.name[i].decode("utf-8")) return NameSpace(result) @staticmethod - def get_core_struct(name:Optional[Union[str, List[str], 'NameSpace']]) -> Optional[core.BNNameSpace]: + def get_core_struct(name: Optional[Union[str, List[str], 'NameSpace']]) -> Optional[core.BNNameSpace]: if name is None: return None if isinstance(name, NameSpace): @@ -197,7 +200,7 @@ class NameSpace(QualifiedName): class CoreSymbol: - def __init__(self, handle:core.BNSymbolHandle): + def __init__(self, handle: core.BNSymbolHandle): self._handle = handle def __del__(self): @@ -307,7 +310,9 @@ class Symbol(CoreSymbol): LibraryFunctionSymbol Symbols for external functions outside the library =========================== ============================================================== """ - def __init__(self, sym_type, addr, short_name, full_name=None, raw_name=None, binding=None, namespace=None, ordinal=0): + def __init__( + self, sym_type, addr, short_name, full_name=None, raw_name=None, binding=None, namespace=None, ordinal=0 + ): if isinstance(sym_type, str): sym_type = SymbolType[sym_type] if full_name is None: @@ -324,9 +329,9 @@ class Symbol(CoreSymbol): @dataclass class FunctionParameter: - type:SomeType - name:str = "" - location:Optional['variable.VariableNameAndType'] = None + type: SomeType + name: str = "" + location: Optional['variable.VariableNameAndType'] = None def __repr__(self): if (self.location is not None) and (self.location.name != self.name): @@ -342,8 +347,8 @@ class FunctionParameter: @dataclass(frozen=True) class OffsetWithConfidence: - value:int - confidence:int=core.max_confidence + value: int + confidence: int = core.max_confidence def __int__(self): return self.value @@ -376,11 +381,11 @@ class OffsetWithConfidence: return result @classmethod - def from_core_struct(cls, core_struct:core.BNOffsetWithConfidence) -> 'OffsetWithConfidence': + def from_core_struct(cls, core_struct: core.BNOffsetWithConfidence) -> 'OffsetWithConfidence': return cls(core_struct.value, core_struct.confidence) @staticmethod - def get_core_struct(value:OffsetWithConfidenceType) -> core.BNOffsetWithConfidence: + def get_core_struct(value: OffsetWithConfidenceType) -> core.BNOffsetWithConfidence: if isinstance(value, OffsetWithConfidence): return value._to_core_struct() else: @@ -389,8 +394,8 @@ class OffsetWithConfidence: @dataclass(frozen=True) class BoolWithConfidence: - value:bool - confidence:int=core.max_confidence + value: bool + confidence: int = core.max_confidence def __eq__(self, other): if not isinstance(other, self.__class__): @@ -411,11 +416,11 @@ class BoolWithConfidence: return result @classmethod - def from_core_struct(cls, core_struct:core.BNBoolWithConfidence) -> 'BoolWithConfidence': + def from_core_struct(cls, core_struct: core.BNBoolWithConfidence) -> 'BoolWithConfidence': return cls(core_struct.value, core_struct.confidence) @staticmethod - def get_core_struct(value:BoolWithConfidenceType) -> core.BNBoolWithConfidence: + def get_core_struct(value: BoolWithConfidenceType) -> core.BNBoolWithConfidence: if isinstance(value, BoolWithConfidence): return value._to_core_struct() else: @@ -424,12 +429,12 @@ class BoolWithConfidence: @dataclass class MutableTypeBuilder: - type:'TypeBuilder' - container:TypeContainer - name:QualifiedName - platform:Optional['_platform.Platform'] - confidence:int - user:bool = True + type: 'TypeBuilder' + container: TypeContainer + name: QualifiedName + platform: Optional['_platform.Platform'] + confidence: int + user: bool = True def __enter__(self): return self.type @@ -446,7 +451,10 @@ class MutableTypeBuilder: class TypeBuilder: - def __init__(self, handle:core.BNTypeBuilderHandle, platform:'_platform.Platform'=None, confidence:int=core.max_confidence): + def __init__( + self, handle: core.BNTypeBuilderHandle, platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ): assert isinstance(handle, core.BNTypeBuilderHandle), "handle isn't an instance of BNTypeBuilderHandle" self._handle = handle self.platform = platform @@ -456,12 +464,12 @@ class TypeBuilder: if core is not None: core.BNFreeTypeBuilder(self._handle) - def __eq__(self, other:'TypeBuilder') -> bool: + def __eq__(self, other: 'TypeBuilder') -> bool: if not isinstance(other, TypeBuilder): raise ValueError(f"Unable compare equality of TypeBuilder and {type(other)}") return self.immutable_copy() == other.immutable_copy() - def __ne__(self, other:'TypeBuilder') -> bool: + def __ne__(self, other: 'TypeBuilder') -> bool: return not self.__eq__(other) def __repr__(self): @@ -482,17 +490,13 @@ class TypeBuilder: def immutable_copy(self): Types = { - TypeClass.VoidTypeClass:VoidType, - TypeClass.BoolTypeClass:BoolType, - TypeClass.IntegerTypeClass:IntegerType, - TypeClass.FloatTypeClass:FloatType, - TypeClass.PointerTypeClass:PointerType, - TypeClass.ArrayTypeClass:ArrayType, - TypeClass.FunctionTypeClass:FunctionType, - TypeClass.WideCharTypeClass:WideCharType, - # TypeClass.StructureTypeClass:StructureType, - # TypeClass.EnumerationTypeClass:EnumerationType, - # TypeClass.NamedTypeReferenceClass:NamedTypeReferenceType, + TypeClass.VoidTypeClass: VoidType, TypeClass.BoolTypeClass: BoolType, + TypeClass.IntegerTypeClass: IntegerType, TypeClass.FloatTypeClass: FloatType, + TypeClass.PointerTypeClass: PointerType, TypeClass.ArrayTypeClass: ArrayType, + TypeClass.FunctionTypeClass: FunctionType, TypeClass.WideCharTypeClass: WideCharType, + # TypeClass.StructureTypeClass:StructureType, + # TypeClass.EnumerationTypeClass:EnumerationType, + # TypeClass.NamedTypeReferenceClass:NamedTypeReferenceType, } return Types[self.type_class](self.finalized, self.platform, self.confidence) @@ -505,8 +509,10 @@ class TypeBuilder: return NotImplemented @classmethod - def builder(cls, container:TypeContainer, name:'QualifiedName', user:bool=True, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'MutableTypeBuilder': + def builder( + cls, container: TypeContainer, name: 'QualifiedName', user: bool = True, platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ) -> 'MutableTypeBuilder': return MutableTypeBuilder(cls.create(), container, name, platform, confidence, user) @staticmethod @@ -518,11 +524,13 @@ class TypeBuilder: return BoolBuilder.create() @staticmethod - def char(alternate_name:str="") -> 'CharBuilder': + def char(alternate_name: str = "") -> 'CharBuilder': return CharBuilder.create(alternate_name) @staticmethod - def int(width:_int, sign:BoolWithConfidenceType=BoolWithConfidence(True), altname:str="") -> 'IntegerBuilder': + def int( + width: _int, sign: BoolWithConfidenceType = BoolWithConfidence(True), altname: str = "" + ) -> 'IntegerBuilder': """ ``int`` class method for creating an int Type. :param int width: width of the integer in bytes @@ -532,7 +540,7 @@ class TypeBuilder: return IntegerBuilder.create(width, sign, altname) @staticmethod - def float(width:_int, altname:str="") -> 'FloatBuilder': + def float(width: _int, altname: str = "") -> 'FloatBuilder': """ ``float`` class method for creating floating point Types. :param int width: width of the floating point number in bytes @@ -541,7 +549,7 @@ class TypeBuilder: return FloatBuilder.create(width, altname) @staticmethod - def wide_char(width:_int, altname:str="") -> 'WideCharBuilder': + def wide_char(width: _int, altname: str = "") -> 'WideCharBuilder': """ ``wide_char`` class method for creating wide char Types. :param int width: width of the wide character in bytes @@ -550,39 +558,50 @@ class TypeBuilder: return WideCharBuilder.create(width, altname) @staticmethod - def named_type_from_type(name:QualifiedName, type_class:Optional[NamedTypeReferenceClass]=None) -> 'NamedTypeReferenceBuilder': + def named_type_from_type( + name: QualifiedName, type_class: Optional[NamedTypeReferenceClass] = None + ) -> 'NamedTypeReferenceBuilder': return NamedTypeReferenceBuilder.named_type_from_type(name, type_class) @staticmethod - def named_type_from_type_and_id(type_id:str, name:QualifiedName, type:Optional['Type']=None) -> 'NamedTypeReferenceBuilder': + def named_type_from_type_and_id( + type_id: str, name: QualifiedName, type: Optional['Type'] = None + ) -> 'NamedTypeReferenceBuilder': return NamedTypeReferenceBuilder.named_type_from_type_and_id(type_id, name, type) @staticmethod - def named_type_from_registered_type(view:'binaryview.BinaryView', name:QualifiedName) -> 'NamedTypeReferenceBuilder': + def named_type_from_registered_type( + view: 'binaryview.BinaryView', name: QualifiedName + ) -> 'NamedTypeReferenceBuilder': return NamedTypeReferenceBuilder.named_type_from_registered_type(view, name) @staticmethod - def pointer(arch:'architecture.Architecture', type:'Type', - const:BoolWithConfidenceType=BoolWithConfidence(False), - volatile:BoolWithConfidenceType=BoolWithConfidence(False), - ref_type:ReferenceType=ReferenceType.PointerReferenceType) -> 'PointerBuilder': + def pointer( + arch: 'architecture.Architecture', type: 'Type', const: BoolWithConfidenceType = BoolWithConfidence(False), + volatile: BoolWithConfidenceType = BoolWithConfidence(False), + ref_type: ReferenceType = ReferenceType.PointerReferenceType + ) -> 'PointerBuilder': return PointerBuilder.create(type, arch.address_size, arch, const, volatile, ref_type) @staticmethod - def pointer_of_width(width:_int, type:'Type', - const:BoolWithConfidenceType=BoolWithConfidence(False), - volatile:BoolWithConfidenceType=BoolWithConfidence(False), - ref_type:ReferenceType=ReferenceType.PointerReferenceType) -> 'PointerBuilder': + def pointer_of_width( + width: _int, type: 'Type', const: BoolWithConfidenceType = BoolWithConfidence(False), + volatile: BoolWithConfidenceType = BoolWithConfidence(False), + ref_type: ReferenceType = ReferenceType.PointerReferenceType + ) -> 'PointerBuilder': return PointerBuilder.create(type, width, None, const, volatile, ref_type) @staticmethod - def array(type:'Type', count:_int) -> 'ArrayBuilder': + def array(type: 'Type', count: _int) -> 'ArrayBuilder': return ArrayBuilder.create(type, count) @staticmethod - def function(ret:Optional['Type']=None, params:Optional[ParamsType]=None, calling_convention:'callingconvention.CallingConvention'=None, - variable_arguments:BoolWithConfidenceType=BoolWithConfidence(False), - stack_adjust:OffsetWithConfidenceType=0) -> 'FunctionBuilder': + def function( + ret: Optional['Type'] = None, params: Optional[ParamsType] = None, + calling_convention: 'callingconvention.CallingConvention' = None, + variable_arguments: BoolWithConfidenceType = BoolWithConfidence(False), + stack_adjust: OffsetWithConfidenceType = 0 + ) -> 'FunctionBuilder': """ ``function`` class method for creating an function Type. :param Type ret: return Type of the function @@ -594,29 +613,36 @@ class TypeBuilder: return FunctionBuilder.create(ret, calling_convention, params, variable_arguments, stack_adjust) @staticmethod - def structure(members:Optional[MembersType]=None, packed:_bool=False, type:StructureVariant=StructureVariant.StructStructureType) -> 'StructureBuilder': + def structure( + members: Optional[MembersType] = None, packed: _bool = False, + type: StructureVariant = StructureVariant.StructStructureType + ) -> 'StructureBuilder': return StructureBuilder.create(members, type=type, packed=packed) - + @staticmethod - def union(members:Optional[MembersType]=None, packed:_bool=False) -> 'StructureBuilder': + def union(members: Optional[MembersType] = None, packed: _bool = False) -> 'StructureBuilder': return StructureBuilder.create(members, type=StructureVariant.UnionStructureType, packed=packed) - + @staticmethod - def class_type(members:Optional[MembersType]=None, packed:_bool=False) -> 'StructureBuilder': + def class_type(members: Optional[MembersType] = None, packed: _bool = False) -> 'StructureBuilder': return StructureBuilder.create(members, type=StructureVariant.ClassStructureType, packed=packed) @staticmethod - def enumeration(arch:Optional['architecture.Architecture']=None, members:Optional[List[EnumMembersType]]=None, - width:Optional[_int]=None, sign:BoolWithConfidenceType=BoolWithConfidence(False)) -> 'EnumerationBuilder': + def enumeration( + arch: Optional['architecture.Architecture'] = None, members: Optional[List[EnumMembersType]] = None, + width: Optional[_int] = None, sign: BoolWithConfidenceType = BoolWithConfidence(False) + ) -> 'EnumerationBuilder': return EnumerationBuilder.create(members, width, arch, sign) @staticmethod - def named_type_reference(type_class:NamedTypeReferenceClass, name:QualifiedName, - type_id:Optional[str]=None, alignment:_int=1, width:_int=0, - const:BoolWithConfidenceType=BoolWithConfidence(False), - volatile:BoolWithConfidenceType=BoolWithConfidence(False)) -> 'NamedTypeReferenceBuilder': - return NamedTypeReferenceBuilder.create(type_class, type_id, name, width, alignment, - None, core.max_confidence, const, volatile) + def named_type_reference( + type_class: NamedTypeReferenceClass, name: QualifiedName, type_id: Optional[str] = None, alignment: _int = 1, + width: _int = 0, const: BoolWithConfidenceType = BoolWithConfidence(False), + volatile: BoolWithConfidenceType = BoolWithConfidence(False) + ) -> 'NamedTypeReferenceBuilder': + return NamedTypeReferenceBuilder.create( + type_class, type_id, name, width, alignment, None, core.max_confidence, const, volatile + ) @property def width(self) -> _int: @@ -637,20 +663,24 @@ class TypeBuilder: def const(self) -> BoolWithConfidence: """Whether type is const (read/write)""" result = core.BNIsTypeBuilderConst(self._handle) - return BoolWithConfidence(result.value, confidence = result.confidence) + return BoolWithConfidence(result.value, confidence=result.confidence) @const.setter - def const(self, value:BoolWithConfidenceType) -> None: # type: ignore # We explicitly allow 'set' type to be different than 'get' type + def const( + self, value: BoolWithConfidenceType + ) -> None: # type: ignore # We explicitly allow 'set' type to be different than 'get' type core.BNTypeBuilderSetConst(self._handle, BoolWithConfidence.get_core_struct(value)) @property def volatile(self) -> BoolWithConfidence: """Whether type is volatile (read/write)""" result = core.BNIsTypeBuilderVolatile(self._handle) - return BoolWithConfidence(result.value, confidence = result.confidence) + return BoolWithConfidence(result.value, confidence=result.confidence) @volatile.setter - def volatile(self, value:BoolWithConfidenceType) -> None: # type: ignore # We explicitly allow 'set' type to be different than 'get' type + def volatile( + self, value: BoolWithConfidenceType + ) -> None: # type: ignore # We explicitly allow 'set' type to be different than 'get' type core.BNTypeBuilderSetVolatile(self._handle, BoolWithConfidence.get_core_struct(value)) @property @@ -666,7 +696,7 @@ class TypeBuilder: return Type.create(handle, self.platform, type_conf.confidence) @child.setter - def child(self, value:SomeType) -> None: # type: ignore + def child(self, value: SomeType) -> None: # type: ignore core.BNTypeBuilderSetChildType(self._handle, value.immutable_copy()._to_core_struct()) @property @@ -674,7 +704,7 @@ class TypeBuilder: return core.BNGetTypeBuilderAlternateName(self._handle) @alternate_name.setter - def alternate_name(self, name:str) -> None: + def alternate_name(self, name: str) -> None: core.BNTypeBuilderSetAlternateName(self._handle, name) @property @@ -685,7 +715,7 @@ class TypeBuilder: return core.BNTypeBuilderGetSystemCallNumber(self._handle) @system_call_number.setter - def system_call_number(self, value:int) -> None: + def system_call_number(self, value: int) -> None: core.BNTypeBuilderSetSystemCallNumber(self._handle, True, value) def clear_system_call(self) -> None: @@ -700,13 +730,14 @@ class TypeBuilder: return BoolWithConfidence.from_core_struct(core.BNIsTypeBuilderSigned(self._handle)) @signed.setter - def signed(self, value:BoolWithConfidenceType) -> None: # type: ignore + def signed(self, value: BoolWithConfidenceType) -> None: # type: ignore _value = BoolWithConfidence.get_core_struct(value) core.BNTypeBuilderSetSigned(self._handle, _value) + class VoidBuilder(TypeBuilder): @classmethod - def create(cls, platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'VoidBuilder': + def create(cls, platform: '_platform.Platform' = None, confidence: int = core.max_confidence) -> 'VoidBuilder': handle = core.BNCreateVoidTypeBuilder() assert handle is not None, "core.BNCreateVoidTypeBuilder returned None" return cls(handle, platform, confidence) @@ -714,7 +745,7 @@ class VoidBuilder(TypeBuilder): class BoolBuilder(TypeBuilder): @classmethod - def create(cls, platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'BoolBuilder': + def create(cls, platform: '_platform.Platform' = None, confidence: int = core.max_confidence) -> 'BoolBuilder': handle = core.BNCreateBoolTypeBuilder() assert handle is not None, "core.BNCreateBoolTypeBuilder returned None" return cls(handle, platform, confidence) @@ -722,8 +753,10 @@ class BoolBuilder(TypeBuilder): class IntegerBuilder(TypeBuilder): @classmethod - def create(cls, width:int, sign:BoolWithConfidenceType=True, alternate_name:str="", - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'IntegerBuilder': + def create( + cls, width: int, sign: BoolWithConfidenceType = True, alternate_name: str = "", + platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ) -> 'IntegerBuilder': _sign = BoolWithConfidence.get_core_struct(sign) handle = core.BNCreateIntegerTypeBuilder(width, _sign, alternate_name) assert handle is not None, "core.BNCreateIntegerTypeBuilder returned None" @@ -732,8 +765,9 @@ class IntegerBuilder(TypeBuilder): class CharBuilder(IntegerBuilder): @classmethod - def create(cls, alternate_name:str="", - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'CharBuilder': + def create( + cls, alternate_name: str = "", platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ) -> 'CharBuilder': handle = core.BNCreateIntegerTypeBuilder(1, BoolWithConfidence.get_core_struct(False), alternate_name) assert handle is not None, "BNCreateIntegerTypeBuilder returned None" return cls(handle, platform, confidence) @@ -741,8 +775,10 @@ class CharBuilder(IntegerBuilder): class FloatBuilder(TypeBuilder): @classmethod - def create(cls, width:int, alternate_name:str="", - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'FloatBuilder': + def create( + cls, width: int, alternate_name: str = "", platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ) -> 'FloatBuilder': handle = core.BNCreateFloatTypeBuilder(width, alternate_name) assert handle is not None, "core.BNCreateFloatTypeBuilder returned None" return cls(handle, platform, confidence) @@ -750,8 +786,10 @@ class FloatBuilder(TypeBuilder): class WideCharBuilder(TypeBuilder): @classmethod - def create(cls, width:int, alternate_name:str="", - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'WideCharBuilder': + def create( + cls, width: int, alternate_name: str = "", platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ) -> 'WideCharBuilder': handle = core.BNCreateWideCharTypeBuilder(width, alternate_name) assert handle is not None, "core.BNCreateWideCharTypeBuilder returned None" return cls(handle, platform, confidence) @@ -759,10 +797,12 @@ class WideCharBuilder(TypeBuilder): class PointerBuilder(TypeBuilder): @classmethod - def create(cls, type:'Type', width:int=4, arch:Optional['architecture.Architecture']=None, - const:BoolWithConfidenceType=False, volatile:BoolWithConfidenceType=False, - ref_type:ReferenceType=ReferenceType.PointerReferenceType, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'PointerBuilder': + def create( + cls, type: 'Type', width: int = 4, arch: Optional['architecture.Architecture'] = None, + const: BoolWithConfidenceType = False, volatile: BoolWithConfidenceType = False, + ref_type: ReferenceType = ReferenceType.PointerReferenceType, platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ) -> 'PointerBuilder': assert width is not None or arch is not None, "Must specify either a width or architecture when creating a pointer" _width = width if arch is not None: @@ -770,8 +810,7 @@ class PointerBuilder(TypeBuilder): _const = BoolWithConfidence.get_core_struct(const) _volatile = BoolWithConfidence.get_core_struct(volatile) - handle = core.BNCreatePointerTypeBuilderOfWidth(_width, type._to_core_struct(), _const, - _volatile, ref_type) + handle = core.BNCreatePointerTypeBuilderOfWidth(_width, type._to_core_struct(), _const, _volatile, ref_type) assert handle is not None, "BNCreatePointerTypeBuilderOfWidth returned None" return cls(handle, platform, confidence) @@ -786,8 +825,10 @@ class PointerBuilder(TypeBuilder): class ArrayBuilder(TypeBuilder): @classmethod - def create(cls, type:SomeType, element_count:int, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'ArrayBuilder': + def create( + cls, type: SomeType, element_count: int, platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ) -> 'ArrayBuilder': handle = core.BNCreateArrayTypeBuilder(type._to_core_struct(), element_count) assert handle is not None, "BNCreateArrayTypeBuilder returned None" return cls(handle, platform, confidence) @@ -803,10 +844,12 @@ class ArrayBuilder(TypeBuilder): class FunctionBuilder(TypeBuilder): @classmethod - def create(cls, return_type:Optional[SomeType]=None, calling_convention:Optional['callingconvention.CallingConvention']=None, - params:Optional[ParamsType]=None, var_args:BoolWithConfidenceType=False, - stack_adjust:OffsetWithConfidenceType=0, platform:'_platform.Platform'=None, - confidence:int=core.max_confidence) -> 'FunctionBuilder': + def create( + cls, return_type: Optional[SomeType] = None, + calling_convention: Optional['callingconvention.CallingConvention'] = None, params: Optional[ParamsType] = None, + var_args: BoolWithConfidenceType = False, stack_adjust: OffsetWithConfidenceType = 0, + platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ) -> 'FunctionBuilder': param_buf = FunctionBuilder._to_core_struct(params) if return_type is None: ret_conf = Type.void()._to_core_struct() @@ -825,8 +868,9 @@ class FunctionBuilder(TypeBuilder): stack_adjust_conf = OffsetWithConfidence.get_core_struct(stack_adjust) if params is None: params = [] - handle = core.BNCreateFunctionTypeBuilder(ret_conf, conv_conf, param_buf, len(params), - vararg_conf, stack_adjust_conf) + handle = core.BNCreateFunctionTypeBuilder( + ret_conf, conv_conf, param_buf, len(params), vararg_conf, stack_adjust_conf + ) assert handle is not None, "BNCreateFunctionTypeBuilder returned None" return cls(handle, platform, confidence) @@ -839,10 +883,10 @@ class FunctionBuilder(TypeBuilder): return self.child.mutable_copy() @return_value.setter - def return_value(self, value:SomeType) -> None: # type: ignore + def return_value(self, value: SomeType) -> None: # type: ignore self.child = value - def append(self, type:Union[SomeType, FunctionParameter], name:str=""): + def append(self, type: Union[SomeType, FunctionParameter], name: str = ""): if isinstance(type, FunctionParameter): self.parameters = [*self.parameters, type] else: @@ -858,7 +902,7 @@ class FunctionBuilder(TypeBuilder): return BoolWithConfidence.from_core_struct(core.BNFunctionTypeBuilderCanReturn(self._handle)) @can_return.setter - def can_return(self, value:BoolWithConfidenceType) -> None: # type: ignore + def can_return(self, value: BoolWithConfidenceType) -> None: # type: ignore core.BNSetFunctionTypeBuilderCanReturn(self._handle, BoolWithConfidence.get_core_struct(value)) @property @@ -873,17 +917,21 @@ class FunctionBuilder(TypeBuilder): assert params is not None, "core.BNGetTypeBuilderParameters returned None" result = [] for i in range(0, count.value): - param_type = Type.create(core.BNNewTypeReference(params[i].type), platform = self.platform, confidence = params[i].typeConfidence) + param_type = Type.create( + core.BNNewTypeReference(params[i].type), platform=self.platform, confidence=params[i].typeConfidence + ) if params[i].defaultLocation: param_location = None else: name = params[i].name - if (params[i].location.type == VariableSourceType.RegisterVariableSourceType) and (self.platform is not None): + if (params[i].location.type + == VariableSourceType.RegisterVariableSourceType) and (self.platform is not None): name = self.platform.arch.get_reg_name(params[i].location.storage) elif params[i].location.type == VariableSourceType.StackVariableSourceType: name = "arg_%x" % params[i].location.storage - param_location = variable.VariableNameAndType(params[i].location.type, params[i].location.index, - params[i].location.storage, name, param_type) + param_location = variable.VariableNameAndType( + params[i].location.type, params[i].location.index, params[i].location.storage, name, param_type + ) result.append(FunctionParameter(param_type, params[i].name, param_location)) core.BNFreeTypeParameterList(params, count.value) return result @@ -893,7 +941,7 @@ class FunctionBuilder(TypeBuilder): return BoolWithConfidence.from_core_struct(core.BNTypeBuilderHasVariableArguments(self._handle)) @staticmethod - def _to_core_struct(params:Optional[ParamsType]=None): + def _to_core_struct(params: Optional[ParamsType] = None): if params is None: params = [] param_buf = (core.BNFunctionParameter * len(params))() @@ -920,7 +968,9 @@ class FunctionBuilder(TypeBuilder): elif isinstance(param, tuple): name, _type = param assert isinstance(name, str), f"Conversion from unsupported function parameter type {type(param)}" - assert isinstance(_type, (Type, TypeBuilder)), f"Conversion from unsupported function parameter type {type(param)}" + assert isinstance( + _type, (Type, TypeBuilder) + ), f"Conversion from unsupported function parameter type {type(param)}" core_param.name = name core_param.type = _type.handle core_param.typeConfidence = _type.confidence @@ -930,31 +980,32 @@ class FunctionBuilder(TypeBuilder): return param_buf @parameters.setter - def parameters(self, params:List[FunctionParameter]) -> None: + def parameters(self, params: List[FunctionParameter]) -> None: core.BNSetFunctionTypeBuilderParameters(self._handle, FunctionBuilder._to_core_struct(params), len(params)) @dataclass class StructureMember: - type:'Type' - name:str - offset:int - access:MemberAccess = MemberAccess.NoAccess - scope:MemberScope = MemberScope.NoScope + type: 'Type' + name: str + offset: int + access: MemberAccess = MemberAccess.NoAccess + scope: MemberScope = MemberScope.NoScope def __repr__(self): if len(self.name) == 0: return f"<member: {self.type}, offset {self.offset:#x}>" - return f"<{self.type.get_string_before_name()} {self.name}{self.type.get_string_after_name()}" + \ - f", offset {self.offset:#x}>" + return f"<{self.type.get_string_before_name()} {self.name}{self.type.get_string_after_name()}, offset {self.offset:#x}>" def __len__(self): return len(self.type) class StructureBuilder(TypeBuilder): - def __init__(self, handle:core.BNTypeBuilderHandle, builder_handle:core.BNStructureBuilderHandle, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence): + def __init__( + self, handle: core.BNTypeBuilderHandle, builder_handle: core.BNStructureBuilderHandle, + platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ): super(StructureBuilder, self).__init__(handle, platform, confidence) assert builder_handle is not None, "Can't instantiate Structure with builder_handle set to None" self.builder_handle = builder_handle @@ -966,12 +1017,18 @@ class StructureBuilder(TypeBuilder): for member in members: if isinstance(member, Tuple): _type, _name = member - core.BNAddStructureBuilderMember(structure_builder_handle, _type._to_core_struct(), _name, MemberAccess.NoAccess, MemberScope.NoScope) + core.BNAddStructureBuilderMember( + structure_builder_handle, _type._to_core_struct(), _name, MemberAccess.NoAccess, MemberScope.NoScope + ) elif isinstance(member, StructureMember): - core.BNAddStructureBuilderMemberAtOffset(structure_builder_handle, member.type._to_core_struct(), - member.name, member.offset, False, member.access, member.scope) + core.BNAddStructureBuilderMemberAtOffset( + structure_builder_handle, member.type._to_core_struct(), member.name, member.offset, False, + member.access, member.scope + ) elif isinstance(member, (TypeBuilder, Type)): - core.BNAddStructureBuilderMember(structure_builder_handle, member._to_core_struct(), "", MemberAccess.NoAccess, MemberScope.NoScope) + core.BNAddStructureBuilderMember( + structure_builder_handle, member._to_core_struct(), "", MemberAccess.NoAccess, MemberScope.NoScope + ) else: raise ValueError(f"Structure member type {member} not supported") @@ -979,11 +1036,11 @@ class StructureBuilder(TypeBuilder): StructureBuilder._add_members_to_builder(self.builder_handle, members) @classmethod - def create(cls, members:MembersType=None, - type:StructureVariant=StructureVariant.StructStructureType, - packed:bool=False, - width:Optional[int]=None, platform:'_platform.Platform'=None, - confidence:int=core.max_confidence) -> 'StructureBuilder': + def create( + cls, members: MembersType = None, type: StructureVariant = StructureVariant.StructStructureType, + packed: bool = False, width: Optional[int] = None, platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ) -> 'StructureBuilder': structure_builder_handle = core.BNCreateStructureBuilderWithOptions(type, packed) assert structure_builder_handle is not None, "core.BNCreateStructureBuilderWithOptions returned None" if width is not None: @@ -1011,14 +1068,18 @@ class StructureBuilder(TypeBuilder): result = [] for i in range(0, count.value): t = Type.create(core.BNNewTypeReference(members[i].type), confidence=members[i].typeConfidence) - result.append(StructureMember(t, members[i].name, members[i].offset, - MemberAccess(members[i].access), MemberScope(members[i].scope))) + result.append( + StructureMember( + t, members[i].name, members[i].offset, MemberAccess(members[i].access), + MemberScope(members[i].scope) + ) + ) return result finally: core.BNFreeStructureMemberList(members, count.value) @members.setter - def members(self, members:MembersType=None) -> None: + def members(self, members: MembersType = None) -> None: count = len(self.members) # remove members in reverse order for i in reversed(range(count)): @@ -1030,7 +1091,7 @@ class StructureBuilder(TypeBuilder): return core.BNIsStructureBuilderPacked(self.builder_handle) @packed.setter - def packed(self, value:bool) -> None: + def packed(self, value: bool) -> None: core.BNSetStructureBuilderPacked(self.builder_handle, value) @property @@ -1038,7 +1099,7 @@ class StructureBuilder(TypeBuilder): return core.BNGetStructureBuilderAlignment(self.builder_handle) @alignment.setter - def alignment(self, value:int) -> None: + def alignment(self, value: int) -> None: core.BNSetStructureBuilderAlignment(self.builder_handle, value) @property @@ -1046,7 +1107,7 @@ class StructureBuilder(TypeBuilder): return core.BNGetStructureBuilderWidth(self.builder_handle) @width.setter - def width(self, value:int) -> None: + def width(self, value: int) -> None: core.BNSetStructureBuilderWidth(self.builder_handle, value) @property @@ -1058,17 +1119,19 @@ class StructureBuilder(TypeBuilder): return StructureVariant(core.BNGetStructureBuilderType(self.builder_handle)) @type.setter - def type(self, value:StructureVariant) -> None: + def type(self, value: StructureVariant) -> None: core.BNSetStructureBuilderType(self.builder_handle, value) - def __getitem__(self, name:str) -> Optional[StructureMember]: + def __getitem__(self, name: str) -> Optional[StructureMember]: member = core.BNGetStructureBuilderMemberByName(self.builder_handle, name) if member is None: return None try: - return StructureMember(Type(core.BNNewTypeReference(member.contents.type), - confidence=member.contents.typeConfidence), member.contents.name, member.contents.offset, - MemberAccess(member.contents.access), MemberScope(member.contents.scope)) + return StructureMember( + Type(core.BNNewTypeReference(member.contents.type), confidence=member.contents.typeConfidence), + member.contents.name, member.contents.offset, MemberAccess(member.contents.access), + MemberScope(member.contents.scope) + ) finally: core.BNFreeStructureMember(member) @@ -1079,55 +1142,63 @@ class StructureBuilder(TypeBuilder): def __len__(self) -> int: return self.width - def member_at_offset(self, offset:int) -> Optional[StructureMember]: + def member_at_offset(self, offset: int) -> Optional[StructureMember]: for member in self.members: if member.offset == offset: return member return None - def index_by_name(self, name:MemberName) -> Optional[MemberIndex]: + def index_by_name(self, name: MemberName) -> Optional[MemberIndex]: for i, member in enumerate(self.members): if member.name == name: return i return None - def index_by_offset(self, offset:MemberOffset) -> Optional[MemberIndex]: + def index_by_offset(self, offset: MemberOffset) -> Optional[MemberIndex]: for i, member in enumerate(self.members): if member.offset == offset: return i return None - def replace(self, index:int, type:SomeType, name:str="", overwrite_existing:bool=True): - core.BNReplaceStructureBuilderMember(self.builder_handle, index, - type._to_core_struct(), name, overwrite_existing) + def replace(self, index: int, type: SomeType, name: str = "", overwrite_existing: bool = True): + core.BNReplaceStructureBuilderMember( + self.builder_handle, index, type._to_core_struct(), name, overwrite_existing + ) - def remove(self, index:int): + def remove(self, index: int): core.BNRemoveStructureBuilderMember(self.builder_handle, index) - def insert(self, offset:int, type:SomeType, name:str="", overwrite_existing:bool=True, - access:MemberAccess=MemberAccess.NoAccess, scope:MemberScope=MemberScope.NoScope): - core.BNAddStructureBuilderMemberAtOffset(self.builder_handle, - type._to_core_struct(), name, offset, overwrite_existing, access, scope) + def insert( + self, offset: int, type: SomeType, name: str = "", overwrite_existing: bool = True, + access: MemberAccess = MemberAccess.NoAccess, scope: MemberScope = MemberScope.NoScope + ): + core.BNAddStructureBuilderMemberAtOffset( + self.builder_handle, type._to_core_struct(), name, offset, overwrite_existing, access, scope + ) - def append(self, type:SomeType, name:MemberName="", access:MemberAccess=MemberAccess.NoAccess, - scope:MemberScope=MemberScope.NoScope) -> 'StructureBuilder': + def append( + self, type: SomeType, name: MemberName = "", access: MemberAccess = MemberAccess.NoAccess, + scope: MemberScope = MemberScope.NoScope + ) -> 'StructureBuilder': # appends a member at the end of the structure growing the structure - core.BNAddStructureBuilderMember(self.builder_handle, - type._to_core_struct(), name, access, scope) + core.BNAddStructureBuilderMember(self.builder_handle, type._to_core_struct(), name, access, scope) return self - def add_member_at_offset(self, name:MemberName, type:SomeType, offset:MemberOffset, overwrite_existing:bool=True, - access:MemberAccess=MemberAccess.NoAccess, scope:MemberScope=MemberScope.NoScope) -> 'StructureBuilder': + def add_member_at_offset( + self, name: MemberName, type: SomeType, offset: MemberOffset, overwrite_existing: bool = True, + access: MemberAccess = MemberAccess.NoAccess, scope: MemberScope = MemberScope.NoScope + ) -> 'StructureBuilder': # Adds structure member to the given offset optionally clearing any members within the range offset-offset+len(type) - core.BNAddStructureBuilderMemberAtOffset(self.builder_handle, type._to_core_struct(), name, - offset, overwrite_existing, access, scope) + core.BNAddStructureBuilderMemberAtOffset( + self.builder_handle, type._to_core_struct(), name, offset, overwrite_existing, access, scope + ) return self @dataclass(frozen=True) class EnumerationMember: - name:str - value:Optional[int] = None + name: str + value: Optional[int] = None def __repr__(self): value = f"{self.value:#x}" if self.value is not None else "auto()" @@ -1138,16 +1209,20 @@ class EnumerationMember: class EnumerationBuilder(TypeBuilder): - def __init__(self, handle:core.BNTypeBuilderHandle, enum_builder_handle:core.BNEnumerationBuilderHandle, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence): + def __init__( + self, handle: core.BNTypeBuilderHandle, enum_builder_handle: core.BNEnumerationBuilderHandle, + platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ): super(EnumerationBuilder, self).__init__(handle, platform, confidence) assert isinstance(enum_builder_handle, core.BNEnumerationBuilderHandle) self.enum_builder_handle = enum_builder_handle @classmethod - def create(cls, members:Optional[List[EnumMembersType]]=None, width:Optional[int]=None, - arch:Optional['architecture.Architecture']=None, sign:BoolWithConfidenceType=False, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'EnumerationBuilder': + def create( + cls, members: Optional[List[EnumMembersType]] = None, width: Optional[int] = None, + arch: Optional['architecture.Architecture'] = None, sign: BoolWithConfidenceType = False, + platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ) -> 'EnumerationBuilder': if members is None: members = [] @@ -1182,19 +1257,21 @@ class EnumerationBuilder(TypeBuilder): result = [] try: for i in range(count.value): - result.append(EnumerationMember(members[i].name, members[i].value if not members[i].isDefault else None)) + result.append( + EnumerationMember(members[i].name, members[i].value if not members[i].isDefault else None) + ) return result finally: core.BNFreeEnumerationMemberList(members, count.value) @members.setter - def members(self, members:List[EnumMembersType]) -> None: # type: ignore + def members(self, members: List[EnumMembersType]) -> None: # type: ignore for i in reversed(range(len(self.members))): self.remove(i) EnumerationBuilder._add_members(self.enum_builder_handle, members) @staticmethod - def _add_members(enum_builder_handle, members:List[EnumMembersType]): + def _add_members(enum_builder_handle, members: List[EnumMembersType]): for i, member in enumerate(members): value = None if isinstance(member, Tuple): @@ -1210,16 +1287,15 @@ class EnumerationBuilder(TypeBuilder): else: core.BNAddEnumerationBuilderMemberWithValue(enum_builder_handle, name, value) - - def append(self, name:str, value:Optional[int]=None) -> 'EnumerationBuilder': + def append(self, name: str, value: Optional[int] = None) -> 'EnumerationBuilder': EnumerationBuilder._add_members(self.enum_builder_handle, [EnumerationMember(name, value)]) return self - def remove(self, i:int) -> 'EnumerationBuilder': + def remove(self, i: int) -> 'EnumerationBuilder': core.BNRemoveEnumerationBuilderMember(self.enum_builder_handle, i) return self - def replace(self, i:int, name:str, value:Optional[int]=None) -> 'EnumerationBuilder': + def replace(self, i: int, name: str, value: Optional[int] = None) -> 'EnumerationBuilder': core.BNReplaceEnumerationBuilderMember(self.enum_builder_handle, i, name, value) return self @@ -1227,7 +1303,7 @@ class EnumerationBuilder(TypeBuilder): for member in self.members: yield member - def __getitem__(self, value:Union[str, int, slice]): + def __getitem__(self, value: Union[str, int, slice]): if isinstance(value, str): for member in self.members: if member.name == value: @@ -1240,7 +1316,7 @@ class EnumerationBuilder(TypeBuilder): else: raise ValueError(f"Incompatible type {type(value)} for __getitem__") - def __setitem__(self, item:Union[str, int], value:Union[Optional[int], EnumerationMember]): + def __setitem__(self, item: Union[str, int], value: Union[Optional[int], EnumerationMember]): if isinstance(item, str): for i, member in enumerate(self.members): if member.name == item: @@ -1252,25 +1328,33 @@ class EnumerationBuilder(TypeBuilder): class NamedTypeReferenceBuilder(TypeBuilder): - def __init__(self, handle:core.BNTypeBuilderHandle, ntr_builder_handle:core.BNNamedTypeReferenceBuilderHandle, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence): + def __init__( + self, handle: core.BNTypeBuilderHandle, ntr_builder_handle: core.BNNamedTypeReferenceBuilderHandle, + platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ): assert ntr_builder_handle is not None, "Failed to construct NameTypeReference" assert handle is not None, "Failed to construct NameTypeReference" - assert isinstance(ntr_builder_handle, core.BNNamedTypeReferenceBuilderHandle), "Failed to construct NameTypeReference" + assert isinstance( + ntr_builder_handle, core.BNNamedTypeReferenceBuilderHandle + ), "Failed to construct NameTypeReference" super(NamedTypeReferenceBuilder, self).__init__(handle, platform, confidence) self.ntr_builder_handle = ntr_builder_handle @classmethod - def create(cls, type_class:NamedTypeReferenceClass=NamedTypeReferenceClass.UnknownNamedTypeClass, - type_id:Optional[str]=None, name:QualifiedName=QualifiedName(""), width:int=0, align:int=1, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence, - const:BoolWithConfidenceType=False, volatile:BoolWithConfidenceType=False) -> 'NamedTypeReferenceBuilder': + def create( + cls, type_class: NamedTypeReferenceClass = NamedTypeReferenceClass.UnknownNamedTypeClass, + type_id: Optional[str] = None, name: QualifiedName = QualifiedName(""), width: int = 0, align: int = 1, + platform: '_platform.Platform' = None, confidence: int = core.max_confidence, + const: BoolWithConfidenceType = False, volatile: BoolWithConfidenceType = False + ) -> 'NamedTypeReferenceBuilder': ntr_builder_handle = core.BNCreateNamedTypeBuilder(type_class, type_id, QualifiedName(name)._to_core_struct()) assert ntr_builder_handle is not None, "core.BNCreateNamedTypeBuilder returned None" _const = BoolWithConfidence.get_core_struct(const) _volatile = BoolWithConfidence.get_core_struct(volatile) - type_builder_handle = core.BNCreateNamedTypeReferenceBuilderWithBuilder(ntr_builder_handle, width, align, _const, _volatile) + type_builder_handle = core.BNCreateNamedTypeReferenceBuilderWithBuilder( + ntr_builder_handle, width, align, _const, _volatile + ) assert type_builder_handle is not None, "core.BNCreateNamedTypeReferenceBuilderWithBuilder returned None" return cls(type_builder_handle, ntr_builder_handle, platform, confidence) @@ -1302,14 +1386,20 @@ class NamedTypeReferenceBuilder(TypeBuilder): return NamedTypeReferenceClass(core.BNGetTypeReferenceBuilderClass(self.ntr_builder_handle)) @staticmethod - def named_type(named_type:'NamedTypeReferenceBuilder', width:int=0, align:int=1, - const:BoolWithConfidenceType=BoolWithConfidence(False), - volatile:BoolWithConfidenceType=BoolWithConfidence(False)) -> 'NamedTypeReferenceBuilder': - return NamedTypeReferenceBuilder.create(named_type.named_type_class, named_type.id, - named_type.name, width, align, None, core.max_confidence, const, volatile) + def named_type( + named_type: 'NamedTypeReferenceBuilder', width: int = 0, align: int = 1, + const: BoolWithConfidenceType = BoolWithConfidence(False), + volatile: BoolWithConfidenceType = BoolWithConfidence(False) + ) -> 'NamedTypeReferenceBuilder': + return NamedTypeReferenceBuilder.create( + named_type.named_type_class, named_type.id, named_type.name, width, align, None, core.max_confidence, const, + volatile + ) @staticmethod - def named_type_from_type_and_id(type_id:str, name:QualifiedName, type:Optional['Type']=None) -> 'NamedTypeReferenceBuilder': + def named_type_from_type_and_id( + type_id: str, name: QualifiedName, type: Optional['Type'] = None + ) -> 'NamedTypeReferenceBuilder': if type is None: return NamedTypeReferenceBuilder.create(NamedTypeReferenceClass.UnknownNamedTypeClass, type_id, name) elif type.type_class == TypeClass.StructureTypeClass: @@ -1325,14 +1415,20 @@ class NamedTypeReferenceBuilder(TypeBuilder): return NamedTypeReferenceBuilder.create(NamedTypeReferenceClass.TypedefNamedTypeClass, type_id, name) @staticmethod - def named_type_from_type(name:QualifiedName, type_class:Optional[NamedTypeReferenceClass]=None) -> 'NamedTypeReferenceBuilder': + def named_type_from_type( + name: QualifiedName, type_class: Optional[NamedTypeReferenceClass] = None + ) -> 'NamedTypeReferenceBuilder': if type_class is None: - return NamedTypeReferenceBuilder.create(NamedTypeReferenceClass.UnknownNamedTypeClass, str(uuid.uuid4()), name) + return NamedTypeReferenceBuilder.create( + NamedTypeReferenceClass.UnknownNamedTypeClass, str(uuid.uuid4()), name + ) else: return NamedTypeReferenceBuilder.create(type_class, str(uuid.uuid4()), name) @staticmethod - def named_type_from_registered_type(view:'binaryview.BinaryView', name:QualifiedName) -> 'NamedTypeReferenceBuilder': + def named_type_from_registered_type( + view: 'binaryview.BinaryView', name: QualifiedName + ) -> 'NamedTypeReferenceBuilder': type = view.get_type_by_name(name) if type is None: raise ValueError(f"Unable to find type named {name}") @@ -1365,14 +1461,16 @@ class Type: :py:meth:`parse_types_from_source_file <platform.Platform.parse_types_from_source_file>` """ - def __init__(self, handle, platform:'_platform.Platform'=None, confidence:int=core.max_confidence): + def __init__(self, handle, platform: '_platform.Platform' = None, confidence: int = core.max_confidence): assert isinstance(handle.contents, core.BNType), "Attempting to create mutable Type" self._handle = handle self._confidence = confidence self._platform = platform @classmethod - def create(cls, handle=core.BNTypeHandle, platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'Type': + def create( + cls, handle=core.BNTypeHandle, platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ) -> 'Type': assert handle is not None, "Passed a handle which is None" assert isinstance(handle, core.BNTypeHandle) type_class = TypeClass(core.BNGetTypeClass(handle)) @@ -1458,7 +1556,7 @@ class Type: """Type string as a list of tokens (read-only)""" return self.get_tokens() - def get_tokens(self, base_confidence = core.max_confidence) -> List['_function.InstructionTextToken']: + def get_tokens(self, base_confidence=core.max_confidence) -> List['_function.InstructionTextToken']: count = ctypes.c_ulonglong() platform = None if self._platform is not None: @@ -1470,7 +1568,7 @@ class Type: core.BNFreeInstructionText(tokens, count.value) return result - def get_tokens_before_name(self, base_confidence = core.max_confidence) -> List['_function.InstructionTextToken']: + def get_tokens_before_name(self, base_confidence=core.max_confidence) -> List['_function.InstructionTextToken']: count = ctypes.c_ulonglong() platform = None if self._platform is not None: @@ -1481,7 +1579,7 @@ class Type: core.BNFreeInstructionText(tokens, count.value) return result - def get_tokens_after_name(self, base_confidence = core.max_confidence) -> List['_function.InstructionTextToken']: + def get_tokens_after_name(self, base_confidence=core.max_confidence) -> List['_function.InstructionTextToken']: count = ctypes.c_ulonglong() platform = None if self._platform is not None: @@ -1493,14 +1591,14 @@ class Type: return result def with_confidence(self, confidence) -> 'Type': - return Type.create(handle = core.BNNewTypeReference(self._handle), platform = self._platform, confidence = confidence) + return Type.create(handle=core.BNNewTypeReference(self._handle), platform=self._platform, confidence=confidence) @property def confidence(self) -> _int: return self._confidence @confidence.setter - def confidence(self, value:_int) -> None: + def confidence(self, value: _int) -> None: self._confidence = value @property @@ -1508,22 +1606,18 @@ class Type: return self._platform @platform.setter - def platform(self, value:'_platform.Platform') -> None: + def platform(self, value: '_platform.Platform') -> None: self._platform = value def mutable_copy(self) -> 'TypeBuilder': TypeBuilders = { - TypeClass.VoidTypeClass:VoidBuilder, - TypeClass.BoolTypeClass:BoolBuilder, - TypeClass.IntegerTypeClass:IntegerBuilder, - TypeClass.FloatTypeClass:FloatBuilder, - TypeClass.PointerTypeClass:PointerBuilder, - TypeClass.ArrayTypeClass:ArrayBuilder, - TypeClass.FunctionTypeClass:FunctionBuilder, - TypeClass.WideCharTypeClass:WideCharBuilder, - # TypeClass.StructureTypeClass:Structure, - # TypeClass.EnumerationTypeClass:Enumeration, - # TypeClass.NamedTypeReferenceClass:NamedTypeReference, + TypeClass.VoidTypeClass: VoidBuilder, TypeClass.BoolTypeClass: BoolBuilder, + TypeClass.IntegerTypeClass: IntegerBuilder, TypeClass.FloatTypeClass: FloatBuilder, + TypeClass.PointerTypeClass: PointerBuilder, TypeClass.ArrayTypeClass: ArrayBuilder, + TypeClass.FunctionTypeClass: FunctionBuilder, TypeClass.WideCharTypeClass: WideCharBuilder, + # TypeClass.StructureTypeClass:Structure, + # TypeClass.EnumerationTypeClass:Enumeration, + # TypeClass.NamedTypeReferenceClass:NamedTypeReference, } builder_handle = core.BNCreateTypeBuilderFromType(self._handle) assert builder_handle is not None, "core.BNCreateTypeBuilderFromType returned None" @@ -1532,12 +1626,14 @@ class Type: def immutable_copy(self) -> 'Type': return self - def get_builder(self, bv:'binaryview.BinaryView') -> 'MutableTypeBuilder': + def get_builder(self, bv: 'binaryview.BinaryView') -> 'MutableTypeBuilder': return MutableTypeBuilder(self.mutable_copy(), bv, self.registered_name, self.platform, self._confidence) @staticmethod - def builder(bv:'binaryview.BinaryView', name:Optional[QualifiedName]=None, id:Optional[str]=None, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'MutableTypeBuilder': + def builder( + bv: 'binaryview.BinaryView', name: Optional[QualifiedName] = None, id: Optional[str] = None, + platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ) -> 'MutableTypeBuilder': type = None if name is None and id is None: raise ValueError("Must specify either a name or id to create a builder object") @@ -1560,13 +1656,15 @@ class Type: return MutableTypeBuilder(type.mutable_copy(), bv, name, platform, confidence) def with_replaced_structure(self, from_struct, to_struct): - return Type.create(handle = core.BNTypeWithReplacedStructure(self._handle, from_struct.handle, to_struct.handle)) + return Type.create(handle=core.BNTypeWithReplacedStructure(self._handle, from_struct.handle, to_struct.handle)) def with_replaced_enumeration(self, from_enum, to_enum): - return Type.create(handle = core.BNTypeWithReplacedEnumeration(self._handle, from_enum.handle, to_enum.handle)) + return Type.create(handle=core.BNTypeWithReplacedEnumeration(self._handle, from_enum.handle, to_enum.handle)) def with_replaced_named_type_reference(self, from_ref, to_ref): - return Type.create(handle = core.BNTypeWithReplacedNamedTypeReference(self._handle, from_ref.handle, to_ref.handle)) + return Type.create( + handle=core.BNTypeWithReplacedNamedTypeReference(self._handle, from_ref.handle, to_ref.handle) + ) @staticmethod def void() -> 'VoidType': @@ -1577,11 +1675,11 @@ class Type: return BoolType.create() @staticmethod - def char(alternate_name:str="") -> 'CharType': + def char(alternate_name: str = "") -> 'CharType': return CharType.create(alternate_name) @staticmethod - def int(width:_int, sign:BoolWithConfidenceType=True, alternate_name:str="") -> 'IntegerType': + def int(width: _int, sign: BoolWithConfidenceType = True, alternate_name: str = "") -> 'IntegerType': """ ``int`` class method for creating an int Type. :param int width: width of the integer in bytes @@ -1591,7 +1689,7 @@ class Type: return IntegerType.create(width, sign, alternate_name) @staticmethod - def float(width:_int, alternate_name:str="") -> 'FloatType': + def float(width: _int, alternate_name: str = "") -> 'FloatType': """ ``float`` class method for creating floating point Types. :param int width: width of the floating point number in bytes @@ -1600,7 +1698,7 @@ class Type: return FloatType.create(width, alternate_name) @staticmethod - def wide_char(width:_int, alternate_name:str="") -> 'WideCharType': + def wide_char(width: _int, alternate_name: str = "") -> 'WideCharType': """ ``wide_char`` class method for creating wide char Types. :param int width: width of the wide character in bytes @@ -1609,42 +1707,47 @@ class Type: return WideCharType.create(width=width, alternate_name=alternate_name) @staticmethod - def structure_type(structure:'StructureBuilder') -> 'StructureType': + def structure_type(structure: 'StructureBuilder') -> 'StructureType': result = structure.immutable_copy() assert isinstance(result, StructureType) return result @staticmethod - def named_type(named_type:'NamedTypeReferenceBuilder') -> 'NamedTypeReferenceType': + def named_type(named_type: 'NamedTypeReferenceBuilder') -> 'NamedTypeReferenceType': result = named_type.immutable_copy() assert isinstance(result, NamedTypeReferenceType) return result @staticmethod - def named_type_from_type(name:QualifiedName, type:'Type') -> 'NamedTypeReferenceType': + def named_type_from_type(name: QualifiedName, type: 'Type') -> 'NamedTypeReferenceType': return NamedTypeReferenceType.create_from_type(name, type) @staticmethod - def named_type_from_type_and_id(type_id:str, name:QualifiedName, type:Optional['Type']=None) -> 'NamedTypeReferenceType': + def named_type_from_type_and_id( + type_id: str, name: QualifiedName, type: Optional['Type'] = None + ) -> 'NamedTypeReferenceType': return NamedTypeReferenceType.create_from_type(name, type, type_id) @staticmethod - def generate_named_type_reference(guid:str, name:QualifiedName) -> 'NamedTypeReferenceType': + def generate_named_type_reference(guid: str, name: QualifiedName) -> 'NamedTypeReferenceType': return NamedTypeReferenceType.create(NamedTypeReferenceClass.TypedefNamedTypeClass, guid, name) @staticmethod - def named_type_from_registered_type(view:'binaryview.BinaryView', name:QualifiedName) -> 'NamedTypeReferenceType': + def named_type_from_registered_type(view: 'binaryview.BinaryView', name: QualifiedName) -> 'NamedTypeReferenceType': return NamedTypeReferenceType.create_from_registered_type(view, name) @staticmethod - def enumeration_type(arch, enum:'EnumerationBuilder', width:_int=None, sign:_bool=False) -> 'EnumerationType': + def enumeration_type( + arch, enum: 'EnumerationBuilder', width: _int = None, sign: _bool = False + ) -> 'EnumerationType': return EnumerationType.create(enum.members, enum.width, arch, enum.signed) @staticmethod - def pointer(arch:'architecture.Architecture', type:'Type', - const:BoolWithConfidenceType=BoolWithConfidence(False), - volatile:BoolWithConfidenceType=BoolWithConfidence(False), - ref_type:ReferenceType=ReferenceType.PointerReferenceType, width:_int=None) -> 'PointerType': + def pointer( + arch: 'architecture.Architecture', type: 'Type', const: BoolWithConfidenceType = BoolWithConfidence(False), + volatile: BoolWithConfidenceType = BoolWithConfidence(False), + ref_type: ReferenceType = ReferenceType.PointerReferenceType, width: _int = None + ) -> 'PointerType': if arch is not None: width = arch.address_size @@ -1654,20 +1757,23 @@ class Type: return PointerType.create_with_width(width, type, const, volatile, ref_type) @staticmethod - def pointer_of_width(width:_int, type:'Type', - const:BoolWithConfidenceType=False, - volatile:BoolWithConfidenceType=False, - ref_type:ReferenceType=ReferenceType.PointerReferenceType) -> 'PointerType': + def pointer_of_width( + width: _int, type: 'Type', const: BoolWithConfidenceType = False, volatile: BoolWithConfidenceType = False, + ref_type: ReferenceType = ReferenceType.PointerReferenceType + ) -> 'PointerType': return PointerType.create_with_width(width, type, const, volatile, ref_type) @staticmethod - def array(type:'Type', count:_int) -> 'ArrayType': + def array(type: 'Type', count: _int) -> 'ArrayType': return ArrayType.create(type, count) @staticmethod - def function(ret:Optional['Type']=None, params:Optional[ParamsType]=None, calling_convention:'callingconvention.CallingConvention'=None, - variable_arguments:BoolWithConfidenceType=False, - stack_adjust:OffsetWithConfidence=OffsetWithConfidence(0)) -> 'FunctionType': + def function( + ret: Optional['Type'] = None, params: Optional[ParamsType] = None, + calling_convention: 'callingconvention.CallingConvention' = None, + variable_arguments: BoolWithConfidenceType = False, + stack_adjust: OffsetWithConfidence = OffsetWithConfidence(0) + ) -> 'FunctionType': """ ``function`` class method for creating an function Type. :param Type ret: return Type of the function @@ -1679,35 +1785,42 @@ class Type: return FunctionType.create(ret, params, calling_convention, variable_arguments, stack_adjust) @staticmethod - def from_core_struct(core_type:core.BNType): + def from_core_struct(core_type: core.BNType): return Type.create(core.BNNewTypeReference(core_type)) @staticmethod - def structure(members:MembersType=None, packed:_bool=False, type:StructureVariant=StructureVariant.StructStructureType) -> 'StructureType': + def structure( + members: MembersType = None, packed: _bool = False, + type: StructureVariant = StructureVariant.StructStructureType + ) -> 'StructureType': return StructureType.create(members, packed, type) - + @staticmethod - def union(members:Optional[MembersType]=None, packed:_bool=False) -> 'StructureType': + def union(members: Optional[MembersType] = None, packed: _bool = False) -> 'StructureType': return StructureType.create(members, type=StructureVariant.UnionStructureType, packed=packed) - + @staticmethod - def class_type(members:Optional[MembersType]=None, packed:_bool=False) -> 'StructureType': + def class_type(members: Optional[MembersType] = None, packed: _bool = False) -> 'StructureType': return StructureType.create(members, type=StructureVariant.ClassStructureType, packed=packed) @staticmethod - def enumeration(arch:Optional['architecture.Architecture']=None, members:Optional[List[EnumMembersType]]=None, - width:Optional[_int]=None, sign:BoolWithConfidenceType=False) -> 'EnumerationType': + def enumeration( + arch: Optional['architecture.Architecture'] = None, members: Optional[List[EnumMembersType]] = None, + width: Optional[_int] = None, sign: BoolWithConfidenceType = False + ) -> 'EnumerationType': if members is None: members = [] return EnumerationType.create(members, width, arch, sign) @staticmethod - def named_type_reference(type_class:NamedTypeReferenceClass, name:QualifiedName, - type_id:Optional[str]=None, alignment:_int=1, width:_int=0, - const:BoolWithConfidenceType=BoolWithConfidence(False), - volatile:BoolWithConfidenceType=BoolWithConfidence(False)): - return NamedTypeReferenceType.create(type_class, type_id, name, alignment, width, - None, core.max_confidence, const, volatile) + def named_type_reference( + type_class: NamedTypeReferenceClass, name: QualifiedName, type_id: Optional[str] = None, alignment: _int = 1, + width: _int = 0, const: BoolWithConfidenceType = BoolWithConfidence(False), + volatile: BoolWithConfidenceType = BoolWithConfidence(False) + ): + return NamedTypeReferenceType.create( + type_class, type_id, name, alignment, width, None, core.max_confidence, const, volatile + ) @property @abstractmethod @@ -1715,12 +1828,12 @@ class Type: raise NotImplementedError("Name not implemented for this type") @staticmethod - def generate_auto_type_id(source:str, name:str) -> str: + def generate_auto_type_id(source: str, name: str) -> str: _name = QualifiedName(name)._to_core_struct() return core.BNGenerateAutoTypeId(source, _name) @staticmethod - def generate_auto_demangled_type_id(name:str) -> str: + def generate_auto_demangled_type_id(name: str) -> str: _name = QualifiedName(name)._to_core_struct() return core.BNGenerateAutoDemangledTypeId(_name) @@ -1740,13 +1853,13 @@ class Type: def const(self): """Whether type is const (read/write)""" result = core.BNIsTypeConst(self._handle) - return BoolWithConfidence(result.value, confidence = result.confidence) + return BoolWithConfidence(result.value, confidence=result.confidence) @property def volatile(self): """Whether type is volatile (read/write)""" result = core.BNIsTypeVolatile(self._handle) - return BoolWithConfidence(result.value, confidence = result.confidence) + return BoolWithConfidence(result.value, confidence=result.confidence) @property def system_call_number(self) -> Optional[_int]: @@ -1758,8 +1871,8 @@ class Type: @dataclass(frozen=True) class RegisterStackAdjustmentWithConfidence: - value:int - confidence:int=core.max_confidence + value: int + confidence: int = core.max_confidence def __int__(self): return self.value @@ -1767,7 +1880,7 @@ class RegisterStackAdjustmentWithConfidence: class VoidType(Type): @classmethod - def create(cls, platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'VoidType': + def create(cls, platform: '_platform.Platform' = None, confidence: int = core.max_confidence) -> 'VoidType': core_void = core.BNCreateVoidType() assert core_void is not None, "core.BNCreateVoidType returned None" return cls(core.BNNewTypeReference(core_void), platform, confidence) @@ -1775,19 +1888,21 @@ class VoidType(Type): class BoolType(Type): @classmethod - def create(cls, platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'BoolType': + def create(cls, platform: '_platform.Platform' = None, confidence: int = core.max_confidence) -> 'BoolType': handle = core.BNCreateBoolType() assert handle is not None, "core.BNCreateBoolType returned None" return cls(core.BNNewTypeReference(handle), platform, confidence) class IntegerType(Type): - def __init__(self, handle, platform:'_platform.Platform'=None, confidence:int=core.max_confidence): + def __init__(self, handle, platform: '_platform.Platform' = None, confidence: int = core.max_confidence): super(IntegerType, self).__init__(handle, platform, confidence) @classmethod - def create(cls, width:int, sign:BoolWithConfidenceType=True, alternate_name:str="", - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'IntegerType': + def create( + cls, width: int, sign: BoolWithConfidenceType = True, alternate_name: str = "", + platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ) -> 'IntegerType': _sign = BoolWithConfidence.get_core_struct(sign) handle = core.BNCreateIntegerType(width, _sign, alternate_name) assert handle is not None, "core.BNCreateIntegerType returned None" @@ -1801,14 +1916,17 @@ class IntegerType(Type): class CharType(IntegerType): @classmethod - def create(cls, altname:str="char", platform:'_platform.Platform'=None, - confidence:int=core.max_confidence) -> 'CharType': + def create( + cls, altname: str = "char", platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ) -> 'CharType': return cls(IntegerType.create(1, True, altname).handle, platform, confidence) class FloatType(Type): @classmethod - def create(cls, width:int, altname:str="", platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'FloatType': + def create( + cls, width: int, altname: str = "", platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ) -> 'FloatType': """ ``float`` class method for creating floating point Types. @@ -1821,7 +1939,7 @@ class FloatType(Type): class StructureType(Type): - def __init__(self, handle, platform:'_platform.Platform'=None, confidence:int=core.max_confidence): + def __init__(self, handle, platform: '_platform.Platform' = None, confidence: int = core.max_confidence): assert handle is not None, "Attempted to create EnumerationType with handle which is None" super(StructureType, self).__init__(handle, platform, confidence) struct_handle = core.BNGetTypeStructure(handle) @@ -1829,8 +1947,11 @@ class StructureType(Type): self.struct_handle = struct_handle @classmethod - def create(cls, members:MembersType=None, packed:bool=False, type:StructureVariant=StructureVariant.StructStructureType, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'StructureType': + def create( + cls, members: MembersType = None, packed: bool = False, + type: StructureVariant = StructureVariant.StructStructureType, platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ) -> 'StructureType': builder = core.BNCreateStructureBuilderWithOptions(type, packed) assert builder is not None, "core.BNCreateStructureBuilder returned None" StructureBuilder._add_members_to_builder(builder, members) @@ -1850,7 +1971,7 @@ class StructureType(Type): return StructureBuilder(type_builder_handle, structure_builder_handle, self.platform, self.confidence) @classmethod - def from_core_struct(cls, structure:core.BNStructure) -> 'StructureType': + def from_core_struct(cls, structure: core.BNStructure) -> 'StructureType': return cls(core.BNNewTypeReference(core.BNCreateStructureType(structure))) def __del__(self): @@ -1860,28 +1981,32 @@ class StructureType(Type): def __hash__(self): return hash(ctypes.addressof(self.struct_handle.contents)) - def __getitem__(self, name:str) -> StructureMember: + def __getitem__(self, name: str) -> StructureMember: member = None try: member = core.BNGetStructureMemberByName(self.struct_handle, name) if member is None: raise ValueError(f"Member {name} is not part of structure") - return StructureMember(Type.create(core.BNNewTypeReference(member.contents.type), confidence=member.contents.typeConfidence), - member.contents.name, member.contents.offset, MemberAccess(member.contents.access), - MemberScope(member.contents.scope)) + return StructureMember( + Type.create(core.BNNewTypeReference(member.contents.type), confidence=member.contents.typeConfidence), + member.contents.name, member.contents.offset, MemberAccess(member.contents.access), + MemberScope(member.contents.scope) + ) finally: if member is not None: core.BNFreeStructureMember(member) - def member_at_offset(self, offset:int) -> StructureMember: + def member_at_offset(self, offset: int) -> StructureMember: member = None try: member = core.BNGetStructureMemberAtOffset(self.struct_handle, offset, None) if member is None: raise ValueError(f"No member exists a offset {offset}") - return StructureMember(Type.create(core.BNNewTypeReference(member.contents.type), confidence=member.contents.typeConfidence), - member.contents.name, member.contents.offset, MemberAccess(member.contents.access), - MemberScope(member.contents.scope)) + return StructureMember( + Type.create(core.BNNewTypeReference(member.contents.type), confidence=member.contents.typeConfidence), + member.contents.name, member.contents.offset, MemberAccess(member.contents.access), + MemberScope(member.contents.scope) + ) finally: core.BNFreeStructureMember(member) @@ -1894,9 +2019,13 @@ class StructureType(Type): try: result = [] for i in range(0, count.value): - result.append(StructureMember(Type.create(core.BNNewTypeReference(members[i].type), confidence=members[i].typeConfidence), - members[i].name, members[i].offset, MemberAccess(members[i].access), - MemberScope(members[i].scope))) + result.append( + StructureMember( + Type.create(core.BNNewTypeReference(members[i].type), confidence=members[i].typeConfidence), + members[i].name, members[i].offset, MemberAccess(members[i].access), + MemberScope(members[i].scope) + ) + ) finally: core.BNFreeStructureMemberList(members, count.value) return result @@ -1920,27 +2049,34 @@ class StructureType(Type): return StructureVariant(core.BNGetStructureType(self.struct_handle)) def with_replaced_structure(self, from_struct, to_struct) -> 'StructureType': - return StructureType(core.BNStructureWithReplacedStructure(self.struct_handle, from_struct.handle, to_struct.handle)) + return StructureType( + core.BNStructureWithReplacedStructure(self.struct_handle, from_struct.handle, to_struct.handle) + ) def with_replaced_enumeration(self, from_enum, to_enum) -> 'StructureType': - return StructureType(core.BNStructureWithReplacedEnumeration(self.struct_handle, from_enum.handle, to_enum.handle)) + return StructureType( + core.BNStructureWithReplacedEnumeration(self.struct_handle, from_enum.handle, to_enum.handle) + ) def with_replaced_named_type_reference(self, from_ref, to_ref) -> 'StructureType': - return StructureType(core.BNStructureWithReplacedNamedTypeReference(self.struct_handle, from_ref.handle, to_ref.handle)) + return StructureType( + core.BNStructureWithReplacedNamedTypeReference(self.struct_handle, from_ref.handle, to_ref.handle) + ) - def generate_named_type_reference(self, guid:str, name:QualifiedName): + def generate_named_type_reference(self, guid: str, name: QualifiedName): if self.type == StructureVariant.StructStructureType: ntr_type = NamedTypeReferenceClass.StructNamedTypeClass elif self.type == StructureVariant.UnionStructureType: ntr_type = NamedTypeReferenceClass.UnionNamedTypeClass else: ntr_type = NamedTypeReferenceClass.ClassNamedTypeClass - return NamedTypeReferenceType.create(ntr_type, guid, name, self.alignment, - self.width, self.platform, self.confidence) + return NamedTypeReferenceType.create( + ntr_type, guid, name, self.alignment, self.width, self.platform, self.confidence + ) class EnumerationType(IntegerType): - def __init__(self, handle, platform:'_platform.Platform'=None, confidence:int=core.max_confidence): + def __init__(self, handle, platform: '_platform.Platform' = None, confidence: int = core.max_confidence): assert handle is not None, "Attempted to create EnumerationType without handle" super(EnumerationType, self).__init__(handle, platform, confidence) enum_handle = core.BNGetTypeEnumeration(handle) @@ -1968,9 +2104,11 @@ class EnumerationType(IntegerType): return result @classmethod - def create(cls, members=List[EnumMembersType], width:Optional[int]=None, - arch:Optional['architecture.Architecture']=None, sign:BoolWithConfidenceType=False, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'EnumerationType': + def create( + cls, members=List[EnumMembersType], width: Optional[int] = None, + arch: Optional['architecture.Architecture'] = None, sign: BoolWithConfidenceType = False, + platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ) -> 'EnumerationType': if width is None: if arch is None: raise ValueError("One of the following parameters must not be None: (arch, width)") @@ -1998,10 +2136,9 @@ class EnumerationType(IntegerType): assert enumeration_builder_handle is not None, "core.BNCreateEnumerationBuilderFromEnumeration returned None" return EnumerationBuilder(type_builder_handle, enumeration_builder_handle, self.platform, self.confidence) - def generate_named_type_reference(self, guid:str, name:QualifiedName): + def generate_named_type_reference(self, guid: str, name: QualifiedName): ntr_type = NamedTypeReferenceClass.EnumNamedTypeClass - return NamedTypeReferenceType.create(ntr_type, guid, name, - platform=self.platform, confidence=self.confidence) + return NamedTypeReferenceType.create(ntr_type, guid, name, platform=self.platform, confidence=self.confidence) class PointerType(Type): @@ -2010,16 +2147,19 @@ class PointerType(Type): return ReferenceType(core.BNTypeGetReferenceType(self._handle)) @classmethod - def create(cls, arch:'architecture.Architecture', type:SomeType, const:BoolWithConfidenceType=False, - volatile:BoolWithConfidenceType=False, ref_type:ReferenceType=ReferenceType.PointerReferenceType, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'PointerType': + def create( + cls, arch: 'architecture.Architecture', type: SomeType, const: BoolWithConfidenceType = False, + volatile: BoolWithConfidenceType = False, ref_type: ReferenceType = ReferenceType.PointerReferenceType, + platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ) -> 'PointerType': return cls.create_with_width(arch.address_size, type, const, volatile, ref_type, platform, confidence) @staticmethod - def from_bools(const:BoolWithConfidenceType, volatile:BoolWithConfidenceType) -> Tuple[BoolWithConfidence, BoolWithConfidence]: + def from_bools(const: BoolWithConfidenceType, + volatile: BoolWithConfidenceType) -> Tuple[BoolWithConfidence, BoolWithConfidence]: _const = const if const is None: - _const = BoolWithConfidence(False, confidence = 0) + _const = BoolWithConfidence(False, confidence=0) elif isinstance(const, bool): _const = BoolWithConfidence(const) if not isinstance(_const, BoolWithConfidence): @@ -2027,7 +2167,7 @@ class PointerType(Type): _volatile = volatile if volatile is None: - _volatile = BoolWithConfidence(False, confidence = 0) + _volatile = BoolWithConfidence(False, confidence=0) elif isinstance(volatile, bool): _volatile = BoolWithConfidence(volatile) if not isinstance(_volatile, BoolWithConfidence): @@ -2036,17 +2176,20 @@ class PointerType(Type): return (_const, _volatile) @classmethod - def create_with_width(cls, width:int, type:SomeType, const:BoolWithConfidenceType=False, - volatile:BoolWithConfidenceType=False, ref_type:ReferenceType=None, platform:'_platform.Platform'=None, - confidence:int=core.max_confidence) -> 'PointerType': + def create_with_width( + cls, width: int, type: SomeType, const: BoolWithConfidenceType = False, + volatile: BoolWithConfidenceType = False, ref_type: ReferenceType = None, platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ) -> 'PointerType': _const, _volatile = PointerType.from_bools(const, volatile) type = type.immutable_copy() if ref_type is None: ref_type = ReferenceType.PointerReferenceType type_conf = type._to_core_struct() - core_type = core.BNCreatePointerTypeOfWidth(width, type_conf, _const._to_core_struct(), - _volatile._to_core_struct(), ref_type) + core_type = core.BNCreatePointerTypeOfWidth( + width, type_conf, _const._to_core_struct(), _volatile._to_core_struct(), ref_type + ) assert core_type is not None, "core.BNCreatePointerTypeOfWidth returned None" return cls(core.BNNewTypeReference(core_type), platform, confidence) @@ -2060,7 +2203,10 @@ class PointerType(Type): class ArrayType(Type): @classmethod - def create(cls, element_type:Type, count:int, platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'ArrayType': + def create( + cls, element_type: Type, count: int, platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ) -> 'ArrayType': type_conf = element_type._to_core_struct() core_array = core.BNCreateArrayType(type_conf, count) assert core_array is not None, "core.BNCreateArrayType returned None" @@ -2080,9 +2226,13 @@ class ArrayType(Type): class FunctionType(Type): @classmethod - def create(cls, ret:Optional[Type]=None, params:ParamsType=None, - calling_convention:'callingconvention.CallingConvention'=None, variable_arguments:BoolWithConfidenceType=BoolWithConfidence(False), - stack_adjust:OffsetWithConfidence=OffsetWithConfidence(0), platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'FunctionType': + def create( + cls, ret: Optional[Type] = None, params: ParamsType = None, + calling_convention: 'callingconvention.CallingConvention' = None, + variable_arguments: BoolWithConfidenceType = BoolWithConfidence(False), + stack_adjust: OffsetWithConfidence = OffsetWithConfidence(0), platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ) -> 'FunctionType': if ret is None: ret = VoidType.create() if params is None: @@ -2100,8 +2250,9 @@ class FunctionType(Type): _variable_arguments = BoolWithConfidence.get_core_struct(variable_arguments) _stack_adjust = OffsetWithConfidence.get_core_struct(stack_adjust) - func_type = core.BNCreateFunctionType(ret_conf, conv_conf, param_buf, len(params), - _variable_arguments, _stack_adjust) + func_type = core.BNCreateFunctionType( + ret_conf, conv_conf, param_buf, len(params), _variable_arguments, _stack_adjust + ) assert func_type is not None, f"core.BNCreateFunctionType returned None {ret_conf} {conv_conf} {param_buf} {_variable_arguments} {_stack_adjust}" return cls(core.BNNewTypeReference(func_type), platform, confidence) @@ -2109,7 +2260,7 @@ class FunctionType(Type): def stack_adjustment(self) -> OffsetWithConfidence: """Stack adjustment for function (read-only)""" result = core.BNGetTypeStackAdjustment(self._handle) - return OffsetWithConfidence(result.value, confidence = result.confidence) + return OffsetWithConfidence(result.value, confidence=result.confidence) @property def return_value(self) -> Type: @@ -2117,7 +2268,7 @@ class FunctionType(Type): result = core.BNGetChildType(self._handle) if result is None: return Type.void() - return Type.create(core.BNNewTypeReference(result.type), platform = self._platform, confidence = result.confidence) + return Type.create(core.BNNewTypeReference(result.type), platform=self._platform, confidence=result.confidence) @property def calling_convention(self) -> Optional[callingconvention.CallingConvention]: @@ -2125,7 +2276,7 @@ class FunctionType(Type): result = core.BNGetTypeCallingConvention(self._handle) if not result.convention: return None - return callingconvention.CallingConvention(None, handle = result.convention, confidence = result.confidence) + return callingconvention.CallingConvention(None, handle=result.convention, confidence=result.confidence) @property def parameters(self) -> List[FunctionParameter]: @@ -2135,17 +2286,21 @@ class FunctionType(Type): assert params is not None, "core.BNGetTypeParameters returned None" result = [] for i in range(0, count.value): - param_type = Type.create(core.BNNewTypeReference(params[i].type), platform = self._platform, confidence = params[i].typeConfidence) + param_type = Type.create( + core.BNNewTypeReference(params[i].type), platform=self._platform, confidence=params[i].typeConfidence + ) if params[i].defaultLocation: param_location = None else: name = params[i].name - if (params[i].location.type == VariableSourceType.RegisterVariableSourceType) and (self._platform is not None): + if (params[i].location.type + == VariableSourceType.RegisterVariableSourceType) and (self._platform is not None): name = self._platform.arch.get_reg_name(params[i].location.storage) elif params[i].location.type == VariableSourceType.StackVariableSourceType: name = "arg_%x" % params[i].location.storage - param_location = variable.VariableNameAndType(params[i].location.type, params[i].location.index, - params[i].location.storage, name, param_type) + param_location = variable.VariableNameAndType( + params[i].location.type, params[i].location.index, params[i].location.storage, name, param_type + ) result.append(FunctionParameter(param_type, params[i].name, param_location)) core.BNFreeTypeParameterList(params, count.value) return result @@ -2154,17 +2309,19 @@ class FunctionType(Type): def has_variable_arguments(self) -> BoolWithConfidence: """Whether type has variable arguments (read-only)""" result = core.BNTypeHasVariableArguments(self._handle) - return BoolWithConfidence(result.value, confidence = result.confidence) + return BoolWithConfidence(result.value, confidence=result.confidence) @property def can_return(self) -> BoolWithConfidence: """Whether type can return""" result = core.BNFunctionTypeCanReturn(self._handle) - return BoolWithConfidence(result.value, confidence = result.confidence) + return BoolWithConfidence(result.value, confidence=result.confidence) class NamedTypeReferenceType(Type): - def __init__(self, handle, platform:'_platform.Platform'=None, confidence:int=core.max_confidence, ntr_handle=None): + def __init__( + self, handle, platform: '_platform.Platform' = None, confidence: int = core.max_confidence, ntr_handle=None + ): assert handle is not None, "Attempting to create NamedTypeReferenceType handle which is None" super(NamedTypeReferenceType, self).__init__(handle, platform, confidence) if ntr_handle is None: @@ -2175,14 +2332,18 @@ class NamedTypeReferenceType(Type): def mutable_copy(self): type_builder_handle = core.BNCreateTypeBuilderFromType(self._handle) assert type_builder_handle is not None, "core.BNCreateTypeBuilderFromType returned None" - ntr_builder_handle = core.BNCreateNamedTypeBuilder(self.named_type_class, self.type_id, self.name._to_core_struct()) + ntr_builder_handle = core.BNCreateNamedTypeBuilder( + self.named_type_class, self.type_id, self.name._to_core_struct() + ) assert ntr_builder_handle is not None, "core.BNCreateNamedTypeBuilder returned None" return NamedTypeReferenceBuilder(type_builder_handle, ntr_builder_handle, self.platform, self.confidence) @classmethod - def create(cls, named_type_class:NamedTypeReferenceClass, guid:Optional[str], - name:QualifiedName, alignment:int=0, width:int=0, platform:'_platform.Platform'=None, - confidence:int=core.max_confidence, const:BoolWithConfidenceType=False, volatile:BoolWithConfidenceType=False) -> 'NamedTypeReferenceType': + def create( + cls, named_type_class: NamedTypeReferenceClass, guid: Optional[str], name: QualifiedName, alignment: int = 0, + width: int = 0, platform: '_platform.Platform' = None, confidence: int = core.max_confidence, + const: BoolWithConfidenceType = False, volatile: BoolWithConfidenceType = False + ) -> 'NamedTypeReferenceType': _guid = guid if guid is None: _guid = str(uuid.uuid4()) @@ -2198,8 +2359,10 @@ class NamedTypeReferenceType(Type): return cls(core.BNNewTypeReference(core_type), platform, confidence) @classmethod - def create_from_type(cls, name:QualifiedName, type:Optional[Type], guid:Optional[str]=None, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'NamedTypeReferenceType': + def create_from_type( + cls, name: QualifiedName, type: Optional[Type], guid: Optional[str] = None, + platform: '_platform.Platform' = None, confidence: int = core.max_confidence + ) -> 'NamedTypeReferenceType': _guid = guid if _guid is None: _guid = str(uuid.uuid4()) @@ -2210,8 +2373,10 @@ class NamedTypeReferenceType(Type): return type.generate_named_type_reference(_guid, name) @classmethod - def create_from_registered_type(cls, view:'binaryview.BinaryView', name:QualifiedName, - platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'NamedTypeReferenceType': + def create_from_registered_type( + cls, view: 'binaryview.BinaryView', name: QualifiedName, platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ) -> 'NamedTypeReferenceType': _name = QualifiedName(name)._to_core_struct() core_type = core.BNCreateNamedTypeReferenceFromType(view.handle, _name) assert core_type is not None, "core.BNCreateNamedTypeReferenceFromType returned None" @@ -2262,16 +2427,16 @@ class NamedTypeReferenceType(Type): return result @staticmethod - def generate_auto_type_ref(type_class:NamedTypeReferenceClass, source:str, name:QualifiedNameType): + def generate_auto_type_ref(type_class: NamedTypeReferenceClass, source: str, name: QualifiedNameType): type_id = Type.generate_auto_type_id(source, name) return NamedTypeReferenceType.create(type_class, type_id, name) @staticmethod - def generate_auto_demangled_type_ref(type_class:NamedTypeReferenceClass, name:QualifiedNameType): + def generate_auto_demangled_type_ref(type_class: NamedTypeReferenceClass, name: QualifiedNameType): type_id = Type.generate_auto_demangled_type_id(name) return NamedTypeReferenceType.create(type_class, type_id, name) - def _target_helper(self, bv:'binaryview.BinaryView', type_ids=None) -> Optional[Type]: + def _target_helper(self, bv: 'binaryview.BinaryView', type_ids=None) -> Optional[Type]: t = bv.get_type_by_id(self.type_id) if t is None: return None @@ -2285,7 +2450,7 @@ class NamedTypeReferenceType(Type): else: return t - def target(self, bv:'binaryview.BinaryView') -> Optional[Type]: + def target(self, bv: 'binaryview.BinaryView') -> Optional[Type]: """Returns the type pointed to by the current type :param bv: The BinaryView in which this type is defined. @@ -2298,8 +2463,10 @@ class NamedTypeReferenceType(Type): class WideCharType(Type): @classmethod - def create(cls, width:int, alternate_name:str="", platform:'_platform.Platform'=None, - confidence:int=core.max_confidence) -> 'WideCharType': + def create( + cls, width: int, alternate_name: str = "", platform: '_platform.Platform' = None, + confidence: int = core.max_confidence + ) -> 'WideCharType': """ ``wide_char`` class method for creating wide char Types. @@ -2310,24 +2477,20 @@ class WideCharType(Type): assert core_type is not None, "core.BNCreateWideCharType returned None" return cls(core.BNNewTypeReference(core_type), platform, confidence) + Types = { - TypeClass.VoidTypeClass:VoidType, - TypeClass.BoolTypeClass:BoolType, - TypeClass.IntegerTypeClass:IntegerType, - TypeClass.FloatTypeClass:FloatType, - TypeClass.StructureTypeClass:StructureType, - TypeClass.EnumerationTypeClass:EnumerationType, - TypeClass.PointerTypeClass:PointerType, - TypeClass.ArrayTypeClass:ArrayType, - TypeClass.FunctionTypeClass:FunctionType, - TypeClass.NamedTypeReferenceClass:NamedTypeReferenceType, - TypeClass.WideCharTypeClass:WideCharType, + TypeClass.VoidTypeClass: VoidType, TypeClass.BoolTypeClass: BoolType, TypeClass.IntegerTypeClass: IntegerType, + TypeClass.FloatTypeClass: FloatType, TypeClass.StructureTypeClass: StructureType, + TypeClass.EnumerationTypeClass: EnumerationType, TypeClass.PointerTypeClass: PointerType, + TypeClass.ArrayTypeClass: ArrayType, TypeClass.FunctionTypeClass: FunctionType, + TypeClass.NamedTypeReferenceClass: NamedTypeReferenceType, TypeClass.WideCharTypeClass: WideCharType, } + @dataclass(frozen=True) class RegisterSet: - regs:List['architecture.RegisterName'] - confidence:int=core.max_confidence + regs: List['architecture.RegisterName'] + confidence: int = core.max_confidence def __iter__(self) -> Generator['architecture.RegisterName', None, None]: for reg in self.regs: @@ -2345,15 +2508,16 @@ class RegisterSet: @dataclass(frozen=True) class TypeParserResult: - types:Mapping[QualifiedName, Type] - variables:Mapping[QualifiedName, Type] - functions:Mapping[QualifiedName, Type] + types: Mapping[QualifiedName, Type] + variables: Mapping[QualifiedName, Type] + functions: Mapping[QualifiedName, Type] def __repr__(self): return f"<types: {self.types}, variables: {self.variables}, functions: {self.functions}>" -def preprocess_source(source:str, filename:str=None, include_dirs:Optional[List[str]]=None) -> Tuple[Optional[str], str]: +def preprocess_source(source: str, filename: str = None, + include_dirs: Optional[List[str]] = None) -> Tuple[Optional[str], str]: """ ``preprocess_source`` run the C preprocessor on the given source or source filename. @@ -2393,11 +2557,11 @@ def preprocess_source(source:str, filename:str=None, include_dirs:Optional[List[ @dataclass(frozen=True) class TypeFieldReference: - func:Optional['_function.Function'] - arch:Optional['architecture.Architecture'] - address:int - size:int - incomingType:Optional[Type] + func: Optional['_function.Function'] + arch: Optional['architecture.Architecture'] + address: int + size: int + incomingType: Optional[Type] def __repr__(self): if self.arch: |