INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Create and return a symbolic buffer of length nbytes. The buffer is not written into State s memory ; write it to the state s memory to introduce it into the program state. | def new_symbolic_buffer(self, nbytes, **options):
"""Create and return a symbolic buffer of length `nbytes`. The buffer is
not written into State's memory; write it to the state's memory to
introduce it into the program state.
:param int nbytes: Length of the new buffer
:param s... |
Create and return a symbolic value that is nbits bits wide. Assign the value to a register or write it into the address space to introduce it into the program state. | def new_symbolic_value(self, nbits, label=None, taint=frozenset()):
"""Create and return a symbolic value that is `nbits` bits wide. Assign
the value to a register or write it into the address space to introduce
it into the program state.
:param int nbits: The bitwidth of the value retu... |
This finds a set of solutions for symbolic using policy. This raises TooManySolutions if more solutions than maxcount | def concretize(self, symbolic, policy, maxcount=7):
""" This finds a set of solutions for symbolic using policy.
This raises TooManySolutions if more solutions than maxcount
"""
assert self.constraints == self.platform.constraints
symbolic = self.migrate_expression(symbolic)
... |
Concretize a symbolic: class: ~manticore. core. smtlib. expression. Expression into one solution. | def solve_one(self, expr, constrain=False):
"""
Concretize a symbolic :class:`~manticore.core.smtlib.expression.Expression` into
one solution.
:param manticore.core.smtlib.Expression expr: Symbolic value to concretize
:param bool constrain: If True, constrain expr to concretized... |
Concretize a symbolic: class: ~manticore. core. smtlib. expression. Expression into nsolves solutions. | def solve_n(self, expr, nsolves):
"""
Concretize a symbolic :class:`~manticore.core.smtlib.expression.Expression` into
`nsolves` solutions.
:param manticore.core.smtlib.Expression expr: Symbolic value to concretize
:return: Concrete value
:rtype: list[int]
"""
... |
Solves a symbolic: class: ~manticore. core. smtlib. expression. Expression into its maximum solution | def solve_max(self, expr):
"""
Solves a symbolic :class:`~manticore.core.smtlib.expression.Expression` into
its maximum solution
:param manticore.core.smtlib.Expression expr: Symbolic value to solve
:return: Concrete value
:rtype: list[int]
"""
if isinsta... |
Solves a symbolic: class: ~manticore. core. smtlib. expression. Expression into its minimum solution | def solve_min(self, expr):
"""
Solves a symbolic :class:`~manticore.core.smtlib.expression.Expression` into
its minimum solution
:param manticore.core.smtlib.Expression expr: Symbolic value to solve
:return: Concrete value
:rtype: list[int]
"""
if isinsta... |
Solves a symbolic: class: ~manticore. core. smtlib. expression. Expression into its minimum and maximun solution. Only defined for bitvects. | def solve_minmax(self, expr):
"""
Solves a symbolic :class:`~manticore.core.smtlib.expression.Expression` into
its minimum and maximun solution. Only defined for bitvects.
:param manticore.core.smtlib.Expression expr: Symbolic value to solve
:return: Concrete value
:rtyp... |
Reads nbytes of symbolic data from a buffer in memory at addr and attempts to concretize it | def solve_buffer(self, addr, nbytes, constrain=False):
"""
Reads `nbytes` of symbolic data from a buffer in memory at `addr` and attempts to
concretize it
:param int address: Address of buffer to concretize
:param int nbytes: Size of buffer to concretize
:param bool cons... |
Mark parts of a buffer as symbolic ( demarked by the wildcard byte ) | def symbolicate_buffer(self, data, label='INPUT', wildcard='+', string=False, taint=frozenset()):
"""Mark parts of a buffer as symbolic (demarked by the wildcard byte)
:param str data: The string to symbolicate. If no wildcard bytes are provided,
this is the identity function on the fir... |
Create a mapping in Unicorn and note that we ll need it if we retry.: param uc: The Unicorn instance.: param address: The address which is contained by the mapping.: rtype Map | def _create_emulated_mapping(self, uc, address):
"""
Create a mapping in Unicorn and note that we'll need it if we retry.
:param uc: The Unicorn instance.
:param address: The address which is contained by the mapping.
:rtype Map
"""
m = self._cpu.memory.map_conta... |
Handle memory operations from unicorn. | def _hook_xfer_mem(self, uc, access, address, size, value, data):
"""
Handle memory operations from unicorn.
"""
assert access in (UC_MEM_WRITE, UC_MEM_READ, UC_MEM_FETCH)
if access == UC_MEM_WRITE:
self._cpu.write_int(address, value, size * 8)
# If client c... |
We hit an unmapped region ; map it into unicorn. | def _hook_unmapped(self, uc, access, address, size, value, data):
"""
We hit an unmapped region; map it into unicorn.
"""
try:
m = self._create_emulated_mapping(uc, address)
except MemoryException as e:
self._to_raise = e
self._should_try_agai... |
Handle software interrupt ( SVC/ INT ) | def _interrupt(self, uc, number, data):
"""
Handle software interrupt (SVC/INT)
"""
from ..native.cpu.abstractcpu import Interruption # prevent circular imports
self._to_raise = Interruption(number)
return True |
Emulate a single instruction. | def emulate(self, instruction):
"""
Emulate a single instruction.
"""
# The emulation might restart if Unicorn needs to bring in a memory map
# or bring a value from Manticore state.
while True:
self.reset()
# Establish Manticore state, potentia... |
A single attempt at executing an instruction. | def _step(self, instruction):
"""
A single attempt at executing an instruction.
"""
logger.debug("0x%x:\t%s\t%s"
% (instruction.address, instruction.mnemonic, instruction.op_str))
registers = set(self._cpu.canonical_registers)
# Refer to EFLAGS inst... |
r Recursive Length Prefix Encoding: param item: the object to encode either a string bytes bytearray int long or sequence | def rlp_encode(item):
r""" Recursive Length Prefix Encoding
:param item: the object to encode, either a string, bytes, bytearray, int, long, or sequence
https://github.com/ethereum/wiki/wiki/RLP
>>> rlp_encode('dog')
b'\x83dog'
>>> rlp_encode([ 'cat', 'dog' ])
b'\xc8\x83cat\x83dog'
... |
Check if expression is True and that it can not be False with current constraints | def must_be_true(self, constraints, expression) -> bool:
"""Check if expression is True and that it can not be False with current constraints"""
solutions = self.get_all_values(constraints, expression, maxcnt=2, silent=True)
return solutions == [True] |
Iteratively finds the maximum value for a symbol within given constraints.: param X: a symbol or expression: param M: maximum number of iterations allowed | def max(self, constraints, X: BitVec, M=10000):
"""
Iteratively finds the maximum value for a symbol within given constraints.
:param X: a symbol or expression
:param M: maximum number of iterations allowed
"""
assert isinstance(X, BitVec)
return self.optimize(con... |
Iteratively finds the minimum value for a symbol within given constraints. | def min(self, constraints, X: BitVec, M=10000):
"""
Iteratively finds the minimum value for a symbol within given constraints.
:param constraints: constraints that the expression must fulfil
:param X: a symbol or expression
:param M: maximum number of iterations allowed
... |
Returns the min and max possible values for x within given constraints | def minmax(self, constraints, x, iters=10000):
"""Returns the min and max possible values for x within given constraints"""
if issymbolic(x):
m = self.min(constraints, x, iters)
M = self.max(constraints, x, iters)
return m, M
else:
return x, x |
If we fail to parse the version we assume z3 s output has changed meaning it s a newer version than what s used now and therefore ok. | def _solver_version(self) -> Version:
"""
If we fail to parse the version, we assume z3's output has changed, meaning it's a newer
version than what's used now, and therefore ok.
Anticipated version_cmd_output format: 'Z3 version 4.4.2'
'Z3... |
Spawns z3 solver process | def _start_proc(self):
"""Spawns z3 solver process"""
assert '_proc' not in dir(self) or self._proc is None
try:
self._proc = Popen(shlex.split(self._command), stdin=PIPE, stdout=PIPE, bufsize=0, universal_newlines=True)
except OSError as e:
print(e, "Probably too... |
Stops the z3 solver process by: - sending an exit command to it - sending a SIGKILL signal - waiting till the process terminates ( so we don t leave a zombie process ) | def _stop_proc(self):
"""
Stops the z3 solver process by:
- sending an exit command to it,
- sending a SIGKILL signal,
- waiting till the process terminates (so we don't leave a zombie process)
"""
if self._proc is None:
return
if self._proc.re... |
Auxiliary method to reset the smtlib external solver to initial defaults | def _reset(self, constraints=None):
"""Auxiliary method to reset the smtlib external solver to initial defaults"""
if self._proc is None:
self._start_proc()
else:
if self.support_reset:
self._send("(reset)")
for cfg in self._init:
... |
Send a string to the solver. | def _send(self, cmd: str):
"""
Send a string to the solver.
:param cmd: a SMTLIBv2 command (ex. (check-sat))
"""
logger.debug('>%s', cmd)
try:
self._proc.stdout.flush()
self._proc.stdin.write(f'{cmd}\n')
except IOError as e:
ra... |
Reads the response from the solver | def _recv(self) -> str:
"""Reads the response from the solver"""
buf, left, right = self.__readline_and_count()
bufl = [buf]
while left != right:
buf, l, r = self.__readline_and_count()
bufl.append(buf)
left += l
right += r
buf = ... |
Check the satisfiability of the current state | def _is_sat(self) -> bool:
"""
Check the satisfiability of the current state
:return: whether current state is satisfiable or not.
"""
logger.debug("Solver.check() ")
start = time.time()
self._send('(check-sat)')
status = self._recv()
logger.debug... |
Auxiliary method to send an assert | def _assert(self, expression: Bool):
"""Auxiliary method to send an assert"""
assert isinstance(expression, Bool)
smtlib = translate_to_smtlib(expression)
self._send('(assert %s)' % smtlib) |
Ask the solver for one possible assignment for given expression using current set of constraints. The current set of expressions must be sat. | def _getvalue(self, expression):
"""
Ask the solver for one possible assignment for given expression using current set of constraints.
The current set of expressions must be sat.
NOTE: This is an internal method: it uses the current solver state (set of constraints!).
"""
... |
Check if two potentially symbolic values can be equal | def can_be_true(self, constraints, expression):
"""Check if two potentially symbolic values can be equal"""
if isinstance(expression, bool):
if not expression:
return expression
else:
# if True check if constraints are feasible
self... |
Returns a list with all the possible values for the symbol x | def get_all_values(self, constraints, expression, maxcnt=None, silent=False):
"""Returns a list with all the possible values for the symbol x"""
if not isinstance(expression, Expression):
return [expression]
assert isinstance(constraints, ConstraintSet)
assert isinstance(expr... |
Iteratively finds the maximum or minimum value for the operation ( Normally Operators. UGT or Operators. ULT ) | def optimize(self, constraints: ConstraintSet, x: BitVec, goal: str, M=10000):
"""
Iteratively finds the maximum or minimum value for the operation
(Normally Operators.UGT or Operators.ULT)
:param constraints: constraints to take into account
:param x: a symbol or expression
... |
Ask the solver for one possible result of given expression using given set of constraints. | def get_value(self, constraints, expression):
"""
Ask the solver for one possible result of given expression using given set of constraints.
"""
if not issymbolic(expression):
return expression
assert isinstance(expression, (Bool, BitVec, Array))
with constrai... |
Produce a summarized record name i. e. manticore. core. executor - > m. c. executor | def summarized_name(self, name):
"""
Produce a summarized record name
i.e. manticore.core.executor -> m.c.executor
"""
components = name.split('.')
prefix = '.'.join(c[0] for c in components[:-1])
return f'{prefix}.{components[-1]}' |
Colors the logging level in the logging record | def colored_level_name(self, levelname):
"""
Colors the logging level in the logging record
"""
if self.colors_disabled:
return self.plain_levelname_format.format(levelname)
else:
return self.colored_levelname_format.format(self.color_map[levelname], level... |
Helper for finding the closest NULL or effectively NULL byte from a starting address. | def _find_zero(cpu, constrs, ptr):
"""
Helper for finding the closest NULL or, effectively NULL byte from a starting address.
:param Cpu cpu:
:param ConstraintSet constrs: Constraints for current `State`
:param int ptr: Address to start searching for a zero from
:return: Offset from `ptr` to fi... |
strcmp symbolic model. | def strcmp(state, s1, s2):
"""
strcmp symbolic model.
Algorithm: Walks from end of string (minimum offset to NULL in either string)
to beginning building tree of ITEs each time either of the
bytes at current offset is symbolic.
Points of Interest:
- We've been building up a symbolic tree b... |
strlen symbolic model. | def strlen(state, s):
"""
strlen symbolic model.
Algorithm: Walks from end of string not including NULL building ITE tree when current byte is symbolic.
:param State state: current program state
:param int s: Address of string
:return: Symbolic strlen result
:rtype: Expression or int
"... |
Return all events that all subclasses have so far registered to publish. | def all_events(cls):
"""
Return all events that all subclasses have so far registered to publish.
"""
all_evts = set()
for cls, evts in cls.__all_events__.items():
all_evts.update(evts)
return all_evts |
This forwards signal to sink | def forward_events_to(self, sink, include_source=False):
"""This forwards signal to sink"""
assert isinstance(sink, Eventful), f'{sink.__class__.__name__} is not Eventful'
self._forwards[sink] = include_source |
Convenient access to shared context | def context(self):
""" Convenient access to shared context """
if self._context is not None:
return self._context
else:
logger.warning("Using shared context without a lock")
return self._executor._shared_context |
A context manager that provides safe parallel access to the global Manticore context. This should be used to access the global Manticore context when parallel analysis is activated. Code within the with block is executed atomically so access of shared variables should occur within. | def locked_context(self, key=None, value_type=list):
"""
A context manager that provides safe parallel access to the global Manticore context.
This should be used to access the global Manticore context
when parallel analysis is activated. Code within the `with` block is executed
... |
Returns a pstat. Stats instance with profiling results if run was called with should_profile = True. Otherwise returns None. | def get_profiling_stats(self):
"""
Returns a pstat.Stats instance with profiling results if `run` was called with `should_profile=True`.
Otherwise, returns `None`.
"""
profile_file_path = os.path.join(self.workspace, 'profiling.bin')
try:
return pstats.Stats(p... |
Runs analysis. | def run(self, procs=1, timeout=None, should_profile=False):
"""
Runs analysis.
:param int procs: Number of parallel worker processes
:param timeout: Analysis timeout, in seconds
"""
assert not self.running, "Manticore is already running."
self._start_run()
... |
Dispatches execution into one of Manticore s engines: evm or native. | def main():
"""
Dispatches execution into one of Manticore's engines: evm or native.
"""
args = parse_arguments()
if args.no_colors:
log.disable_colors()
sys.setrecursionlimit(consts.recursionlimit)
ManticoreBase.verbosity(args.v)
if args.argv[0].endswith('.sol'):
eth... |
Get the first nbits from value. | def GetNBits(value, nbits):
"""
Get the first `nbits` from `value`.
:param value: Source value from which to extract
:type value: int or long or BitVec
:param int nbits: How many bits to extract
:return: Low `nbits` bits of `value`.
:rtype int or long or BitVec
"""
# NOP if sizes ar... |
Convert a bitstring value of width bits to a signed integer representation. | def SInt(value, width):
"""
Convert a bitstring `value` of `width` bits to a signed integer
representation.
:param value: The value to convert.
:type value: int or long or BitVec
:param int width: The width of the bitstring to consider
:return: The converted value
:rtype int or long or ... |
The ARM LSL_C ( logical left shift with carry ) operation. | def LSL_C(value, amount, width):
"""
The ARM LSL_C (logical left shift with carry) operation.
:param value: Value to shift
:type value: int or long or BitVec
:param int amount: How many bits to shift it.
:param int width: Width of the value
:return: Resultant value and the carry result
... |
The ARM LSL ( logical left shift ) operation. | def LSL(value, amount, width):
"""
The ARM LSL (logical left shift) operation.
:param value: Value to shift
:type value: int or long or BitVec
:param int amount: How many bits to shift it.
:param int width: Width of the value
:return: Resultant value
:rtype int or BitVec
"""
if ... |
The ARM LSR_C ( logical shift right with carry ) operation. | def LSR_C(value, amount, width):
"""
The ARM LSR_C (logical shift right with carry) operation.
:param value: Value to shift
:type value: int or long or BitVec
:param int amount: How many bits to shift it.
:param int width: Width of the value
:return: Resultant value and carry result
:rt... |
The ARM LSR ( logical shift right ) operation. | def LSR(value, amount, width):
"""
The ARM LSR (logical shift right) operation.
:param value: Value to shift
:type value: int or long or BitVec
:param int amount: How many bits to shift it.
:param int width: Width of the value
:return: Resultant value
:rtype int or BitVec
"""
if... |
The ARM ASR_C ( arithmetic shift right with carry ) operation. | def ASR_C(value, amount, width):
"""
The ARM ASR_C (arithmetic shift right with carry) operation.
:param value: Value to shift
:type value: int or long or BitVec
:param int amount: How many bits to shift it.
:param int width: Width of the value
:return: Resultant value and carry result
... |
The ARM ASR ( arithmetic shift right ) operation. | def ASR(value, amount, width):
"""
The ARM ASR (arithmetic shift right) operation.
:param value: Value to shift
:type value: int or long or BitVec
:param int amount: How many bits to shift it.
:param int width: Width of the value
:return: Resultant value
:rtype int or BitVec
"""
... |
The ARM ROR_C ( rotate right with carry ) operation. | def ROR_C(value, amount, width):
"""
The ARM ROR_C (rotate right with carry) operation.
:param value: Value to shift
:type value: int or long or BitVec
:param int amount: How many bits to rotate it.
:param int width: Width of the value
:return: Resultant value and carry result
:rtype tu... |
The ARM ROR ( rotate right ) operation. | def ROR(value, amount, width):
"""
The ARM ROR (rotate right) operation.
:param value: Value to shift
:type value: int or long or BitVec
:param int amount: How many bits to rotate it.
:param int width: Width of the value
:return: Resultant value
:rtype int or BitVec
"""
if amoun... |
The ARM RRX ( rotate right with extend and with carry ) operation. | def RRX_C(value, carry, width):
"""
The ARM RRX (rotate right with extend and with carry) operation.
:param value: Value to shift
:type value: int or long or BitVec
:param int amount: How many bits to rotate it.
:param int width: Width of the value
:return: Resultant value and carry result
... |
The ARM RRX ( rotate right with extend ) operation. | def RRX(value, carry, width):
"""
The ARM RRX (rotate right with extend) operation.
:param value: Value to shift
:type value: int or long or BitVec
:param int amount: How many bits to rotate it.
:param int width: Width of the value
:return: Resultant value
:rtype int or BitVec
"""
... |
Policy shared context dictionary | def locked_context(self, key=None, default=dict):
""" Policy shared context dictionary """
keys = ['policy']
if key is not None:
keys.append(key)
with self._executor.locked_context('.'.join(keys), default) as policy_context:
yield policy_context |
Save summarize ( state ) on policy shared context before the state is stored | def _add_state_callback(self, state_id, state):
""" Save summarize(state) on policy shared context before
the state is stored
"""
summary = self.summarize(state)
if summary is None:
return
with self.locked_context('summaries', dict) as ctx:
ctx... |
Maintain our own copy of the visited set | def _visited_callback(self, state, pc, instr):
""" Maintain our own copy of the visited set
"""
with self.locked_context('visited', set) as ctx:
ctx.add(pc) |
Maintain our own copy of the visited set | def _visited_callback(self, state, pc, instr):
""" Maintain our own copy of the visited set
"""
pc = state.platform.current.PC
with self.locked_context('visited', dict) as ctx:
ctx[pc] = ctx.get(pc, 0) + 1 |
Executor context is a shared memory object. All workers share this. It needs a lock. Its used like this: | def locked_context(self, key=None, default=dict):
""" Executor context is a shared memory object. All workers share this.
It needs a lock. Its used like this:
with executor.context() as context:
visited = context['visited']
visited.append(state.cpu.PC)
... |
Enqueue state. Save state on storage assigns an id to it then add it to the priority queue | def enqueue(self, state):
"""
Enqueue state.
Save state on storage, assigns an id to it, then add it to the
priority queue
"""
# save the state to secondary storage
state_id = self._workspace.save_state(state)
self.put(state_id)
self._p... |
Enqueue it for processing | def put(self, state_id):
""" Enqueue it for processing """
self._states.append(state_id)
self._lock.notify_all()
return state_id |
Dequeue a state with the max priority | def get(self):
""" Dequeue a state with the max priority """
# A shutdown has been requested
if self.is_shutdown():
return None
# if not more states in the queue, let's wait for some forks
while len(self._states) == 0:
# if no worker is running, bail out... |
Fork state on expression concretizations. Using policy build a list of solutions for expression. For the state on each solution setting the new state with setstate | def fork(self, state, expression, policy='ALL', setstate=None):
"""
Fork state on expression concretizations.
Using policy build a list of solutions for expression.
For the state on each solution setting the new state with setstate
For example if expression is a Bool it may have... |
Entry point of the Executor ; called by workers to start analysis. | def run(self):
"""
Entry point of the Executor; called by workers to start analysis.
"""
# policy_order=self.policy_order
# policy=self.policy
current_state = None
current_state_id = None
with WithKeyboardInterruptAs(self.shutdown):
# notify s... |
Constructor for Linux binary analysis. | def linux(cls, path, argv=None, envp=None, entry_symbol=None, symbolic_files=None, concrete_start='', pure_symbolic=False, stdin_size=None, **kwargs):
"""
Constructor for Linux binary analysis.
:param str path: Path to binary to analyze
:param argv: Arguments to provide to the binary
... |
Constructor for Decree binary analysis. | def decree(cls, path, concrete_start='', **kwargs):
"""
Constructor for Decree binary analysis.
:param str path: Path to binary to analyze
:param str concrete_start: Concrete stdin to use before symbolic input
:param kwargs: Forwarded to the Manticore constructor
:return... |
A decorator used to register a hook function to run before analysis begins. Hook function takes one: class: ~manticore. core. state. State argument. | def init(self, f):
"""
A decorator used to register a hook function to run before analysis begins. Hook
function takes one :class:`~manticore.core.state.State` argument.
"""
def callback(manticore_obj, state):
f(state)
self.subscribe('will_start_run', types.Me... |
A decorator used to register a hook function for a given instruction address. Equivalent to calling: func: ~add_hook. | def hook(self, pc):
"""
A decorator used to register a hook function for a given instruction address.
Equivalent to calling :func:`~add_hook`.
:param pc: Address of instruction to hook
:type pc: int or None
"""
def decorator(f):
self.add_hook(pc, f)
... |
Add a callback to be invoked on executing a program counter. Pass None for pc to invoke callback on every instruction. callback should be a callable that takes one: class: ~manticore. core. state. State argument. | def add_hook(self, pc, callback):
"""
Add a callback to be invoked on executing a program counter. Pass `None`
for pc to invoke callback on every instruction. `callback` should be a callable
that takes one :class:`~manticore.core.state.State` argument.
:param pc: Address of inst... |
Invoke all registered generic hooks | def _hook_callback(self, state, pc, instruction):
'Invoke all registered generic hooks'
# Ignore symbolic pc.
# TODO(yan): Should we ask the solver if any of the hooks are possible,
# and execute those that are?
if issymbolic(pc):
return
# Invoke all pc-spe... |
A helper method used to resolve a symbol name into a memory address when injecting hooks for analysis. | def resolve(self, symbol):
"""
A helper method used to resolve a symbol name into a memory address when
injecting hooks for analysis.
:param symbol: function name to be resolved
:type symbol: string
:param line: if more functions present, optional line number can be inc... |
helper method for determining binary architecture | def binary_arch(binary):
"""
helper method for determining binary architecture
:param binary: str for binary to introspect.
:rtype bool: True for x86_64, False otherwise
"""
with open(binary, 'rb') as f:
elffile = ELFFile(f)
if elffile['e_machine'] == 'EM_X86_64':
r... |
helper method for getting all binary symbols with SANDSHREW_ prepended. We do this in order to provide the symbols Manticore should hook on to perform main analysis. | def binary_symbols(binary):
"""
helper method for getting all binary symbols with SANDSHREW_ prepended.
We do this in order to provide the symbols Manticore should hook on to
perform main analysis.
:param binary: str for binary to instrospect.
:rtype list: list of symbols from binary
"""
... |
Get a configuration variable group named |name| | def get_group(name: str) -> _Group:
"""
Get a configuration variable group named |name|
"""
global _groups
if name in _groups:
return _groups[name]
group = _Group(name)
_groups[name] = group
return group |
Save current config state to an yml file stream identified by |f| | def save(f):
"""
Save current config state to an yml file stream identified by |f|
:param f: where to write the config file
"""
global _groups
c = {}
for group_name, group in _groups.items():
section = {var.name: var.value for var in group.updated_vars()}
if not section:
... |
Load an yml - formatted configuration from file stream |f| | def parse_config(f):
"""
Load an yml-formatted configuration from file stream |f|
:param file f: Where to read the config.
"""
try:
c = yaml.safe_load(f)
for section_name, section in c.items():
group = get_group(section_name)
for key, val in section.items()... |
Load config overrides from the yml file at |path| or from default paths. If a path is provided and it does not exist raise an exception | def load_overrides(path=None):
"""
Load config overrides from the yml file at |path|, or from default paths. If a path
is provided and it does not exist, raise an exception
Default paths: ./mcore.yml, ./.mcore.yml, ./manticore.yml, ./.manticore.yml.
"""
if path is not None:
names = [pa... |
Import all defined config vars into |args| for parsing command line.: param args: A container for argparse vars: type args: argparse. ArgumentParser or argparse. _ArgumentGroup: return: | def add_config_vars_to_argparse(args):
"""
Import all defined config vars into |args|, for parsing command line.
:param args: A container for argparse vars
:type args: argparse.ArgumentParser or argparse._ArgumentGroup
:return:
"""
global _groups
for group_name, group in _groups.items():... |
Bring in provided config values to the args parser and import entries to the config from all arguments that were actually passed on the command line | def process_config_values(parser: argparse.ArgumentParser, args: argparse.Namespace):
"""
Bring in provided config values to the args parser, and import entries to the config
from all arguments that were actually passed on the command line
:param parser: The arg parser
:param args: The value that p... |
Add a variable named |name| to this value group optionally giving it a default value and a description. | def add(self, name: str, default=None, description: str=None):
"""
Add a variable named |name| to this value group, optionally giving it a
default value and a description.
Variables must be added with this method before they can be set or read.
Reading a variable replaces the va... |
Like add but can tolerate existing values ; also updates the value. | def update(self, name: str, value=None, default=None, description: str=None):
"""
Like add, but can tolerate existing values; also updates the value.
Mostly used for setting fields from imported INI files and modified CLI flags.
"""
if name in self._vars:
description... |
Return the description or a help string of variable identified by |name|. | def get_description(self, name: str) -> str:
"""
Return the description, or a help string of variable identified by |name|.
"""
if name not in self._vars:
raise ConfigError(f"{self.name}.{name} not defined.")
return self._vars[name].description |
Communicate with the child process without closing stdin. | def correspond(text):
"""Communicate with the child process without closing stdin."""
subproc.stdin.write(text)
subproc.stdin.flush()
return drain() |
Returns the function signature for the specified name and Solidity JSON metadata inputs array. | def function_signature_for_name_and_inputs(name: str, inputs: Sequence[Mapping[str, Any]]) -> str:
"""Returns the function signature for the specified name and Solidity JSON metadata inputs array.
The ABI specification defines the function signature as the function name followed by the parenthesised li... |
Equivalent to function_signature_for_name_and_inputs ( components ). | def tuple_signature_for_components(components: Sequence[Mapping[str, Any]]) -> str:
"""Equivalent to ``function_signature_for_name_and_inputs('', components)``."""
ts = []
for c in components:
t: str = c['type']
if t.startswith('tuple'):
assert len(t) == 5... |
Returns the tuple type signature for the arguments of the contract constructor. | def get_constructor_arguments(self) -> str:
"""Returns the tuple type signature for the arguments of the contract constructor."""
item = self._constructor_abi_item
return '()' if item is None else self.tuple_signature_for_components(item['inputs']) |
Solidity source code snippet related to asm_pos evm bytecode offset. If runtime is False initialization bytecode source map is used | def get_source_for(self, asm_offset, runtime=True):
""" Solidity source code snippet related to `asm_pos` evm bytecode offset.
If runtime is False, initialization bytecode source map is used
"""
srcmap = self.get_srcmap(runtime)
try:
beg, size, _, _ = srcmap[asm_... |
Returns a copy of the Solidity JSON ABI item for the contract constructor. | def constructor_abi(self) -> Dict[str, Any]:
"""Returns a copy of the Solidity JSON ABI item for the contract constructor.
The content of the returned dict is described at https://solidity.readthedocs.io/en/latest/abi-spec.html#json_
"""
item = self._constructor_abi_item
if item... |
Returns a copy of the Solidity JSON ABI item for the function associated with the selector hsh. | def get_abi(self, hsh: bytes) -> Dict[str, Any]:
"""Returns a copy of the Solidity JSON ABI item for the function associated with the selector ``hsh``.
If no normal contract function has the specified selector, a dict describing the default or non-default
fallback function is returned.
... |
Returns the tuple type signature for the arguments of the function associated with the selector hsh. | def get_func_argument_types(self, hsh: bytes):
"""Returns the tuple type signature for the arguments of the function associated with the selector ``hsh``.
If no normal contract function has the specified selector,
the empty tuple type signature ``'()'`` is returned.
"""
if not i... |
Returns the tuple type signature for the output values of the function associated with the selector hsh. | def get_func_return_types(self, hsh: bytes) -> str:
"""Returns the tuple type signature for the output values of the function
associated with the selector ``hsh``.
If no normal contract function has the specified selector,
the empty tuple type signature ``'()'`` is returned.
"""... |
Returns the name of the normal function with the selector hsh or { fallback } if no such function exists. | def get_func_name(self, hsh: bytes) -> str:
"""Returns the name of the normal function with the selector ``hsh``,
or ``'{fallback}'`` if no such function exists.
"""
if not isinstance(hsh, (bytes, bytearray)):
raise TypeError('The selector argument must be a concrete byte arr... |
Returns the signature of the normal function with the selector hsh or None if no such function exists. | def get_func_signature(self, hsh: bytes) -> Optional[str]:
"""Returns the signature of the normal function with the selector ``hsh``,
or ``None`` if no such function exists.
This function returns ``None`` for any selector that will be dispatched to a fallback function.
"""
if no... |
The selectors of all normal contract functions plus self. fallback_function_selector if the contract has a non - default fallback function. | def function_selectors(self) -> Iterable[bytes]:
"""The selectors of all normal contract functions,
plus ``self.fallback_function_selector`` if the contract has a non-default fallback function.
"""
selectors = self._function_signatures_by_selector.keys()
if self._fallback_functio... |
The selectors of all normal contract functions plus self. fallback_function_selector. | def hashes(self) -> Tuple[bytes, ...]:
"""The selectors of all normal contract functions, plus ``self.fallback_function_selector``."""
selectors = self._function_signatures_by_selector.keys()
return (*selectors, self.fallback_function_selector) |
Converts a Manticore permission string into a Unicorn permission: param m_perms: Manticore perm string ( rwx ): return: Unicorn Permissions | def convert_permissions(m_perms):
"""
Converts a Manticore permission string into a Unicorn permission
:param m_perms: Manticore perm string ('rwx')
:return: Unicorn Permissions
"""
permissions = UC_PROT_NONE
if 'r' in m_perms:
permissions |= UC_PROT_READ
if 'w' in m_perms:
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.