def push_comments(self,
comments: Dict[int, str],
state: State = None) -> None:
# Push comments
for addr, comment in comments.items():
comm_addr = int(addr)
state.set_comment(comm_addr, comment)
def remove_all_comments(self,
bn_func: binaryninja.function.Function,
user: Optional[str] = None,
state: State = None) -> None:
for _, ins_addr in bn_func.instructions:
if ins_addr in state.comments:
state.remove_comment(ins_addr)
def push_function(self,
bn_func: binaryninja.function.Function,
state: State = None):
# Push function
func = binsync.data.Function(int(
bn_func.start)) # force conversion from long to int
func.name = bn_func.name
state.set_function(func)
def push_stack_variable(self,
bn_func: binaryninja.Function,
stack_var: binaryninja.function.Variable,
state: State = None):
if stack_var.source_type != VariableSourceType.StackVariableSourceType:
raise TypeError("Unexpected source type %s of the variable %r." %
(stack_var.source_type, stack_var))
type_str = stack_var.type.get_string_before_name()
size = stack_var.type.width
v = StackVariable(stack_var.storage, StackOffsetType.BINJA,
stack_var.name, type_str, size, bn_func.start)
state.set_stack_variable(bn_func.start, stack_var.storage, v)
def pull_stack_variables(self,
bn_func,
user: Optional[str] = None,
state: State = None) -> Dict[int, StackVariable]:
try:
return dict(state.get_stack_variables(bn_func.start))
except KeyError:
return {}
def pull_comments(self,
start_addr,
end_addr: Optional[int] = None,
user: Optional[str] = None,
state: State = None) -> Optional[Iterable[str]]:
"""
Pull comments downwards.
:param bv:
:param start_addr:
:param end_addr:
:param user:
:return:
"""
return state.get_comments(start_addr, end_addr=end_addr)
def pull_comment(self,
addr,
user: Optional[str] = None,
state: State = None) -> Optional[str]:
"""
Pull comments downwards.
:param bv:
:param start_addr:
:param end_addr:
:param user:
:return:
"""
try:
return state.get_comment(addr)
except KeyError:
return None
def pull_function(self,
bn_func,
user: Optional[str] = None,
state: State = None) -> Optional[Function]:
"""
Pull a function downwards.
:param bv:
:param bn_func:
:param user:
:return:
"""
# pull function
try:
func = state.get_function(int(bn_func.start))
return func
except KeyError:
return None
def pull_stack_variable(self,
bn_func,
offset: int,
user: Optional[str] = None,
state: State = None) -> StackVariable:
return state.get_stack_variable(bn_func.start, offset)
def push_patch(self, patch, state: State = None):
state.set_patch(patch.offset, patch)