def transform_string(input_string):
# Initial parameters
folder = 'ntp_packet_field_short_client'
long_byte_range = [44,45,46,50,54,58,66,74,82,90]
short_byte_range = [42,43,44]
group = [0,1,2,5,9,11,15,19,23,27]
length = 450
regex = '^[0-9a-f]+$'
# Encode as hex
hex_string = input_string.encode('HEX')
fixed_slice = 162 ## 27*6
dfa = regex2dfa.regex2dfa(regex)
fteObj = fte.encoder.DfaEncoder(dfa, fixed_slice)
client_ciphertext = fteObj.encode(hex_string)
# Read into all possible values for each field (only consider field with more than 16 observations)
long_field = retrieve_long_field(long_byte_range, folder)
short_field = retrieve_short_field(short_byte_range, folder)
# Do original FTE
dfa = regex2dfa.regex2dfa(regex)
fteObj = fte.encoder.DfaEncoder(dfa, fixed_slice)
client_ciphertext = fteObj.encode(hex_string)
# Map to NTP traffic
chunk = cut_str_into_chunk(client_ciphertext,27)
output = [''] * len(chunk)
for i in range(len(chunk)):
output[i] = rewrite_output(map_fte_to_ntp(chunk[i], group, long_field), folder, short_field)
return output
def FPEncrypt(regex, fixed_slice, input_plaintext):
dfa = regex2dfa.regex2dfa(regex)
fteObj = fte.encoder.DfaEncoder(dfa, fixed_slice)
cifrado = fteObj.encode(input_plaintext)
#print("Debug: encrypting %s, result %s"%(input_plaintext,cifrado))
#print("Debug: len(cifrado) %s"%(len(cifrado)))
return cifrado
def FPEncrypt(regex, fixed_slice,input_plaintext):
dfa = regex2dfa.regex2dfa(regex)
fteObj = fte.encoder.DfaEncoder(dfa, fixed_slice)
cifrado = fteObj.encode(input_plaintext)
#print("Debug: encrypting %s, result %s"%(input_plaintext,cifrado))
#print("Debug: len(cifrado) %s"%(len(cifrado)))
return cifrado
def encode(self, marionette_state, template, to_embed):
ctxt = ''
if self.target_len_ < self.min_len_ or self.target_len_ > self.max_len_:
key = self.regex_ + str(self.target_len_)
if not regex_cache_.get(key):
dfa = regex2dfa.regex2dfa(self.regex_)
cdfa_obj = fte.cDFA.DFA(dfa, self.target_len_)
encoder = fte.dfa.DFA(cdfa_obj, self.target_len_)
regex_cache_[key] = (dfa, encoder)
(dfa, encoder) = regex_cache_[key]
to_unrank = random.randint(0, encoder.getNumWordsInSlice(self.target_len_))
ctxt = encoder.unrank(to_unrank)
else:
key = self.regex_ + str(self.min_len_)
(dfa, encoder) = fte_cache_[key]
ctxt = encoder.encode(to_embed)
if len(ctxt) != self.target_len_:
raise Exception("Could not find ctxt of len %d (%d)" %
(self.target_len_,len(ctxt)))
return ctxt
def transform_string(input_string):
# parameters
input_length = 450
start_seed = 42
start = "2"
filename = "client-payload-output.fsa"
folder_size = "client-payload-size-uniq-obs"
folder_symbol = "client-payload-obs"
timing_bin = [0.025]
size_bin = [10, 20, 35, 53, 65]
length = [1, 2, 3, 2, 3, 3]
# Encode as hex
hex_string = input_string.encode("HEX")
# Do original FTE
regex = "^[0-9a-f]+$"
# fixed_slice = 512
fixed_slice = 150
dfa = regex2dfa.regex2dfa(regex)
fteObj = fte.encoder.DfaEncoder(dfa, fixed_slice)
client_ciphertext = fteObj.encode(hex_string)
print len(client_ciphertext)
print client_ciphertext
all_group = divide_into_group(size_bin, length, folder_size)
# print client_ciphertext[0]
fte_bin = cut_fte_into_pieces(
client_ciphertext, filename, start, length, size_bin, all_group, folder_symbol, start_seed
)
# print len(fte_bin)
return fte_bin
def get_fte_obj(self, regex, msg_len):
fte_key = 'fte_obj-' + regex + str(msg_len)
if not self.get_global(fte_key):
dfa = regex2dfa.regex2dfa(regex)
fte_obj = fte.encoder.DfaEncoder(dfa, msg_len)
self.set_global(fte_key, fte_obj)
return self.get_global(fte_key)
def __init__(self, regex, msg_len):
self.regex_ = regex
fte_key = regex + str(msg_len)
if not fte_cache_.get(fte_key):
dfa = regex2dfa.regex2dfa(regex)
encrypter = fte.encoder.DfaEncoder(dfa, msg_len)
fte_cache_[fte_key] = (dfa, encrypter)
(self.dfa_, self.fte_encrypter_) = fte_cache_[fte_key]
def __init__(self, regex, msg_len):
self.regex_ = regex
fte_key = regex + str(msg_len)
if not fte_cache_.get(fte_key):
dfa = regex2dfa.regex2dfa(regex)
encrypter = fte.encoder.DfaEncoder(dfa, msg_len)
fte_cache_[fte_key] = (dfa, encrypter)
(self.dfa_, self.fte_encrypter_) = fte_cache_[fte_key]
def __init__(self, regex, msg_len):
self.regex_ = regex
regex_key = regex + str(msg_len)
if not regex_cache_.get(regex_key):
dfa = regex2dfa.regex2dfa(regex)
cDFA = fte.cDFA.DFA(dfa, msg_len)
encoder = fte.dfa.DFA(cDFA, msg_len)
regex_cache_[regex_key] = (dfa, encoder)
(self.dfa_, self.encoder_) = regex_cache_[regex_key]
def __init__(self, regex, msg_len):
self.regex_ = regex
regex_key = regex + str(msg_len)
if not regex_cache_.get(regex_key):
dfa = regex2dfa.regex2dfa(regex)
cDFA = fte.cDFA.DFA(dfa, msg_len)
encoder = fte.dfa.DFA(cDFA, msg_len)
regex_cache_[regex_key] = (dfa, encoder)
(self.dfa_, self.encoder_) = regex_cache_[regex_key]
def _test_regex_file(self, filepath):
with open(filepath) as fh:
regex = fh.read()
actual_dfa = regex2dfa.regex2dfa(regex)
filepath_dfa = filepath[:-5] + "dfa"
with open(filepath_dfa) as fh:
expected_dfa = fh.read()
actual_dfa = actual_dfa.strip()
expected_dfa = expected_dfa.strip()
self.assertEquals(expected_dfa, actual_dfa)
def _test_regex_file(self, filepath):
with open(filepath) as fh:
regex = fh.read()
actual_dfa = regex2dfa.regex2dfa(regex)
filepath_dfa = filepath[:-5] + "dfa"
with open(filepath_dfa) as fh:
expected_dfa = fh.read()
actual_dfa = actual_dfa.strip()
expected_dfa = expected_dfa.strip()
self.assertEquals(expected_dfa, actual_dfa)
def get_fte_obj(self):
if self.regex is None and self.fsm is None:
print("Error: No specified format.")
return
if self.regex is not None:
# get fsm from regex
self.fsm = regex2dfa.regex2dfa(self.regex)
# Get FTE Object + increase fixed slice until language is expressive enough
while True:
try:
fteObj = fte.encoder.DfaEncoder(self.fsm, self.fixed_slice)
except Exception as e:
self.fixed_slice += 5
else:
break
return fteObj
def __init__(self, regex, min_len = MIN_PTXT_LEN, msg_lens = amazon_msg_lens):
self.regex_ = regex
self.msg_lens_ = msg_lens
self.random_lens_ = []
for key in self.msg_lens_:
self.random_lens_ += [key] * self.msg_lens_[key]
self.min_len_ = min_len
key = self.regex_ + str(self.min_len_)
if not fte_cache_.get(key):
dfa = regex2dfa.regex2dfa(self.regex_)
encoder = fte.encoder.DfaEncoder(dfa, self.min_len_)
fte_cache_[key] = (dfa, encoder)
self.max_len_ = 2**18
self.target_len_ = 0.0
def FPEncrypt(regex, fixed_slice,input_plaintext): dfa = regex2dfa.regex2dfa(regex) fteObj = fte.encoder.DfaEncoder(dfa, fixed_slice) cifrado = fteObj.encode(input_plaintext) return cifrado
def FPDecrypt(regex, fixed_slice,cifrado):
dfa = regex2dfa.regex2dfa(regex)
fteObj = fte.encoder.DfaEncoder(dfa, fixed_slice)
#print("Debug: len(cifrado) para descifrar %s"%(len(cifrado)))
[output_plaintext, remainder] = fteObj.decode(cifrado)
return output_plaintext
import regex2dfa import fte.encoder regex = '^(a|b)+$' fixed_slice = 512 input_plaintext = 'test' dfa = regex2dfa.regex2dfa(regex) fteObj = fte.encoder.DfaEncoder(dfa, fixed_slice) ciphertext = fteObj.encode(input_plaintext) [output_plaintext, remainder] = fteObj.decode(ciphertext) print 'input_plaintext='+input_plaintext print 'ciphertext='+ciphertext[:16]+'...'+ciphertext[-16:] print 'output_plaintext='+output_plaintext
def FPDecrypt(regex, fixed_slice, cifrado):
dfa = regex2dfa.regex2dfa(regex)
fteObj = fte.encoder.DfaEncoder(dfa, fixed_slice)
#print("Debug: len(cifrado) para descifrar %s"%(len(cifrado)))
[output_plaintext, remainder] = fteObj.decode(cifrado)
return output_plaintext
import regex2dfa import fte.encoder regex = '^(a|b)+$' fixed_slice = 512 input_plaintext = 'test' dfa = regex2dfa.regex2dfa(regex) fteObj = fte.encoder.DfaEncoder(dfa, fixed_slice) ciphertext = fteObj.encode(input_plaintext) [output_plaintext, remainder] = fteObj.decode(ciphertext) print 'input_plaintext=' + input_plaintext print 'ciphertext=' + ciphertext[:16] + '...' + ciphertext[-16:] print 'output_plaintext=' + output_plaintext
def FPDecrypt(regex, fixed_slice,cifrado): dfa = regex2dfa.regex2dfa(regex) fteObj = fte.encoder.DfaEncoder(dfa, fixed_slice) [output_plaintext, remainder] = fteObj.decode(cifrado) return output_plaintext
