def get_string(self, parsed): # until this becomes more universal, utf-8 is assumed parsed = helpers.str_to_bytes(parsed) parsed = parsed.replace(b"\t", b"") parsed = parsed.replace(b"\r", b"") parsed = parsed.replace(b"\n", b"") parsed = parsed.replace(b",", b"") parsed = parsed.replace(b"0x", b"") parsed = parsed.replace(b"\\x", b"") value = b"" while parsed: pair = parsed[:2] parsed = parsed[2:] hex_pair = int(pair, 16) if hex_pair > 0x7F: return False value += hex_pair.to_bytes(1, "little") value = value.replace(b"\t", b"") value = value.replace(b"\r", b"") value = value.replace(b"\n", b"") value = value.replace(b",", b"") value = value.replace(b"0x", b"") value = value.replace(b"\\x", b"") return value
def __init__( self, name=None, default_value="", min_length=0, max_length=1, max_mutations=25, step=None, *args, **kwargs ): default_value = helpers.str_to_bytes(default_value) super(RandomData, self).__init__(name=name, default_value=default_value, *args, **kwargs) self.min_length = min_length self.max_length = max_length self.max_mutations = max_mutations self.step = step if self.step: self.max_mutations = (self.max_length - self.min_length) // self.step + 1
def test_udp_broadcast_client(self): """ Given: A SocketConnection 'udp' object with udp_broadcast set, and a UDP server. When: Calling SocketConnection.open(), .send(), .recv(), and .close() Then: send() returns length of payload. and: Sent and received data is as expected. """ try: broadcast_addr = six.next(get_local_non_loopback_ipv4_addresses_info())["broadcast"] except StopIteration: assert False, TEST_ERR_NO_NON_LOOPBACK_IPV4 data_to_send = helpers.str_to_bytes( '"Never drink because you need it, for this is rational drinking, and the ' "way to death and hell. But drink because you do not need it, for this is " 'irrational drinking, and the ancient health of the world."' ) # Given server = MiniTestServer(proto="udp", host="") server.bind() t = threading.Thread(target=server.serve_once) t.daemon = True t.start() # noinspection PyDeprecation uut = SocketConnection( host=broadcast_addr, port=server.active_port, proto="udp", bind=("", server.active_port + 1), udp_broadcast=True, ) uut.logger = logging.getLogger("BoofuzzUTLogger") # When uut.open() send_result = uut.send(data=data_to_send) received = uut.recv(10000) uut.close() # Wait for the other thread to terminate t.join(THREAD_WAIT_TIMEOUT) self.assertFalse(t.is_alive()) # Then self.assertEqual(send_result, len(data_to_send)) self.assertEqual(data_to_send, server.received) self.assertEqual(received, server.data_to_send)
def __init__(self, value, min_length, max_length, max_mutations=25, fuzzable=True, step=None, name=None): """ Generate a random chunk of data while maintaining a copy of the original. A random length range can be specified. For a static length, set min/max length to be the same. @type value: str @param value: Original value @type min_length: int @param min_length: Minimum length of random block @type max_length: int @param max_length: Maximum length of random block @type max_mutations: int @param max_mutations: (Optional, def=25) Number of mutations to make before reverting to default @type fuzzable: bool @param fuzzable: (Optional, def=True) Enable/disable fuzzing of this primitive @type step: int @param step: (Optional, def=None) If not null, step count between min and max reps, otherwise random @type name: str @param name: (Optional, def=None) Specifying a name gives you direct access to a primitive """ super(RandomData, self).__init__() self._value = self._original_value = helpers.str_to_bytes(value) self.min_length = min_length self.max_length = max_length self.max_mutations = max_mutations self._fuzzable = fuzzable self.step = step self._name = name if self.step: self.max_mutations = (self.max_length - self.min_length) // self.step + 1
def __init__(self, name, value, min_length, max_length, max_mutations=25, step=None, *args, **kwargs): """ Generate a random chunk of data while maintaining a copy of the original. A random length range can be specified. For a static length, set min/max length to be the same. @type value: str @param value: Original value @type min_length: int @param min_length: Minimum length of random block @type max_length: int @param max_length: Maximum length of random block @type max_mutations: int @param max_mutations: (Optional, def=25) Number of mutations to make before reverting to default @type step: int @param step: (Optional, def=None) If not null, step count between min and max reps, otherwise random """ super(RandomData, self).__init__(name, value, *args, **kwargs) self._value = self._original_value = helpers.str_to_bytes(value) self.min_length = min_length self.max_length = max_length self.max_mutations = max_mutations self.step = step if self.step: self.max_mutations = (self.max_length - self.min_length) // self.step + 1
def call_original_value(context): context.result = helpers.str_to_bytes(context.uut.original_value())
def result_equals_render(context, value): assert context.uut.render() == b"\x01" + helpers.str_to_bytes(value)
def render(self): return helpers.str_to_bytes("".join([x.value for x in self.definition]))