def encrypt(self, plain: bytes):
self.__bit_array = to_bit_array(plain)
self.__bit_array = substitute(self.__bit_array, ip_sub)
for round in range(round_count):
l, r = self.__bit_array[:32], self.__bit_array[32:]
key = self.__enc_keys.get_i_key(round)
expanded = substitute(r, expansion)
xor_k_e = list_xor(key, expanded)
sbox_subed = []
for i in range(8):
six_bits = xor_k_e[i * 6:(i + 1) * 6]
sb_row = six_bits[5] + (six_bits[0] << 1)
sb_col = (six_bits[1] << 3) + (six_bits[2] << 2) + (
six_bits[3] << 1) + six_bits[4]
res = int_to_bit_array(sbox[i][sb_row][sb_col], 4)
sbox_subed += res
res = substitute(sbox_subed, p_out)
xored = list_xor(l, res)
print(xored)
self.__bit_array = r + xored if round < round_count - 1 else xored + r
self.__bit_array = substitute(self.__bit_array, ip_sub_inv)
return bit_array_to_bytes(self.__bit_array)
def gen_sygus_for_pair(result_dir, template, l_name_1, l1, SC1, l_name_2, l2,
SC2):
#keep essense of names:
l_name_1 = fix_name(l_name_1)
l_name_2 = fix_name(l_name_2)
l_name = l_name_1 + "_" + l_name_2
#define the substitutions
base_substitutions = {}
base_substitutions[L1_PH] = l1
base_substitutions[L2_PH] = l2
base_substitutions[SC1_PH] = SC1
base_substitutions[SC2_PH] = SC2
base_sy = utils.substitute(template, base_substitutions)
#generate the sygus queries
#s1, s2, t1, t2 may or may not be equal
plain_sy = utils.substitute(base_sy, {EQUALITY_ASSUMPTIONS_PH: "true"})
#s1=s2
s_sy = utils.substitute(base_sy, {EQUALITY_ASSUMPTIONS_PH: "(= s1 s2)"})
#t1=t2
t_sy = utils.substitute(base_sy, {EQUALITY_ASSUMPTIONS_PH: "(= t1 t2)"})
#s1=s2 and t1=t2
st_sy = utils.substitute(
base_sy, {EQUALITY_ASSUMPTIONS_PH: "(and (= s1 s2) (= t1 t2))"})
#save
save_string_to_file_in_dir(plain_sy, l_name + "_plain.sy", result_dir)
save_string_to_file_in_dir(s_sy, l_name + "_s.sy", result_dir)
save_string_to_file_in_dir(t_sy, l_name + "_t.sy", result_dir)
save_string_to_file_in_dir(st_sy, l_name + "_st.sy", result_dir)
def make_substitutions(l_name_to_l_sc):
result = {}
for name in l_name_to_l_sc.keys():
l, sc = l_name_to_l_sc[name]
l = utils.substitute(l, substitutions)
#some side conditions include a big disjunction. This should be transform to existential
if "bv2" in sc:
sc = replace_disj_with_exists(sc)
sc = utils.substitute(sc, substitutions)
if l is not None and sc is not None:
result[name] = [l, sc]
return result
def __init__(self, key: bytes) -> None:
self.__keys = []
self.__bit_array = to_bit_array(key)
res = substitute(self.__bit_array, pc1)
c, d = res[:28], res[28:]
for i in range(16):
if i in [0, 1, 8, 15]:
c = c[1:] + c[:1]
d = d[1:] + d[:1]
else:
c = c[2:] + c[:2]
d = d[2:] + d[:2]
k = substitute(c + d, pc2)
self.__keys.append(k)
def run(self, env):
if "SOCKET" in env:
logging.error("SOCKET already defined, close prior connection first")
raise TaskError("SOCKET already defined, close prior connection first")
server = utils.substitute(self.server, env)
port = utils.substitute(self.port, env) if isinstance(self.port, str) else self.port
logging.info("Connecting to " + str(server) + ":" + str(port))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((server, int(port)))
env["SOCKET"] = s
env["SOCKET_FILE"] = s.makefile()
env["STDOUT"] = StringIO()
logging.info("Successfully connected")
def main():
from docopt import docopt
args = docopt(__doc__, version=__version__)
args_exclude = args.get('--exclude')
exclude = []
if args_exclude:
exclude = [os.path.realpath(e) for e in args_exclude]
version = args.get('--go-version') if args.get('--go-version') is not None else default_version()
gopath = find_for_gopath(substitute(args.get('--basedir')), exclude)
# we should have _something_ in the GOPATH...
if not gopath:
gopath = [ os.getcwd() ]
quiet = args.get('--quiet')
ensure_paths(GOENV_CACHE_HOME, GOENV_CONFIG_HOME, GOLANG_DISTRIBUTIONS_DIR, quiet=quiet)
platforms = {
"linux": Linux,
"darwin": MacOSX,
"freebsd": FreeBSD
}
for key in platforms:
if sys.platform.startswith(key):
impl = platforms.get(key)
break
else:
message("Your platform '{}' is not supported, sorry!".format(sys.platform), sys.stderr, quiet)
install_only = args.get('--install-only')
impl(version, *gopath, install_only=install_only, quiet=quiet).go()
def generate_sygus(syntax, l, sc, constraint):
substitutions = {}
substitutions["<syntax>"] = syntax
substitutions["<l>"] = l
substitutions["<SC>"] = sc
result = utils.substitute(skeleton, substitutions)
result = result + constraint + "\n"
result = result + check_synth + "\n"
return result
def subst(self,v,a):
if self == v:
return a
else:
newargs = []
for arg in self.comps.args:
if arg == v: newargs.append(a)
elif isinstance(arg,str): newargs.append(arg)
else: newargs.append(substitute(arg,v,a)) #arg.subst(v,a))
return PType(self.comps.pred,newargs)
def run(self, env):
folder = env["WORK_DIR"]
absfile = os.path.join(folder, self.file)
logging.info("Creating file " + str(absfile))
with open(absfile, 'w') as file:
file.write(utils.substitute(self.content, env))
logging.info("Successfully created file")
def run(self, env):
if "SOCKET" not in env:
logging.error("SOCKET not defined, call Connect first")
raise TaskError("SOCKET not defined, call Connect first")
s = env["SOCKET"]
formatted_msg = utils.substitute(self.message, env)
logging.info("Sending " + formatted_msg)
s.sendall(formatted_msg)
logging.info("Successfully sent message")
def subst(self, v, a):
if self == v:
return a
else:
newargs = []
for arg in self.comps.args:
if arg == v: newargs.append(a)
elif isinstance(arg, str): newargs.append(arg)
else: newargs.append(substitute(arg, v, a)) #arg.subst(v,a))
return PType(self.comps.pred, newargs)
def subst(self,v,a):
res = Rec()
for l in self.__dict__.keys():
lval = self.__getattribute__(l)
if lval == v:
res.addfield(l,a)
elif isinstance(lval,str):
res.addfield(l,lval)
else:
res.addfield(l,substitute(lval,v,a))
return res
def subst(self,v,a):
res = RecType()
for l in self.comps.__dict__.keys():
if self.comps.__getattribute__(l) == v:
res.addfield(l,a)
elif isinstance(self.comps.__getattribute__(l),str):
res.addfield(l,self.comps.__getattribute__(l))
else:
res.addfield(l,substitute(self.comps.__getattribute__(l),v,a))
#print(show(res))
return res
def subst(self,v,a):
res = RecType()
for l in self.comps.__dict__.keys():
if self.comps.__getattribute__(l) == v:
res.addfield(l,a)
elif isinstance(self.comps.__getattribute__(l),str):
res.addfield(l,self.comps.__getattribute__(l))
else:
res.addfield(l,substitute(self.comps.__getattribute__(l),v,a))
#print(show(res))
return res
def subst(self, v, a):
res = Rec()
for l in self.__dict__.keys():
lval = self.__getattribute__(l)
if lval == v:
res.addfield(l, a)
elif isinstance(lval, str):
res.addfield(l, lval)
else:
res.addfield(l, substitute(lval, v, a))
return res
def run(self, env):
if "STDIN" not in env:
logging.error("STDIN not defined, run Execute first")
raise TaskError("STDIN not defined, run Execute first")
formatted_input = utils.substitute(self.input, env)
logging.info("Sending input to stdin: " + formatted_input)
stdin = env["STDIN"]
stdin.write(formatted_input)
stdin.flush()
def get_rid_of_commands(prefixes, template):
result = template
for prefix in prefixes:
parens = utils.find_parens(result)
prefix_indexes = utils.find_all(result, prefix)
subs = {}
for index in prefix_indexes:
start = index
end = parens[start]
command = result[start:end + 1]
subs[command] = ""
result = utils.substitute(result, subs)
return result
def app(self,arg):
if self.var == self.body:
return arg
else:
res = substitute(self.body,self.var,arg)
if 'cache' in dir(res) and not isinstance(arg,HypObj):
return res.cache() #This conditional not used?
elif 'eval' in dir(res):
return res.eval()
# elif isinstance(res,HypObj):
# res.depends_on.append(arg)
# return res
else:
return res
def app(self, arg):
if self.var == self.body:
return arg
else:
res = substitute(self.body, self.var, arg)
if 'cache' in dir(res) and not isinstance(arg, HypObj):
return res.cache() #This conditional not used?
elif 'eval' in dir(res):
return res.eval()
# elif isinstance(res,HypObj):
# res.depends_on.append(arg)
# return res
else:
return res
def generate_content_rtl(name, template, new_l, new_SC, directory, ind):
assertion = "assertion_rtl"
if ind:
assertion = assertion + "_ind"
content = utils.substitute(template, {
l_PH: new_l,
SC_PH: new_SC,
assertion_PH: assertion
})
content = remove_ltr_stuff(content)
content = massage(content, new_l, new_SC, directory)
content = set_logic(content, directory, "exists" not in new_SC)
if is_rec(directory):
content = massage_rec(content)
return content
def run(self, env):
import json
sub_map = {}
for key,value in self.json.iteritems():
if isinstance(value, str):
value = utils.substitute(value, env)
if key in self.conversions:
value = self.conversions[key](value)
sub_map[key] = value
with open(self.filename, "w") as f:
json.dump(sub_map, f)
def extract(self, content: str) -> List[str]:
mrz_size: int = self.size()
formatted: str = ''.join(content.split()).upper()
preprocessed: str = self.preprocess(formatted)
processed: str = substitute(preprocessed, mrz_size, _default_separator)
output: list = []
for index in range(self.lines):
start: int = index * self.line_size
end: int = start + self.line_size
chunk: str = processed[start:end]
while len(chunk) > 0 and chunk[0] == _default_separator:
chunk = chunk[1:]
if self.line_size - len(chunk) > 0:
chunk: str = substitute(chunk, self.line_size, _default_separator)
difference: int = self.line_size - len(chunk)
chunk: str = chunk + (difference * _default_separator) if difference > 0 else chunk
output.append(chunk)
return output
def gen_no_inv(name, template, new_l, new_SC, directory, ind):
assertion = "assertion_ltr"
if ind:
assertion = assertion + "_ind"
l_part = EXISTENTIAL_L
content = utils.substitute(template, {
l_PH: new_l,
SC_PH: new_SC,
assertion_PH: assertion,
l_part_PH: l_part
})
content = remove_rtl_stuff(content)
content = set_logic(content, directory, False)
content = massage(content, new_l, new_SC, directory)
if is_rec(directory):
content = massage_rec(content)
return content
def gen_with_inv(name, template, new_l, new_SC, inv, directory, ind):
assertion = "assertion_ltr"
if ind:
assertion = assertion + "_ind"
l_part, extra_definition = get_l_part_and_extra_definition(name, inv)
content = utils.substitute(template, {
l_PH: new_l,
SC_PH: new_SC,
assertion_PH: assertion,
l_part_PH: l_part
})
content = add_extra_definition_to_content(content, extra_definition)
content = remove_rtl_stuff(content)
content = set_logic(content, directory, True)
content = massage(content, new_l, new_SC, directory)
if is_rec(directory):
content = massage_rec(content)
return content
def run(self, env):
if "OCTAVE_ENGINE" not in env:
logging.error("OCTAVE_ENGINE not defined")
raise TaskError("OCTAVE_ENGINE not defined")
engine = env["OCTAVE_ENGINE"]
input_strs = []
# If input argument is a variable, push into Octave's memory.
# Otherwise, pass the input argument directly in the command.
for arg in self.input:
key = utils.get_substitution_key(arg, env)
if key:
engine.push(key, env[key])
input_strs.append(key)
logging.info("Pushing variable " + key + " to Octave with value " + str(env[key]))
elif isinstance(arg, str) and arg in env:
logging.info("Pushing variable " + arg + " to Octave with value " + str(env[arg]))
engine.push(arg, env[arg])
input_strs.append(arg)
elif isinstance(arg, str):
input_strs.append(utils.substitute(arg, env))
else:
input_strs.append(str(arg))
# Build the command
command = ""
if len(self.output) > 0:
command += "["
command += ",".join(self.output)
command += "] = "
command += self.name
command += "("
command += ",".join(input_strs)
command += ");"
logging.info("Evaluating within Octave: " + command)
engine.eval(command)
for arg in self.output:
env[arg] = engine.pull(arg)
logging.info("Pulled variable " + arg + " from Octave with value " + str(env[arg]))
def run(self, env):
command = utils.substitute(self.command, env)
logging.info("Executing command " + command)
process = subprocess.Popen(shlex.split(command),
stdin=subprocess.PIPE,
stdout=None if self.ignore_stdout else subprocess.PIPE,
stderr=None if self.ignore_stderr else subprocess.PIPE)
env["PROCESS"] = process
env["STDIN"] = process.stdin
if not self.ignore_stdout:
env["STDOUT"] = process.stdout
if not self.ignore_stderr:
env["STDERR"] = process.stderr
Thread(target=utils.process_monitor, args=(process,), kwargs={ "timeout":self.timeout }).start()
logging.info("Successfully executed command")
def run(self, env):
if "OCTAVE_ENGINE" not in env:
logging.error("OCTAVE_ENGINE not defined")
raise TaskError("OCTAVE_ENGINE not defined")
engine = env["OCTAVE_ENGINE"]
env_key = utils.get_substitution_key(self.value, env)
if env_key:
engine.push(self.key, env[env_key])
logging.info("Pushing variable " + self.key + " to Octave with value " + str(env[env_key]))
elif isinstance(self.value, str) and self.value in env:
engine.push(self.key, env[self.value])
logging.info("Pushing variable " + self.key + " to Octave with value " + str(env[self.value]))
elif isinstance(self.value, str):
value = utils.substitute(self.value, env)
engine.push(self.key, value)
logging.info("Pushing variable " + self.key + " to Octave with value " + str(value))
else:
engine.push(self.key, self.value)
logging.info("Pushing variable " + self.key + " to Octave with value " + str(self.value))
def subst(self,v,a):
if self == v:
return a
else: return ListType(substitute(self.comps.base_type,v,a))
def subst(self, v, a):
if self.var == v:
return self # v is bound and not replaced
else:
return Fun(self.var, substitute(self.domain_type, v, a),
substitute(self.body, v, a))
message = 'UBXBAGCXAZYHBAZHBYAGCXDBEFBA'
print(frequency_analysis(message))
print(frequency_analysis(message, pattern_length=2))
print(message)
message = substitute(
message,
get_reversed_dict({
'H': 'X',
'O': 'Z',
'E': 'B',
'N': 'A',
# 'F': 'H',
'A': 'G',
'C': 'C',
# 'Z': 'Z',
# 'Y': 'Y',
# 'L': 'L',
# 'C': 'S',
# 'E': 'E',
'G': 'U',
'R': 'Y',
'D': 'H',
'W': 'D',
'S': 'E',
'T': 'F',
}))
print(message)
message = 'ELIERAMASSEMESFLEURS'
print(message, "=>", CaesarCypher(-2).encrypt(message))
message = 'CENESTPASMATASSEDETHE'
def subst(self, v, a):
self.oplist = substitute(self.oplist, v, a)
return self.eval()
def subst(self,v,a):
self.oplist = substitute(self.oplist,v,a)
return self.eval()
def subst(self, v, a):
return AbsPath(substitute(self.rec, v, a), substitute(self.path, v, a))
def subst(self,v,a):
if self.var == v:
return self # v is bound and not replaced
else: return Fun(self.var,substitute(self.domain_type,v,a),substitute(self.body,v,a))
def subst(self,v,a):
if self == v:
return a
else:
return TTRStringType(substitute(self.comps.types,v,a))
def subst(self,v,a):
if self == v:
return a
else:
return KPlusStringType(substitute(self.comps.base_type,v,a))
def subst(self, v, a):
if self == v:
return a
else:
return SingletonType(substitute(self.comps.base_type, v, a),
substitute(self.comps.obj, v, a))
def subst(self, v, a):
if self == v:
return a
else:
return TTRStringType(substitute(self.comps.types, v, a))
def subst(self, v, a):
if self == v:
return a
else:
return KPlusStringType(substitute(self.comps.base_type, v, a))
def translate(definition):
return utils.substitute(definition, substitutions)
def subst(self,v,a):
return AbsPath(substitute(self.rec,v,a),substitute(self.path,v,a))
def subst(self, v, a):
if self == v:
return a
else:
return ListType(substitute(self.comps.base_type, v, a))
def subst(self,v,a):
if self == v:
return a
else: return SingletonType(substitute(self.comps.base_type,v,a),substitute(self.comps.obj,v,a))
