def sym_exec(self, main_address=None, creation_code=None, contract_name=None, code_extension=None):
logging.debug("Starting LASER execution")
self.time = datetime.now()
if main_address:
logging.info("Starting message call transaction to {}".format(main_address))
execute_message_call(self, main_address)
elif creation_code:
logging.info("Starting contract creation transaction")
created_account = execute_contract_creation(self, creation_code, contract_name=contract_name, code_extension=code_extension)
logging.info("Finished contract creation, found {} open states".format(len(self.open_states)))
if len(self.open_states) == 0:
print("No contract was created during the execution of contract creation "
"Try to increase the resources for creation exection (max-depth or create_timeout)")
printd("Finished outer creation")
# Reset code coverage
self.coverage = {}
self.time = datetime.now()
logging.info("Starting message call transaction")
execute_message_call(self, created_account.address)
#self.time = datetime.now()
#execute_message_call(self, created_account.address)
logging.info("Finished symbolic execution")
logging.info("%d nodes, %d edges, %d total states", len(self.nodes), len(self.edges), self.total_states)
for code, coverage in self.coverage.items():
cov = reduce(lambda sum_, val: sum_ + 1 if val else sum_, coverage[1]) / float(coverage[0]) * 100
logging.info("Achieved {} coverage for code: {}".format(cov, code))
def _execute_transactions(self, address):
"""This function executes multiple transactions on the address based on
the coverage.
:param address: Address of the contract
:return:
"""
self.coverage = {}
for i in range(self.transaction_count):
initial_coverage = self._get_covered_instructions()
self.time = datetime.now()
log.info(
"Starting message call transaction, iteration: {}, {} initial states".format(
i, len(self.open_states)
)
)
execute_message_call(self, address)
end_coverage = self._get_covered_instructions()
log.info(
"Number of new instructions covered in tx %d: %d"
% (i, end_coverage - initial_coverage)
)
def sym_exec(self,
main_address=None,
creation_code=None,
contract_name=None):
logging.debug("Starting LASER execution")
self.time = datetime.now()
if main_address:
logging.info(
"Starting message call transaction to {}".format(main_address))
execute_message_call(self, main_address)
elif creation_code:
logging.info("Starting contract creation transaction")
created_account = execute_contract_creation(
self, creation_code, contract_name)
logging.info(
"Finished contract creation, found {} open states".format(
len(self.open_states)))
if len(self.open_states) == 0:
logging.warning(
"No contract was created during the execution of contract creation "
"Increase the resources for creation execution (--max-depth or --create-timeout)"
)
# Reset code coverage
self.coverage = {}
for i in range(self.max_transaction_count):
initial_coverage = self._get_covered_instructions()
self.time = datetime.now()
logging.info(
"Starting message call transaction, iteration: {}".format(
i))
execute_message_call(self, created_account.address)
end_coverage = self._get_covered_instructions()
if end_coverage == initial_coverage:
break
logging.info("Finished symbolic execution")
logging.info(
"%d nodes, %d edges, %d total states",
len(self.nodes),
len(self.edges),
self.total_states,
)
for code, coverage in self.coverage.items():
cov = (reduce(lambda sum_, val: sum_ + 1 if val else sum_,
coverage[1]) / float(coverage[0]) * 100)
logging.info("Achieved {} coverage for code: {}".format(cov, code))
def _execute_transactions(self, address):
"""
This function executes multiple transactions on the address based on the coverage
:param address: Address of the contract
:return:
"""
self.coverage = {}
for i in range(self.max_transaction_count):
initial_coverage = self._get_covered_instructions()
self.time = datetime.now()
logging.info(
"Starting message call transaction, iteration: {}".format(i))
execute_message_call(self, address)
end_coverage = self._get_covered_instructions()
if end_coverage == initial_coverage:
break
def _execute_transactions(self, address):
"""This function executes multiple transactions on the address
:param address: Address of the contract
:return:
"""
for i in range(self.transaction_count):
self.time = datetime.now()
log.info(
"Starting message call transaction, iteration: {}, {} initial states"
.format(i, len(self.open_states)))
for hook in self._start_sym_trans_hooks:
hook()
execute_message_call(self, address)
for hook in self._stop_sym_trans_hooks:
hook()
def _execute_transactions(self, address, priority=None):
"""
This function executes multiple transactions on the address based on the coverage
:param address: Address of the contract
:return:
"""
self.coverage = {}
for i in range(self.transaction_count):
initial_coverage = self._get_covered_instructions()
self.time = datetime.now()
logging.info(
"Starting message call transaction, iteration: {}".format(i))
if priority is None:
execute_message_call(self, address, priority)
else:
heuristic_message_call(self, address, priority)
end_coverage = self._get_covered_instructions()
logging.info("Number of new instructions covered in tx %d: %d" %
(i, end_coverage - initial_coverage))
