def expand_loose(algo, db, cols, tag="md4-wangs-differentials"): i = 0 dbcols = attacks.collision.load_db_tag(algo, db, tag) while True: m = models() m.start(tag + "-expand-r2", False) models.vars.write_header() if i == 0: models.generate(algo, ["h1", "h2"]) i += 1 attacks.collision.loose.constraints(algo, cols) attacks.collision.write_constraints(algo) attacks.collision.differentials.negate(algo, cols + dbcols) models.vars.write_assign(["ccollision", "cblocks", "cdifferentials"]) m.collapse() m.build() sat = m.run(count=1) if not sat: break rs = m.results(algo) attacks.collision.insert_db_multiple(algo, db, rs, tag) dbcols = attacks.collision.load_db_tag(algo, db, tag) db.commit() return dbcols
def pre_run(self): cache_path = self.build_cache_path() cache_tag = self.build_cache_tag() if not os.path.exists(cache_path): count = 0 m = models() m.model_dir = self.cache_dir() cache_dir_path = m.model_dir + "/" + cache_tag if self.create_cache_dir(cache_dir_path): m.start(cache_tag, False) models.vars.write_header() models.generate(self.algo, ["h1", "h2"], rounds=self.rounds, bypass=True) models.vars.write_assign( ["cstart", "cinput", "cintermediate", "coutput"]) m.collapse(bc="00-combined-model.bc") while not os.path.exists(cache_path) or not os.path.exists( cache_path + "/00-combined-model.bc"): time.sleep(0.1) m = models() tag = self.build_tag() m.start(tag, False) base_path = m.model_dir + "/" + tag os.system("ln -s " + cache_path + "/00-combined-model.bc " + base_path + "/00-combined-model.txt") cstart = models.vars.differential(self.input_fill, "h1in", self.input_margin, "h2in", self.input_margin) models.vars.write_clause("cstart", cstart, "50-start.txt") tail = "*" * self.input_margin cinput = models.vars.differential(tail, "h1in", 0, "h2in", 0) models.vars.write_range_clause("cinput", self.input_error, self.input_error, cinput, "50-input.txt") tail = "*" * self.output_margin coutput = models.vars.differential(tail, "h1out", 0, "h2out", 0) models.vars.write_range_clause("coutput", self.output_error, self.output_error, coutput, "50-output.txt") cnf_file = self.cnf_path() model_files = "cat " + m.model_dir + "/" + tag + "/*.txt" compile_model = m.bc_bin + " " + " ".join(m.bc_args) cmd = model_files + " | " + compile_model of = open(cnf_file, "w") oerr = open(cnf_file + ".err", "w") ret = subprocess.call(cmd, shell=True, stdout=of, stderr=oerr) return ret
def find_simplest_differential(algo, db, rounds, tag): algo.rounds = rounds m = models() m.remote = False m.start(tag, False) models.vars.write_header() models.generate(algo, ["h1", "h2"], rounds=rounds, bypass=True) attacks.collision.write_same_state(algo) attacks.collision.write_constraints(algo) attacks.collision.write_optional_differential(algo) attacks.collision.reduced.only_one_difference(algo) found_collisions = [] found_differences = [] while True: print(len(found_collisions)) if len(found_collisions) > 0: found_differences = attacks.collision.intermediate.analyze( algo, found_collisions) print(found_differences) attacks.collision.intermediate.write_negated( algo, found_differences) models.vars.write_assign( ["ccollision", "cblocks", "cstate", "cdifferentials", "cnegated"]) m.collapse() m.build() sat = m.run(count=1) if not sat: break rs = m.results(algo) ncols = attacks.collision.build_col_rows(algo, db, rs, tag) found_collisions.append(ncols[0]) print(found_differences) return found_differences
def find_neighbors(algo, db, start, rounds, tag): r = rounds algo.rounds = rounds cols = [start.copy()] attacks.collision.insert_db_multiple(algo, db, cols, tag + "-original") wq = [] for i in range(0, rounds): wq.append((i)) jq = [] while len(wq) > 0: print(wq) i = wq.pop(0) m = models() m.start(tag + "-r" + str(i), False) models.vars.write_header() models.generate(algo, ["h1", "h2"], rounds=r, bypass=True) attacks.collision.connected.loose.constraints_new_neighbor( algo, cols, i) attacks.collision.write_same_state(algo) attacks.collision.write_constraints(algo) attacks.collision.write_optional_differential(algo) models.vars.write_assign( ["cstate", "ccollision", "cblocks", "cdifferentials"]) m.collapse() m.build() jqj = compute.perform_sat("problem.cnf", "problem.out", count=1, no_wait=True) jq.append((i, jqj)) while compute.assign_work() is None or (len(wq) == 0 and len(jq) > 0): print("Waiting for work...") fj = compute.wait_job_hosts(loop_until_found=True) fj_status = fj[0] fj_job = fj[1] for j in range(0, len(jq)): jqe = jq[j] jqr = jqe[0] jqj = jqe[1] if jqj[0] == fj_job[0]: print("Found finished job:") print((fj, jqe)) if fj_status: m = models() m.start(tag + "-r" + str(jqr), False) rs = m.results(algo) ncols = attacks.collision.build_col_rows( algo, db, rs, tag) cols.extend(ncols) wq.append(jqr) jq.remove(jq[j]) break attacks.collision.insert_db_multiple(algo, db, cols[1:], tag) return cols
def pre_run(self): cache_path = self.build_cache_path() cache_tag = self.build_cache_tag() if not os.path.exists(cache_path): count = 0 m = models() m.model_dir = self.cache_dir() cache_dir_path = m.model_dir + "/" + cache_tag if self.create_cache_dir(cache_dir_path): m.start(cache_tag, False) models.vars.write_header() models.generate(self.algo, ['h1', 'h2'], rounds=self.rounds, bypass=True) attacks.collision.write_constraints(self.algo) attacks.collision.write_optional_differential(self.algo) attacks.collision.write_same_state(self.algo) models.vars.write_assign([ 'ccollision', 'cblocks', 'cstate', 'cdifferentials', 'czeroes' ]) m.collapse(bc="00-combined-model.bc") while not os.path.exists(cache_path) or not os.path.exists( cache_path + "/00-combined-model.bc"): time.sleep(0.1) m = models() tag = self.build_tag() m.start(tag, False) base_path = m.model_dir + "/" + tag os.system("ln -s " + cache_path + "/00-combined-model.bc " + base_path + "/00-combined-model.txt") attacks.collision.connected.loose.distributed_new_neighbor( self.algo, self.base, [], [], base_path + "/07-differential.txt") f = open(base_path + "/42-zeroes.txt", 'w') f.write("czeroes := [" + str(self.zeroes) + "," + str(self.zeroes) + "](" + ','.join(map(lambda x: 'NOT(h1b' + str(x) + ')', range(512))) + ");") f.flush() f.close() if self.h1_start_state != '': models.vars.write_values(self.h1_start_state, 'h1s', base_path + "/01-h1-state.txt") if self.h2_start_state != '': models.vars.write_values(self.h2_start_state, 'h2s', base_path + "/01-h2-state.txt") return 0
def pre_run(self): cache_path = self.build_cache_path() cache_tag = self.build_cache_tag() if not os.path.exists(cache_path): count = 0 m = models() m.model_dir = self.cache_dir() cache_dir_path = m.model_dir + "/" + cache_tag if self.create_cache_dir(cache_dir_path): m.start(cache_tag, False) models.vars.write_header() models.generate(self.algo, ['h1', 'h2', 'h3'], rounds=self.rounds, bypass=True) models.vars.write_assign(['cinput', 'coutput']) m.collapse(bc="00-combined-model.bc") while not os.path.exists(cache_path) or not os.path.exists( cache_path + "/00-combined-model.bc"): time.sleep(0.1) m = models() tag = self.build_tag() m.start(tag, False) base_path = m.model_dir + "/" + tag os.system("ln -s " + cache_path + "/00-combined-model.bc " + base_path + "/00-combined-model.txt") cinput = ['and'] for i in range(0, 25 * self.w): cinput.append(('equal', 'h1in' + str(i), ('xor', 'h2in' + str(i), 'h3in' + str(i)))) cinput = tuple(cinput) models.vars.write_clause('cinput', cinput, '50-input.txt') coutput = ['and'] for i in range(0, 25 * self.w): coutput.append(('equal', 'h1out' + str(i), ('xor', 'h2out' + str(i), 'h3out' + str(i)))) coutput = ('not', tuple(coutput)) models.vars.write_clause('coutput', coutput, '50-output.txt') cnf_file = self.cnf_path() model_files = "cat " + m.model_dir + "/" + tag + "/*.txt" compile_model = m.bc_bin + " " + " ".join(m.bc_args) cmd = model_files + " | " + compile_model of = open(cnf_file, 'w') oerr = open(cnf_file + ".err", 'w') ret = subprocess.call(cmd, shell=True, stdout=of, stderr=oerr) return ret
def pre_run(self): cache_path = self.build_cache_path() cache_tag = self.build_cache_tag() if not os.path.exists(cache_path): count = 0 m = models() m.model_dir = self.cache_dir() cache_dir_path = m.model_dir + "/" + cache_tag if self.create_cache_dir(cache_dir_path): m.start(cache_tag, False) models.vars.write_header() models.generate(self.algo, ['h1', 'h2'], rounds=self.rounds, bypass=True) attacks.collision.write_constraints(self.algo) attacks.collision.write_optional_differential(self.algo) attacks.collision.write_same_state(self.algo) models.vars.write_assign([ 'ccollision', 'cblocks', 'cstate', 'cdifferentials', 'cascii' ]) m.collapse(bc="00-combined-model.bc") while not os.path.exists(cache_path) or not os.path.exists( cache_path + "/00-combined-model.bc"): time.sleep(0.1) m = models() tag = self.build_tag() m.start(tag, False) base_path = m.model_dir + "/" + tag os.system("ln -s " + cache_path + "/00-combined-model.bc " + base_path + "/00-combined-model.txt") attacks.collision.connected.loose.distributed_new_neighbor( self.algo, self.base, [], [], base_path + "/07-differential.txt") prefixes = ['h1b'] if self.both: prefixes = ['h1b', 'h2b'] attacks.collision.write_ascii_constraints(prefixes, base_path + "/44-ascii.txt") if self.h1_start_state != '': models.vars.write_values(self.h1_start_state, 'h1s', base_path + "/01-h1-state.txt") if self.h2_start_state != '': models.vars.write_values(self.h2_start_state, 'h2s', base_path + "/01-h2-state.txt") return 0
def find_arbitrary_differential(algo, db, rounds, tag): algo.rounds = rounds m = models() m.start(tag, False) models.vars.write_header() models.generate(algo, ["h1", "h2"], rounds=rounds, bypass=True) attacks.collision.write_same_state(algo) attacks.collision.write_constraints(algo) attacks.collision.write_optional_differential(algo) models.vars.write_assign(["ccollision", "cblocks", "cstate"]) m.collapse() m.build() m.remote = False m.run(count=1) rs = m.results(algo) ncols = attacks.collision.build_col_rows(algo, db, rs, tag) print(ncols)
def complete(algo, db, cols, tag): differentials = attacks.collision.differentials.analyze(algo, cols) i = 0 for differential in itertools.product(*differentials): m = models() m.start(tag, False) models.vars.write_header() models.generate(algo, ["h1", "h2"]) attacks.collision.tight.constraints(algo, cols) attacks.collision.write_constraints(algo) attacks.collision.differentials.write(algo, differential) models.vars.write_assign(["ccollision", "cblocks", "cdifferentials"]) m.collapse() m.build() m.run(count=1) rs = m.results(algo) attacks.collision.insert_db_multiple(algo, db, rs, tag) i += 1
def pre_run(self): cache_path = self.build_cache_path() cache_tag = self.build_cache_tag() if not os.path.exists(cache_path): count = 0 m = models() m.model_dir = self.cache_dir() cache_dir_path = m.model_dir + "/" + cache_tag if self.create_cache_dir(cache_dir_path): m.start(cache_tag, False) models.vars.write_header() models.generate(self.algo, ['h1', 'h2', 'h3', 'h4'], rounds=self.rounds, bypass=True) attacks.collision.write_constraints(self.algo, prefixes=['h1', 'h2'], name="98-h1-h2-constraints.txt", out_name="ccollisionh1h2") attacks.collision.write_constraints(self.algo, prefixes=['h3', 'h4'], name="98-h3-h4-constraints.txt", out_name="ccollisionh3h4") attacks.collision.write_optional_differential(self.algo) attacks.collision.write_same_state(self.algo, prefixes=['h1', 'h2'], name="01-h1-h2-state.txt", out_name="cstateh1h2") attacks.collision.write_same_state(self.algo, prefixes=['h3', 'h4'], name="01-h3-h4-state.txt", out_name="cstateh3h4") attacks.collision.write_same_blocks(self.algo, prefixes=['h1', 'h3'], name="08-h1-h3-block.txt", out_name="cblocksh1h3") attacks.collision.write_same_blocks(self.algo, prefixes=['h2', 'h4'], name="08-h2-h4-block.txt", out_name="cblocksh2h4") models.vars.write_assign(['ccollisionh1h2', 'ccollisionh3h4', 'cblocks', 'cstateh1h2', 'cstateh3h4', 'cblocksh1h3', 'cblocksh2h4', 'cdifferentialsh1h2', 'cdifferentialsh3h4']) m.collapse(bc="00-combined-model.bc") while not os.path.exists(cache_path) or not os.path.exists(cache_path + "/00-combined-model.bc"): time.sleep(0.1) m = models() tag = self.build_tag() m.start(tag, False) base_path = m.model_dir + "/" + tag os.system("ln -s " + cache_path + "/00-combined-model.bc " + base_path + "/00-combined-model.txt") attacks.collision.connected.loose.distributed_new_neighbor(self.algo, self.base, [], [], base_path + "/07-h1-h2-differential.txt", ['h1', 'h2'], 'cdifferentialsh1h2') attacks.collision.connected.loose.distributed_new_neighbor(self.algo, self.base, [], [], base_path + "/07-h3-h4-differential.txt", ['h3', 'h4'], 'cdifferentialsh3h4') if self.h1_start_state != '': models.vars.write_values(self.h1_start_state, 'h1s', base_path + "/01-h1-state.txt") if self.h2_start_state != '': models.vars.write_values(self.h2_start_state, 'h2s', base_path + "/01-h2-state.txt") return 0
def expand(algo, db, stuck, intermediate): m = models() for i in range(0, algo.rounds): # Don't write constraints for the four previous rounds # and four following rounds cols = attacks.collision.load_db_tag(algo, db, "md4-wangs-original") tag = "md4-wangs-intermediate-r1-" + str(i) + "-" + str( len(intermediate[i])) m.start(tag, False) models.vars.write_header() models.generate(algo, ['h1', 'h2']) # Differential Path differential = ['and'] for j in range(0, algo.rounds): dlist = [] if i == j: for e in intermediate[j]: dlist.append([ e, 'h1i', j * algo.int_size, "h2i", j * algo.int_size ]) differential.append( ('not', models.vars.choice_differentials(dlist))) continue elif i - 4 <= j <= i + 4: continue for e in intermediate[j]: dlist.append( [e, 'h1i', j * algo.int_size, "h2i", j * algo.int_size]) differential.append(models.vars.choice_differentials(dlist)) models.vars.write_clause('cdifferentials', tuple(differential), "07-differential.txt") attacks.collision.write_constraints(algo) attacks.collision.write_optional_differential(algo) attacks.collision.stuck.write(algo, stuck) models.vars.write_assign( ['ccollision', 'cblocks', 'cdifferentials', 'cstuck']) m.collapse() m.build() m.run(count=10) rs = m.results(algo) attacks.collision.insert_db_multiple(algo, db, rs, tag)
def model(algo, model, cols, generate=False): models.vars.write_header() if type(cols) == dict: cols = [cols] assert (type(cols) == list and len(cols) > 0 and type(cols[0]) == dict) prefixes = ['h1', 'h2'] if generate: models.generate(algo, prefixes) for prefix in prefixes: s = attacks.collision.get_state(algo, cols[0], prefix) models.vars.write_values(s, prefix + 's', "01-" + prefix + "-state.txt") attacks.collision.loose.constraints(algo, cols) attacks.collision.write_constraints(algo) attacks.collision.write_optional_differential(algo) models.vars.write_assign(['ccollision', 'cblocks', 'cdifferentials'])
def pre_run(self): cache_path = self.build_cache_path() cache_tag = self.build_cache_tag() if not os.path.exists(cache_path): count = 0 m = models() m.model_dir = self.cache_dir() cache_dir_path = m.model_dir + "/" + cache_tag if self.create_cache_dir(cache_dir_path): m.start(cache_tag, False) models.vars.write_header() models.generate(self.algo, ['h1', 'h2'], rounds=self.rounds, bypass=True) attacks.collision.write_constraints(self.algo) attacks.collision.write_optional_differential(self.algo) attacks.collision.write_same_state(self.algo) models.vars.write_assign([ 'ccollision', 'cblocks', 'cstate', 'cdifferentials', 'cascii' ]) m.collapse(bc="00-combined-model.bc") while not os.path.exists(cache_path) or not os.path.exists( cache_path + "/00-combined-model.bc"): time.sleep(0.1) m = models() tag = self.build_tag() m.start(tag, False) base_path = m.model_dir + "/" + tag os.system("ln -s " + cache_path + "/00-combined-model.bc " + base_path + "/00-combined-model.txt") attacks.collision.connected.loose.distributed_new_neighbor( self.algo, self.base, self.existing, self.poses, base_path + "/07-differential.txt") if self.ascii: prefixes = ['h1b'] if self.both: prefixes = ['h1b', 'h2b'] attacks.collision.write_ascii_constraints( prefixes, base_path + "/44-ascii.txt") if self.h1_start_state != '': models.vars.write_values(self.h1_start_state, 'h1s', base_path + "/01-h1-state.txt") if self.h1_start_block != '': models.vars.write_values(self.h1_start_block, 'h1b', base_path + "/15-h1-state.txt") if self.h2_start_state != '': models.vars.write_values(self.h2_start_state, 'h2s', base_path + "/01-h2-state.txt") if self.h2_start_block != '': models.vars.write_values(self.h2_start_block, 'h2b', base_path + "/15-h2-state.txt") cnf = self.cnf_path() o_cnf = open(cnf, 'w') o_err = open(cnf + ".err", 'w') model_files = "cat " + m.model_dir + "/" + tag + "/*.txt" compile_model = m.bc_bin + " " + " ".join(m.bc_args) cmd = model_files + " | " + compile_model ret = subprocess.call(cmd, stdin=subprocess.DEVNULL, stdout=o_cnf, stderr=o_err, shell=True)
def find_extended(algo, db, delta_set, rounds, tag_base): nd = [] wq = [] jq = [] found_differences = {} r = rounds algo.rounds = r m = models() tag = tag_base + "-r" + str(r) m.start(tag, False) models.vars.write_header() models.generate(algo, ["h1", "h2"], rounds=r, bypass=True) attacks.collision.write_same_state(algo) attacks.collision.write_constraints(algo) attacks.collision.write_optional_differential(algo) models.vars.write_assign( ["ccollision", "cblocks", "cstate", "cdifferentials", "cnegated"]) print("Generating work queue...") for deltas in delta_set: for n in range(0, 1): wd = attacks.collision.reduced.generate_test_delta( deltas, n, rounds) print(wd) print(type(wd[0])) for e in wd: m = models() s = len(e) tag = (tag_base + "-r" + str(r) + "-s" + str(s) + "-e" + "-".join(list(map(str, e)))) m.start(tag, False) os.system("cp -r " + m.model_dir + "/" + tag_base + "-r" + str(r) + "/* " + m.model_dir + "/" + tag + "/") attacks.collision.reduced.specified_difference(algo, e) wq.append((r, s, e)) found_differences[(r, s, e)] = [] m.collapse() m.build() print("Finished generating work queue...") random.shuffle(wq) print("Running work...") while len(wq) > 0: w = wq.pop(0) print("wq: " + str(len(wq))) print("jq: " + str(len(jq))) print("Handling job: " + str(w)) r = w[0] s = w[1] e = w[2] algo.rounds = r m = models() tag = (tag_base + "-r" + str(r) + "-s" + str(s) + "-e" + "-".join(list(map(str, e)))) m.start(tag, False) j = compute.perform_sat("problem.cnf", "problem.out", count=1, no_wait=True, ident=(w)) jq.append((w, j)) print("Done handling job.") while compute.assign_work() is None or (len(wq) == 0 and len(jq) > 0): print("Waiting for work...") print(len(jq)) fj = compute.wait_job_hosts(loop_until_found=True) fj_status = fj[0] fj_job = fj[1] fj_w = fj_job[6] found = False for j in range(0, len(jq)): jqe = jq[j] jqw = jqe[0] jqj = jqe[1] if fj_w == jqw: print("Found finished job:") print(fj_w) print(fj_status) found = True if fj_status: w = fj_w # wq.append(w) r = fj_w[0] s = fj_w[1] e = fj_w[2] algo.rounds = r m = models() tag = (tag_base + "-r" + str(r) + "-s" + str(s) + "-e" + "-".join(list(map(str, e)))) m.start(tag, False) rs = m.results(algo) ncols = attacks.collision.build_col_rows( algo, db, rs, tag) if len(ncols) < 1: continue attacks.collision.insert_db_multiple( algo, db, ncols, tag) db.commit() nfd = attacks.collision.intermediate.analyze( algo, ncols) if len(found_differences[w]) == 0: found_differences[w] = nfd else: for i in range(0, len(nfd)): for ele in nfd[i]: found_differences[w][i].add(ele) jq.remove(jq[j]) break if not found: print("Did not find job..." + str(jq) + " || " + str(fj)) print("Done waiting for work.") print(found_differences)
def parallel_simple_differentials(algo, db, rounds, sizes, tag_base): wq = [] jq = [] found_collisions = {} found_differences = {} print("Starting to generate work queue") for r in rounds: m = models() tag = tag_base + "-r" + str(r) m.start(tag, False) models.vars.write_header() models.generate(algo, ['h1', 'h2'], rounds=r, bypass=True) attacks.collision.write_same_state(algo) attacks.collision.write_constraints(algo) attacks.collision.write_optional_differential(algo) models.vars.write_assign( ['ccollision', 'cblocks', 'cstate', 'cdifferentials', 'cnegated']) for s in sizes: for e in itertools.combinations(list(range(0, r)), s): algo.rounds = r m = models() tag = tag_base + "-r" + str(r) + "-s" + str( s) + "-e" + '-'.join(list(map(str, e))) m.start(tag, False) os.system("cp -r " + m.model_dir + "/" + tag_base + "-r" + str(r) + "/* " + m.model_dir + "/" + tag + "/") attacks.collision.reduced.specified_difference(algo, e) wq.append((r, s, e)) found_differences[(r, s, e)] = [] print("Done generating work...") print("Running work...") random.shuffle(wq) while len(wq) > 0: w = wq.pop(0) print("wq: " + str(len(wq))) print("jq: " + str(len(jq))) print("Handling job: " + str(w)) r = w[0] s = w[1] e = w[2] algo.rounds = r m = models() tag = tag_base + "-r" + str(r) + "-s" + str(s) + "-e" + '-'.join( list(map(str, e))) m.start(tag, False) if len(found_differences[w]) > 0: print(found_differences[w]) attacks.collision.intermediate.write_negated( algo, found_differences[w]) m.collapse() m.build() j = compute.perform_sat("problem.cnf", "problem.out", count=1, no_wait=True, ident=(w)) jq.append((w, j)) print("Done handling job.") while compute.assign_work() is None or (len(wq) == 0 and len(jq) > 0): print("Waiting for work...") fj = compute.wait_job_hosts(loop_until_found=True) fj_status = fj[0] fj_job = fj[1] fj_w = fj_job[6] found = False for j in range(0, len(jq)): jqe = jq[j] jqw = jqe[0] jqj = jqe[1] if fj_w == jqw: print("Found finished job:") found = True if fj_status: w = fj_w print(w) #wq.append(w) r = fj_w[0] s = fj_w[1] e = fj_w[2] algo.rounds = r m = models() tag = tag_base + "-r" + str(r) + "-s" + str( s) + "-e" + '-'.join(list(map(str, e))) m.start(tag, False) rs = m.results(algo) ncols = attacks.collision.build_col_rows( algo, db, rs, tag) if len(ncols) < 1: continue attacks.collision.insert_db_multiple( algo, db, ncols, tag) db.commit() nfd = attacks.collision.intermediate.analyze( algo, ncols) if len(found_differences[w]) == 0: found_differences[w] = nfd else: for i in range(0, len(nfd)): for ele in nfd[i]: found_differences[w][i].add(ele) jq.remove(jq[j]) break if not found: print("Did not find job..." + str(jq) + " || " + str(fj)) print("Done waiting for work.") print(found_differences)
def pre_run(self): cache_path = self.build_cache_path() cache_tag = self.build_cache_tag() if not os.path.exists(cache_path): count = 0 m = models() m.model_dir = self.cache_dir() cache_dir_path = m.model_dir + "/" + cache_tag if self.create_cache_dir(cache_dir_path): m.start(cache_tag, False) models.vars.write_header() models.generate(self.algo, ["h1", "h2"], rounds=self.rounds, bypass=True) models.vars.write_assign( ["ccollision", "cinput", "cintermediate"]) m.collapse(bc="00-combined-model.bc") while not os.path.exists(cache_path) or not os.path.exists( cache_path + "/00-combined-model.bc"): time.sleep(0.1) m = models() tag = self.build_tag() m.start(tag, False) base_path = m.model_dir + "/" + tag os.system("ln -s " + cache_path + "/00-combined-model.bc " + base_path + "/00-combined-model.txt") cinput = ["and"] for i in range(0, 25 * self.w): cinput.append(("not", ("equal", "h1in" + str(i), "h2in" + str(i)))) cinput = tuple(cinput) models.vars.write_range_clause("cinput", self.differences[0], self.differences[0], cinput, "15-input.txt") ccollision = ["and"] for i in range(0, self.margin): ccollision.append(("equal", "h1out" + str(i), "h2out" + str(i))) ccollision = tuple(ccollision) models.vars.write_clause("ccollision", ccollision, "20-collision.txt") if len(self.rounds) > 1: cintermediate = ["and", ("equal", "T", "T")] tir = 0 rir = 0 pir = 0 cir = 0 cic = 0 for index in range(1, len(self.rounds)): r = self.rounds[index - 1] nerr = self.differences[index] if r[0] == "t": cni = ["and"] cvar = tir for i in range(0, 25 * self.w): cni.append(( "not", ( "equal", "h1r" + str(cvar) + r[0] + str(i), "h2r" + str(cvar) + r[0] + str(i), ), )) cni = tuple(cni) models.vars.write_range_clause( "cintermediate" + str(cic), nerr, nerr, cni, "39-intermediate-" + str(cic) + ".txt", ) cintermediate.append("cintermediate" + str(cic)) cic += 1 tir += 1 elif r[0] == "r": cni = ["and"] cvar = rir for i in range(0, 25 * self.w): cni.append(( "not", ( "equal", "h1r" + str(cvar) + r[0] + str(i), "h2r" + str(cvar) + r[0] + str(i), ), )) cni = tuple(cni) models.vars.write_range_clause( "cintermediate" + str(cic), nerr, nerr, cni, "39-intermediate-" + str(cic) + ".txt", ) cintermediate.append("cintermediate" + str(cic)) cic += 1 rir += 1 elif r[0] == "p": cni = ["and"] cvar = pir for i in range(0, 25 * self.w): cni.append(( "not", ( "equal", "h1r" + str(cvar) + r[0] + str(i), "h2r" + str(cvar) + r[0] + str(i), ), )) cni = tuple(cni) models.vars.write_range_clause( "cintermediate" + str(cic), nerr, nerr, cni, "39-intermediate-" + str(cic) + ".txt", ) cintermediate.append("cintermediate" + str(cic)) cic += 1 pir += 1 elif r[0] == "c": cni = ["and"] cvar = cir for i in range(0, 25 * self.w): cni.append(( "not", ( "equal", "h1r" + str(cvar) + r[0] + str(i), "h2r" + str(cvar) + r[0] + str(i), ), )) cni = tuple(cni) models.vars.write_range_clause( "cintermediate" + str(cic), nerr, nerr, cni, "39-intermediate-" + str(cic) + ".txt", ) cintermediate.append("cintermediate" + str(cic)) cic += 1 cir += 1 elif r[0] == "i": iir = int(r[1:]) cni = ["and"] cvar = iir for i in range(0, 25 * self.w): cni.append(( "not", ( "equal", "h1r" + str(cvar) + r[0] + str(i), "h2r" + str(cvar) + r[0] + str(i), ), )) cni = tuple(cni) models.vars.write_range_clause( "cintermediate" + str(cic), nerr, nerr, cni, "39-intermediate-" + str(cic) + ".txt", ) cintermediate.append("cintermediate" + str(cic)) cic += 1 else: assert "Invalid round specification" == "Should not happen." cintermediate = tuple(cintermediate) models.vars.write_clause("cintermediate", cintermediate, "40-intermediate.txt") cnf_file = self.cnf_path() model_files = "cat " + m.model_dir + "/" + tag + "/*.txt" compile_model = m.bc_bin + " " + " ".join(m.bc_args) cmd = model_files + " | " + compile_model of = open(cnf_file, "w") oerr = open(cnf_file + ".err", "w") ret = subprocess.call(cmd, shell=True, stdout=of, stderr=oerr) return ret
def pre_run(self): cache_path = self.build_cache_path() cache_tag = self.build_cache_tag() if not os.path.exists(cache_path): count = 0 m = models() m.model_dir = self.cache_dir() cache_dir_path = m.model_dir + "/" + cache_tag if self.create_cache_dir(cache_dir_path): m.start(cache_tag, False) models.vars.write_header() models.generate(self.algo, ['h1', 'h2'], rounds=self.rounds, bypass=True) attacks.collision.write_constraints(self.algo) attacks.collision.write_optional_differential(self.algo) attacks.collision.write_same_state(self.algo) if self.invalid: invalid_differentials = models.vars.differentials( [['.' * 32, 'h1b', 96, 'h2b', 96], ['.' * 32, 'h1b', 224, 'h2b', 224], ['.' * 32, 'h1b', 352, 'h2b', 352], ['.' * 32, 'h1b', 480, 'h2b', 480]]) models.vars.write_clause('cinvalid', invalid_differentials, '23-invalid.txt') models.vars.write_assign([ 'ccollision', 'cblocks', 'cstate', 'cdifferentials', 'cinvalid', 'cnegated', 'cspecific', 'cascii' ]) m.collapse(bc="00-combined-model.bc") while not os.path.exists(cache_path) or not os.path.exists( cache_path + "/00-combined-model.bc"): time.sleep(0.1) m = models() tag = self.build_tag() m.start(tag, False) base_path = m.model_dir + "/" + tag os.system("ln -s " + cache_path + "/00-combined-model.bc " + base_path + "/00-combined-model.txt") if self.h1_start_state != '': models.vars.write_values(self.h1_start_state, 'h1s', base_path + "/01-h1-state.txt") if self.h1_start_block != '': models.vars.write_values(self.h1_start_block, 'h1b', base_path + "/15-h1-state.txt") if self.h2_start_state != '': models.vars.write_values(self.h2_start_state, 'h2s', base_path + "/01-h2-state.txt") if self.h2_start_block != '': models.vars.write_values(self.h2_start_block, 'h2b', base_path + "/15-h2-state.txt") if self.specific != None: specific_differentials = models.vars.differentials(self.specific) models.vars.write_clause('cspecific', specific_differentials, '28-specific.txt') attacks.collision.reduced.specified_difference( self.algo, self.places, base_path + "/07-differential.txt") attacks.collision.write_ascii_constraints(self.ascii, 64) cnf = self.cnf_path() o_cnf = open(cnf, 'w') o_err = open(cnf + ".err", 'w') model_files = "cat " + m.model_dir + "/" + tag + "/*.txt" compile_model = m.bc_bin + " " + " ".join(m.bc_args) cmd = model_files + " | " + compile_model ret = subprocess.call(cmd, stdin=subprocess.DEVNULL, stdout=o_cnf, stderr=o_err, shell=True) if not o_cnf.closed: o_cnf.flush() o_cnf.close() if not o_err.closed: o_err.flush() o_err.close() if ret != 0: print("ERROR COMPILING MODEL: " + tag) return ret return 0
def pre_run(self): cache_path = self.build_cache_path() cache_tag = self.build_cache_tag() if not os.path.exists(cache_path): count = 0 m = models() m.model_dir = self.cache_dir() cache_dir_path = m.model_dir + "/" + cache_tag if self.create_cache_dir(cache_dir_path): m.start(cache_tag, False) models.vars.write_header() models.generate(self.algo, ["h1", "h2"], rounds=self.rounds, bypass=True) models.vars.write_assign(["cbijection"]) m.collapse(bc="00-combined-model.bc") while not os.path.exists(cache_path) or not os.path.exists( cache_path + "/00-combined-model.bc"): time.sleep(0.1) m = models() tag = self.build_tag() m.start(tag, False) base_path = m.model_dir + "/" + tag os.system("ln -s " + cache_path + "/00-combined-model.bc " + base_path + "/00-combined-model.txt") cinin = ["and"] for i in range(0, 25 * self.w): cinin.append(("equal", "h1in" + str(i), "h2in" + str(i))) cinin = ("not", tuple(cinin)) models.vars.write_clause("cinin", cinin, "02-inin.txt") cinout = ["and"] for i in range(0, 25 * self.w): cinout.append(("equal", "h1out" + str(i), "h2out" + str(i))) cinout = tuple(cinout) models.vars.write_clause("cinout", cinout, "02-inout.txt") csurin = ["and"] for i in range(0, 25 * self.w): csurin.append(("equal", "h1in" + str(i), "h2in" + str(i))) csurin = tuple(csurin) models.vars.write_clause("csurin", csurin, "02-surin.txt") csurout = ["and"] for i in range(0, 25 * self.w): csurout.append(("equal", "h1out" + str(i), "h2out" + str(i))) csurout = ("not", tuple(csurout)) models.vars.write_clause("csurout", csurout, "02-surout.txt") cinjection = ("and", "cinin", "cinout") csurjection = ("and", "csurin", "csurout") cbijection = ("or", cinjection, csurjection) models.vars.write_clause("cbijection", cbijection, "98-problem.txt") cnf_file = self.cnf_path() model_files = "cat " + m.model_dir + "/" + tag + "/*.txt" compile_model = m.bc_bin + " " + " ".join(m.bc_args) cmd = model_files + " | " + compile_model of = open(cnf_file, "w") oerr = open(cnf_file + ".err", "w") ret = subprocess.call(cmd, shell=True, stdout=of, stderr=oerr) return ret
def pre_run(self): cache_path = self.build_cache_path() cache_tag = self.build_cache_tag() if not os.path.exists(cache_path): count = 0 m = models() m.model_dir = self.cache_dir() cache_dir_path = m.model_dir + "/" + cache_tag if self.create_cache_dir(cache_dir_path): m.start(cache_tag, False) models.vars.write_header() models.generate(self.algo, ['h1', 'h2'], rounds=self.rounds, bypass=True) models.vars.write_assign(['ccollision', 'cinput', 'cintermediate']) m.collapse(bc="00-combined-model.bc") while not os.path.exists(cache_path) or not os.path.exists(cache_path + "/00-combined-model.bc"): time.sleep(0.1) m = models() tag = self.build_tag() m.start(tag, False) base_path = m.model_dir + "/" + tag os.system("ln -s " + cache_path + "/00-combined-model.bc " + base_path + "/00-combined-model.txt") cinput = ['and'] for i in range(0, 25*self.w): cinput.append(('not', ('equal', 'h1in' + str(i), 'h2in' + str(i)))) cinput = tuple(cinput) models.vars.write_range_clause('cinput', self.differences[0], self.differences[0], cinput, '15-input.txt') ccollision = ['and'] for i in range(0, self.margin): ccollision.append(('equal', 'h1out' + str(i), 'h2out' + str(i))) ccollision = tuple(ccollision) models.vars.write_clause('ccollision', ccollision, '20-collision.txt') if len(self.rounds) > 1: cintermediate = ['and', ('equal', 'T', 'T')] tir = 0 rir = 0 pir = 0 cir = 0 cic = 0 for index in range(1, len(self.rounds)): r = self.rounds[index-1] nerr = self.differences[index] if r[0] == 't': cni = ['and'] cvar = tir for i in range(0, 25*self.w): cni.append(('not', ('equal', 'h1r' + str(cvar) + r[0] + str(i), 'h2r' + str(cvar) + r[0] + str(i)))) cni = tuple(cni) models.vars.write_range_clause('cintermediate' + str(cic), nerr, nerr, cni, '39-intermediate-' + str(cic) + '.txt') cintermediate.append('cintermediate' + str(cic)) cic += 1 tir += 1 elif r[0] == 'r': cni = ['and'] cvar = rir for i in range(0, 25*self.w): cni.append(('not', ('equal', 'h1r' + str(cvar) + r[0] + str(i), 'h2r' + str(cvar) + r[0] + str(i)))) cni = tuple(cni) models.vars.write_range_clause('cintermediate' + str(cic), nerr, nerr, cni, '39-intermediate-' + str(cic) + '.txt') cintermediate.append('cintermediate' + str(cic)) cic += 1 rir += 1 elif r[0] == 'p': cni = ['and'] cvar = pir for i in range(0, 25*self.w): cni.append(('not', ('equal', 'h1r' + str(cvar) + r[0] + str(i), 'h2r' + str(cvar) + r[0] + str(i)))) cni = tuple(cni) models.vars.write_range_clause('cintermediate' + str(cic), nerr, nerr, cni, '39-intermediate-' + str(cic) + '.txt') cintermediate.append('cintermediate' + str(cic)) cic += 1 pir += 1 elif r[0] == 'c': cni = ['and'] cvar = cir for i in range(0, 25*self.w): cni.append(('not', ('equal', 'h1r' + str(cvar) + r[0] + str(i), 'h2r' + str(cvar) + r[0] + str(i)))) cni = tuple(cni) models.vars.write_range_clause('cintermediate' + str(cic), nerr, nerr, cni, '39-intermediate-' + str(cic) + '.txt') cintermediate.append('cintermediate' + str(cic)) cic += 1 cir += 1 elif r[0] == 'i': iir = int(r[1:]) cni = ['and'] cvar = iir for i in range(0, 25*self.w): cni.append(('not', ('equal', 'h1r' + str(cvar) + r[0] + str(i), 'h2r' + str(cvar) + r[0] + str(i)))) cni = tuple(cni) models.vars.write_range_clause('cintermediate' + str(cic), nerr, nerr, cni, '39-intermediate-' + str(cic) + '.txt') cintermediate.append('cintermediate' + str(cic)) cic += 1 else: assert("Invalid round specification" == "Should not happen.") cintermediate = tuple(cintermediate) models.vars.write_clause('cintermediate', cintermediate, '40-intermediate.txt') cnf_file = self.cnf_path() model_files = "cat " + m.model_dir + "/" + tag + "/*.txt" compile_model = m.bc_bin + " " + " ".join(m.bc_args) cmd = model_files + " | " + compile_model of = open(cnf_file, 'w') oerr = open(cnf_file + ".err", 'w') ret = subprocess.call(cmd, shell=True, stdout=of, stderr=oerr) return ret