def test_symbolic_int(self):
# Arrange
name = 'TestVar1'
z3_ctx = z3.Context()
vsort = z3.IntSort(ctx=z3_ctx)
value = 10
# Act
var = SMTVar(name, vsort)
var_before = var.var
get_var_before = var.get_var()
with self.assertRaises(RuntimeError):
self.assertEquals(var.get_value(), value)
# Concertize the value
solver = z3.Solver(ctx=z3_ctx)
solver.add(var.var == value)
self.assertEquals(solver.check(), z3.sat)
model = solver.model()
var.eval(model)
# Assert
self.assertEquals(var.name, name)
self.assertEquals(var.vsort, vsort)
self.assertTrue(is_symbolic(var_before))
self.assertTrue(is_symbolic(get_var_before))
self.assertEquals(var.name, name)
self.assertEquals(var.vsort, vsort)
self.assertEquals(var.var, value)
self.assertEquals(var.get_value(), value)
self.assertTrue(is_symbolic(var.get_var()))
def reset(self, context=None):
if context != None:
self.context = context
else:
self.context = z3.Context()
self.sort_dict = {} # sorts
self.symbol_dict = {} # constant and function symbols
def _context(self):
try:
return self._tls.context
except AttributeError:
self._tls.context = z3.Context() if threading.current_thread(
).name != 'MainThread' else z3.main_ctx()
return self._tls.context
def myExternalSolver(ctx, node, addr=None):
"""
The particularity of this sample is that we use an external solver to solve
queries instead of using the internal Triton's solver (even if in both cases
it uses z3). The point here is to show that Triton can provide generic smt2
outputs and theses outputs can be send to external solvers and get back model
which then are sent to Triton.
"""
import z3
expr = ctx.newSymbolicExpression(node, "Custom for Solver")
smtFormat = '(set-logic QF_BV) %s %s (check-sat) (get-model)' %(getVarSyntax(ctx), getSSA(ctx, expr))
c = z3.Context()
s = z3.Solver(ctx=c)
s.add(z3.parse_smt2_string(smtFormat, ctx=c))
if addr:
debug('[+] Solving condition at %#x' %(addr))
if s.check() == z3.sat:
ret = dict()
model = s.model()
for x in model:
ret.update({int(str(x).split('_')[1], 10): int(str(model[x]), 10)})
return ret
else:
debug('[-] unsat :(')
sys.exit(-1)
return
def calculate_system(self, entity=None, include_subentities=True):
logger.debug("FAST: Calculating for all entities")
if not hasattr(self, "cache"):
self.init_z3_constraints_and_vars()
all_dts = []
# """ do the other things """
new_cache = translate_to_context(self.cache, z3.Context())
for influence in model.get_all_influences(entity):
if self.contains_if_condition(influence):
self.get_condition_change_enablers(influence, all_dts,
new_cache)
# updates = [up for up in get_updates(self.entity) if up.state == up._parent.current]
for update in model.get_all_updates(entity):
if update.state is update._parent.current: # only the currently active updates
if self.contains_if_condition(update):
self.get_condition_change_enablers(update, all_dts,
new_cache)
# TODO: check for transitions whether they can be done by time only
for trans in model.get_all_transitions(entity):
if trans._parent.current is trans.source:
self.get_transition_time(trans, all_dts, new_cache)
""" Return all behaviour change times """
return all_dts
def __init__(self, args):
ctx = z3.Context()
self.fp = z3.Fixedpoint(ctx=ctx)
self.args = args
self.log = LoggingManager.get_logger(__name__)
self.prdes = None
return
def test_symbolic_enum(self):
# Arrange
values = ['A', 'B', 'C']
sort_name = 'TestType'
name = 'TestVar1'
value = 'A'
z3_ctx = z3.Context()
vsort = EnumType(sort_name, values, z3_ctx=z3_ctx)
# Act
var = SMTVar(name, vsort)
# Assert
self.assertEquals(var.name, name)
self.assertEquals(var.vsort, vsort)
self.assertTrue(is_symbolic(var.var))
self.assertTrue(is_symbolic(var.get_var()))
with self.assertRaises(RuntimeError):
self.assertEquals(var.get_value(), 10)
# Concertize the value
solver = z3.Solver(ctx=z3_ctx)
solver.add(var.var == vsort.get_symbolic_value(value))
self.assertEquals(solver.check(), z3.sat)
model = solver.model()
var.eval(model)
self.assertEquals(var.name, name)
self.assertEquals(var.vsort, vsort)
self.assertEquals(var.var, vsort.get_symbolic_value(value))
self.assertEquals(var.get_value(), value)
self.assertTrue(is_symbolic(var.get_var()))
def getCtx() -> z3.Context:
global ctxHolder
ctx = getattr(ctxHolder, "ctx", None)
if (ctx == None):
ctx = z3.Context()
ctxHolder.ctx = ctx
return ctx
def main(argv):
args = parseArgs(argv[1:])
# get the names of inductive assumps first
iass = set()
cf = open(args.cert_mis_file)
for line in cf:
r = re.match("\s*\(\s*assert\s+(pre![^\)|^\s]+)", line)
if r is not None: iass.add(r.group(1))
# now the invariants
ctx = z3.Context()
fmla = z3.parse_smt2_file(args.ass_inv_file, ctx=ctx)
lemmas = []
assert z3.is_and(fmla), \
"invariant file should be a set of assertions"
for l in fmla.children():
assert z3u.isZ3Implies(l), \
"assertions in the invariant file should be implications"
name = str(l.arg(0).decl())
assert name.startswith("pre!"), \
"implicants in the invariant should start with pre!"
if name in iass: lemmas.append(l.arg(1))
# dump the collected lemmas
out = sys.stdout if args.out == '-' else open(args.out, 'w')
z3u.to_smtlib(lemmas, out)
def checkSolver(self, stmt, endLine, expanderGenerator):
"""Check the given statement for correctness and return True if it is satisfyable."""
# Context Creation
ctx = z3.Context()
model = None
check = None
sat = False
try:
s = z3.Solver(ctx=ctx)
if expanderGenerator is not None:
stmt += expanderGenerator(ctx)
expression = z3.parse_smt2_string(stmt, ctx=ctx)
s.add(expression)
check = s.check()
sat = check.r > 0
if sat:
model = s.model()
except z3.Z3Exception as e:
self.logger.error("Invalid SMT!")
return sat, endLine, model, ctx, check
def chc_solve_with_fp(db, args, opts):
if args.fresh:
ctx = z3.Context()
else:
ctx = db.get_ctx()
fp = z3.Fixedpoint(ctx=ctx)
db.mk_fixedpoint(fp=fp)
if args.st:
fp.set("print_statistics", True)
if args.pp:
fp.set("xform.slice", True)
fp.set("xform.inline_linear", True)
fp.set("xform.inline_eager", True)
else:
fp.set("xform.slice", False)
fp.set("xform.inline_linear", False)
fp.set("xform.inline_eager", False)
if args.spctr is not None:
fp.set("spacer.trace_file", args.spctr)
for k, v in opts.items():
fp.set(k, v)
for q in db.get_queries():
qf = q.mk_query()
if qf.ctx != ctx:
qf = qf.translate(ctx)
res = fp.query(qf)
return res
def main(argv):
print 'In main'
args = parseArgs(argv[1:])
ctx = z3.Context()
fmla = z3.parse_smt2_file(args.file, ctx=ctx)
msg = 'Solving'
if not args.no_blast:
msg = msg + ' (blasted)'
blasted = bitblast(fmla)
else:
blasted = fmla
msg = msg + " ..."
if args.o <> None:
with open(args.o, 'w') as f:
f.write(blasted.sexpr())
print msg
solver = z3.Solver(ctx=ctx)
solver.add(blasted)
res = solver.check()
print res
return 0
def test_fresh_const_name(self):
ctx = SolverContext(z3.Context())
name1 = ctx.fresh_constraint_name()
name2 = ctx.fresh_constraint_name()
self.assertTrue(isinstance(name1, basestring))
self.assertTrue(isinstance(name2, basestring))
self.assertFalse(name1 == name2)
def parallelRun(self, smt2_file):
"""
Job spanner
"""
ctx = z3.Context()
fp = z3.Fixedpoint(ctx=ctx)
jobs = []
with stats.timer('Parse'):
self.log.info('Parsing ... ' + str(smt2_file))
queries = fp.parse_file(smt2_file)
stats.stop('Parse')
self.log.info("Parsing time ... " + str(stats.get('Parse')) +
" ms")
n_function = len(queries)
n_query = n_function if self.args.func < 0 or self.args.func > n_function else self.args.func
self.log.info("Number of functions ... " + str(n_function))
self.log.info("Number of jobs ... " + str(n_query))
all_results = ""
pool_jobs = Pool(processes=n_query)
try:
for q in range(n_query):
query = queries[q]
function_name = self.getFunctionName(query)
self.log.info("Checking feasibility of ... " +
str(function_name))
#job_result = pool_jobs.apply_async(jobStarter, (self.args, qi, smt2_file, ), callback=self.onReturn)
job_result = pool_jobs.apply_async(jobStarter, (
self.args,
q,
smt2_file,
))
job_result.wait(timeout=self.args.timeout)
if job_result.ready():
out = ""
try:
out = job_result.get()
if bench: print out
except Exception as e:
print str(e)
continue
all_results += out + "\n-----------------------\n"
else:
out = out_message % (function_name, "TIMEOUT", "", "",
"", "", "")
out = bcolors.WARNING + out + bcolors.ENDC
if bench: print out
all_results += out + "\n------- ----------------\n"
pool_jobs.close()
pool_jobs.terminate()
pool_jobs.join()
if self.args.save:
f_name = ntpath.basename(smt2_file) + "_feas.txt"
with open(f_name, "w") as f:
f.write(all_results)
else:
print "\n\t ========= SUMMARY SEAHORN INCONSISTENCY CHECKS ========"
print all_results
except Exception as e:
self.log.exception(str(e))
def create_context(announcements,
prefix_list=None,
peer_list=None,
as_path_list=None,
next_hop_list=None,
create_as_paths=True):
"""
Creates the SMT context that contains all the known announcements
:return: SMTContext
"""
prefix_list = prefix_list if prefix_list else []
peer_list = peer_list if peer_list else []
as_path_list = as_path_list if as_path_list else []
as_path_list = [get_as_path_key(p) for p in as_path_list]
next_hope_list = next_hop_list if next_hop_list else []
announcements = announcements if announcements else []
assert announcements, "No announcements defined to extract context from"
ctx = SolverContext(z3.Context())
# Prefixes
read_list = [x.prefix for x in announcements if not is_empty(x.prefix)]
prefix_list = list(set(read_list + prefix_list))
prefix_list = [sanitize_smt_name(prefix) for prefix in prefix_list]
ctx.create_enum_type(PREFIX_SORT, prefix_list)
# Peers
read_list = [x.peer for x in announcements if not is_empty(x.peer)]
peer_list = list(set(read_list + peer_list))
ctx.create_enum_type(PEER_SORT, peer_list)
# BGP announcement origins
origin_list = BGP_ATTRS_ORIGIN.__members__.keys()
ctx.create_enum_type(BGP_ORIGIN_SORT, origin_list)
# AS path list
if create_as_paths:
read_list = [
get_as_path_key(x.as_path) for x in announcements
if not is_empty(x.as_path)
]
as_path_list = list(set(read_list + as_path_list))
ctx.create_enum_type(ASPATH_SORT, as_path_list)
# Next Hop
read_list = [
x.next_hop for x in announcements if not is_empty(x.next_hop)
]
origin_next_hop = '0.0.0.0'
read_list.append(origin_next_hop)
next_hope_list = list(set(read_list + next_hope_list))
next_hope_list = [
sanitize_smt_name(next_hop) for next_hop in next_hope_list
]
vsort = ctx.create_enum_type(NEXT_HOP_SORT, next_hope_list)
ctx.communities = announcements[0].communities.keys()
ctx.origin_next_hop = sanitize_smt_name(origin_next_hop)
ctx.origin_next_hop_var = vsort.get_symbolic_value(ctx.origin_next_hop)
return ctx
def solve_and_proof(tm):
"""Use veriT to determine whether a logical term is satisfiable."""
s = z3wrapper.solve_core(z3.Solver(ctx=z3.Context()) ,tm, False)
with open("proof.smt2", "a") as f:
f.seek(0)
f.truncate()
f.write("(set-logic LRA)\n" + s.to_smt2())
proof_rec("proof.smt2")
def test_create_var_prefix(self):
# Arrange
ctx = SolverContext(z3.Context())
prefix = 'CustPrefix'
# Act
var = ctx.create_fresh_var(z3.IntSort(), value=10, name_prefix=prefix)
# Assert
self.assertTrue(isinstance(var, SMTVar))
self.assertTrue(var.name.startswith(prefix))
def parse_exp(exp_name):
exp_folder = os.path.join(MEDIA, exp_name)
nodes_list = []
run_cmd = ""
stdout = safe_read(os.path.join(exp_folder, "stdout"))
stderr = safe_read(os.path.join(exp_folder, "stderr"))
spacer_log = safe_read(os.path.join(exp_folder, "spacer.log"))
run_cmd = safe_read(os.path.join(exp_folder, "run_cmd"))[0].strip()
temp_var_names = safe_read(os.path.join(exp_folder, "var_names"))
var_names = temp_var_names[0].strip() if temp_var_names != [] else ""
expr_map = get_expr_map(exp_name)
rels = []
status = "success"
spacer_state = get_spacer_state(stderr, stdout)
#generate var_decls
try:
print("trying to parse input")
new_context = z3.Context()
new_env = pysmt.environment.Environment()
db = H.load_horn_db_from_file(
os.path.join(exp_folder, "input_file.smt2"), new_context, new_env)
print("done load horndb")
for rel_name in db._rels:
rel = db.get_rel(rel_name)
rels.append(rel)
with open(os.path.join(exp_folder, "var_decls"), "w") as f:
for rel in rels:
save_var_rels(rel, f)
print("done parsing input")
except:
traceback.print_exc()
status = "error in loading horndb. skip parsing the file"
print(status)
#parse events
nodes_list = parse(spacer_log)
res = {
'status': status,
'spacer_state': spacer_state,
'nodes_list': nodes_list,
'run_cmd': run_cmd,
'var_names': var_names,
'expr_map': expr_map
}
#write to db
if spacer_state != "running":
try:
insert_db(
'REPLACE INTO nodes_list(exp_name, nodes_list) VALUES (?,?)',
(exp_name, json.dumps(res)))
except:
traceback.print_exc()
return res
def __init__(self, *args, **kwargs):
# z3.set_param(auto_config=False)
# http://stackoverflow.com/questions/18770582/z3-offering-random-solutions-in-solving
# z3.set_param('smt.phase_selection',0)
# z3.set_param('smt.random_seed',0)
import os
z3.init(os.getenv('Z3_LIBRARY_PATH', '.'))
self.context_obj = z3.Context(*args, **kwargs)
self.interpretation_map = {}
self.solvers = []
def test_register_var(self):
name = 'TestVar1'
vsort = z3.IntSort()
var = SMTVar(name, vsort)
ctx = SolverContext(z3.Context())
ctx._register_var(var)
self.assertTrue(var.name in ctx._vars)
with self.assertRaises(ValueError):
ctx._register_var(var)
def main(argv):
args = parseArgs(argv[1:])
stat('Result', 'UNKNOWN')
ctx = z3.Context()
fp = z3.Fixedpoint(ctx=ctx)
zus = Zustre(args, ctx, fp)
if args.no_solving:
zus.encode()
else:
zus.encodeAndSolve()
def __init__(self, args):
verbose = args.verbose
self.args = args
self.ctx = z3.Context()
self.fp = z3.Fixedpoint(ctx=self.ctx)
self.preds = []
self.ee_idx = [] #entry/exit vars
self.feasible_flag = [] # keep track of the feasible path
self.non_feasible_flag = [] # keep track of the infesible path
return
def test_fresh_const_name_prefix(self):
# Arrange
ctx = SolverContext(z3.Context())
prefix = 'CustPrefix'
# Act
name1 = ctx.fresh_constraint_name(prefix=prefix)
name2 = ctx.fresh_constraint_name(prefix=prefix)
# Assert
self.assertTrue(isinstance(name1, basestring))
self.assertTrue(isinstance(name2, basestring))
self.assertFalse(name1 == name2)
self.assertTrue(name1.startswith(prefix))
self.assertTrue(name2.startswith(prefix))
def test_get_constraints(self):
var1 = SMTVar('var1', z3.IntSort())
var2 = SMTVar('var1', z3.IntSort())
const = var1.var + var2.var > 10
name = 'cosnt1'
ctx = SolverContext(z3.Context())
ctx.register_constraint(const, name)
self.assertIsNotNone(ctx.get_constraint(name))
self.assertIsNotNone(ctx.get_constraints_info(name))
with self.assertRaises(ValueError):
ctx.get_constraint('NotRegistered')
with self.assertRaises(ValueError):
ctx.get_constraints_info('NotRegistered')
def cmd(n, m, i, output_dir, dims, timeout, incremental, copy_last):
"""Assume that an NxM matrix is encoded as a binary number and is passed as I.
Try to see whether the scoring pattern can be fit into 2D and save the output embeddings, if it can be."""
output_dir = os.path.join(output_dir, f'{i}')
os.makedirs(output_dir, exist_ok=True)
output_file = os.path.join(output_dir, f'{dims}D.out')
prev_output_file = os.path.join(output_dir, '{}D.out'.format(dims - 1))
if os.path.exists(output_file) and incremental:
print(
'Not running for m={}, n={}, i={} as the file {} already exists.'.
format(m, n, i, output_file))
else:
solved = False
if os.path.exists(prev_output_file) and copy_last:
with open(prev_output_file) as f:
prev_dim_res = f.readline().strip()
if prev_dim_res == 'sat':
with open(output_file, 'wt') as f:
f.write('sat')
solved = True
if not solved:
M = i_to_M(n, m, i)
voting_pats = D.sign_mat_to_voting_pats(M)
ctx = z3.Context()
prob, c_vars, v_vars = D.create_z3_prob(
ctx=ctx, n_dim=dims, voting_patterns=voting_pats)
prob.set('timeout', timeout)
res = prob.check()
if str(res) == 'sat':
c_vec, v_vec = D.make_vectors_from_z3_soln(prob=prob,
c_vars=c_vars,
v_vars=v_vars)
c_file = output_file + '.c_vecs'
v_file = output_file + '.v_vecs'
np.savetxt(c_file, c_vec)
np.savetxt(v_file, v_vec)
with open(output_file, 'wt') as f:
f.write(str(res))
def _worker(key_idx):
k_id = key_ids[key_idx]
M = D.make_M_from_df_generic(df=df, key_name=key, key_value=k_id)
voting_pats = D.sign_mat_to_voting_pats(M)
unique_voting_pats = list(set(tuple(x) for x in voting_pats))
ctx = z3.Context()
prob, _, _ = D.create_z3_prob(ctx=ctx,
n_dim=n_dims,
voting_patterns=unique_voting_pats)
prob.set('timeout', timeout)
res = prob.check()
return {key: k_id, '{}D_sat'.format(n_dims): str(res)}
def singleRun(self, smt2_file):
"""
Single run
"""
ctx = z3.Context()
fp = z3.Fixedpoint(ctx=ctx)
with stats.timer('Parse'):
self.log.info('Parsing ... ' + str(smt2_file))
queries = fp.parse_file(smt2_file)
stats.stop('Parse')
self.log.info("Parsing time ... " + str(stats.get('Parse')) +
" ms")
n_function = len(queries)
n_query = n_function if self.args.func < 0 or self.args.func > n_function else self.args.func
self.log.info("Number of functions ... " + str(n_function))
self.log.info("Number of jobs ... " + str(n_query))
all_results = ""
try:
for q in range(n_query):
query = queries[q]
function_name = self.getFunctionName(query)
self.log.info("Checking feasibility of ... " +
str(function_name))
out = ""
try:
p = multiprocessing.Process(target=checkFeas,
args=(
self.args,
q,
smt2_file,
))
p.start()
p.join(self.args.timeout)
if p.is_alive():
out = out_message % (function_name, "TIMEOUT", "",
"", "", "", "")
out = bcolors.WARNING + out + bcolors.ENDC
p.terminate()
p.join()
except Exception as e:
self.log.exception(str(e))
continue
all_results += out + "\n-----------------------\n"
if self.args.save:
f_name = ntpath.basename(smt2_file) + "_feas.txt"
with open(f_name, "w") as f:
f.write(all_results)
except Exception as e:
self.log.exception(str(e))
def test_create_enum_type(self):
# Arrange
values = ['A', 'B', 'C']
sort_name = 'TestType'
ctx = SolverContext(z3.Context())
# Act
vsort = ctx.create_enum_type(sort_name, values)
# Assert
self.assertTrue(isinstance(vsort, EnumType))
self.assertEquals(vsort.name, sort_name)
self.assertEquals(vsort.concrete_values, values)
with self.assertRaises(ValueError):
ctx.create_enum_type(sort_name, values)
with self.assertRaises(ValueError):
ctx.create_enum_type("name2", values)
def __init__(self, args, smt2_file):
log = 3 if verbose else 0
self.log = LoggingManager.get_logger(__name__, log)
self.smt2_file = smt2_file
self.args = args
self.ctx = z3.Context()
self.fp = z3.Fixedpoint(ctx=self.ctx)
self.ee_idx = list() #entry/exit vars
self.feasible_flag = set() # keep track of the feasible path
self.non_feasible_flag = set() # keep track of the infesible path
self.timeout = args.timeout # timeout per function
self.flags = None
self.preds = None
self.function_name = None
self.query_times = list()
def test_concrete_enum(self):
# Arrange
values = ['A', 'B', 'C']
sort_name = 'TestType'
name = 'TestVar1'
value = 'A'
z3_ctx = z3.Context()
vsort = EnumType(sort_name, values, z3_ctx=z3_ctx)
# Act
var = SMTVar(name, vsort, value)
# Assert
self.assertEquals(var.name, name)
self.assertEquals(var.vsort, vsort)
self.assertEquals(var.var, vsort.get_symbolic_value(value))
self.assertEquals(var.get_value(), value)
self.assertTrue(is_symbolic(var.get_var()))
