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]))
