commit 32a0027388f4ce5a9404ab02e3e9a21ed9314465 Author: Arturo Filastò <hellais@torproject.org> Date: Tue Jul 10 20:37:38 2012 +0200 Implement a working b0wser serveside component --- oonib/b0wser.py | 113 ++++++++++++++++++++++++++++++------------------------- 1 files changed, 62 insertions(+), 51 deletions(-) diff --git a/oonib/b0wser.py b/oonib/b0wser.py index 072b4b9..186c9a4 100644 --- a/oonib/b0wser.py +++ b/oonib/b0wser.py @@ -3,13 +3,27 @@ from twisted.internet import protocol class Mutator: idx = 0 step = 0 - state = 0 + waiting = False waiting_step = 0 def __init__(self, steps): self.steps = steps + def _mutate(self, data, idx): + """ + Mutate the idx bytes by increasing it's value by one + + @param data: the data to be mutated. + + @param idx: what byte should be mutated. + """ + print "idx: %s, data: %s" % (idx, data) + ret = data[:idx] + ret += chr(ord(data[idx]) + 1) + ret += data[idx+1:] + return ret + def next_mutation(self): """ Increases by one the mutation state. @@ -18,81 +32,74 @@ class Mutator: before [___*] [____] step1 step2 after [____] [*___] + + Should be called every time you need to proceed onto the next mutation. + It changes the internal state of the mutator to that of the next + mutatation. + + returns True if another mutation is available. + returns False if all the possible mutations have been done. """ - current_idx = self.idx + 1 + if self.step > len(self.steps): + self.waiting = True + return False + + self.idx += 1 + current_idx = self.idx current_step = self.step - current_data = self.steps[c_step]['data'] - data_to_receive = self.steps[c_step]]['recv'] + current_data = self.steps[current_step]['data'] + data_to_receive = self.steps[current_step]['wait'] if self.waiting and self.waiting_step == data_to_receive: + print "I am no longer waiting..." self.waiting = False self.waiting_step = 0 + self.idx = 0 elif self.waiting: + print "Waiting some more..." self.waiting_step += 1 - elif current_idx > len(current_data): + elif current_idx >= len(current_data): + print "Entering waiting mode..." self.step += 1 self.idx = 0 self.waiting = True + print "current index %s current data %s" % (current_idx, len(current_data)) + return True - @classmethod - def mutate(data, idx): - """ - Mutate the idx bytes by increasing it's value by one - - @param data: the data to be mutated. - - @param idx: what byte should be mutated. + def get_mutation(self, state): """ - ret = data[:idx-1] - ret += chr(ord(data[idx]) + 1) - ret += data[idx:] - return ret - - def get_mutation(self): - """ - returns the current packet to be sent to the wire. + Returns the current packet to be sent to the wire. If no mutation is necessary it will return the plain data. - """ - self.next_mutation() - if self.state != self.step or self.waiting: - return self.steps[self.state] + Should be called when you are interested in obtaining the data to be + sent for the selected state. - data = self.steps[self.state] - return self.mutate(data, self.idx) + @param step: the current step you want the mutation for - def get_data(self, i): + returns the mutated packet for the specified step. """ - XXX remove this shit. - """ - j = 0 - pkt_size = len(self.steps[j]['data']) - while i > pkt_size: - j += 1 - pkt_size += len(self.steps[j]) - # I am not in a state to send mutations - if j != self.state: - return self.steps[j]['data'] - - rel_idx = i % (pkt_size - len(self.steps[j-1])) - data = self.steps[j] - data[rel_idx] = chr(ord(data[rel_idx]) + 1) - return data + if step != self.step or self.waiting: + print "I am not going to do anything :)" + return self.steps[step]['data'] + + data = self.steps[step]['data'] + print "Mutating %s with idx %s" % (data, self.idx) + return self._mutate(data, self.idx) class B0wserProtocol(protocol.Protocol): - steps = [{'data': "STEP1", 'recv': 20}, - {'data': "STEP2", 'recv': 20}, - {'data': "STEP3", 'recv': 20}] + steps = [{'data': "STEP1", 'wait': 4}, + {'data': "STEP2", 'wait': 4}, + {'data': "STEP3", 'wait': 4}] mutator = None state = 0 received_data = 0 def next_state(self): - data = self.mutator.get_mutation() + data = self.mutator.get_mutation(self.state) self.transport.write(data) - self.mutator.state += 1 + self.state += 1 self.received_data = 0 def dataReceived(self, data): @@ -100,8 +107,8 @@ class B0wserProtocol(protocol.Protocol): self.transport.loseConnection() return self.received_data += len(data) - if self.received_data >= self.steps[self.state]['recv']: - print self.received_data + if self.received_data >= self.steps[self.state]['wait']: + print "Moving to next state %s" % self.state self.next_state() class B0wserServer(protocol.ServerFactory): @@ -112,6 +119,10 @@ class B0wserServer(protocol.ServerFactory): p.factory = self if addr.host not in self.mutations: - self.mutations[addr.host] = Mutation(p.steps) + self.mutations[addr.host] = Mutator(p.steps) + else: + print "Moving on to next mutation" + self.mutations[addr.host].next_mutation() p.mutator = self.mutations[addr.host] return p +