exception utils.SkipStrategyException(msg, fitness)

Bases: Exception

Raised to signal that this strategy evaluation should be cut off.

__init__(msg, fitness)

Creates the exception with the fitness to pass back

class utils.CustomAdapter(logger, extras)

Bases: logging.LoggerAdapter

Used for demo mode, to change sensitive IP addresses where necessary. Can be used (mostly) like a regular logger.

__init__(logger, extras)

Initialize the adapter with a logger and a dict-like object which provides contextual information. This constructor signature allows easy stacking of LoggerAdapters, if so desired.

You can effectively pass keyword arguments as shown in the following example:

adapter = LoggerAdapter(someLogger, dict(p1=v1, p2=”v2”))

critical(msg, *args, **kwargs)

Print a critical message, uses logger.critical.

debug(msg, *args, **kwargs)

Print a debug message, uses logger.debug.

error(msg, *args, **kwargs)

Print an error message, uses logger.error.


Lookup the assigned random IP for a given real IP. If no random IP exists, a new one is created and a message is logged indicating it.

info(msg, *args, **kwargs)

Print an info message, uses

process(msg, args, kwargs)

Modify the log message to replace any instance of an IP in msg or args with its assigned random IP.

warning(msg, *args, **kwargs)

Print a warning message, uses logger.warning.

regex = re.compile('\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}')
class utils.Logger(log_dir, logger_name, log_name, environment_id, log_level='DEBUG')

Bases: object

Logging class context manager, as a thin wrapper around the logging class to help handle closing open file descriptors.

__init__(log_dir, logger_name, log_name, environment_id, log_level='DEBUG')

Initialize self. See help(type(self)) for accurate signature.


Given a dictionary of arguments, build it back into a command line string.


Closes open file handles for a given logger.


returns log level of console handler

utils.get_from_fuzzed_or_real_packet(environment_id, real_packet_probability, enable_options=True, enable_load=True)

Retrieves a protocol, field, and value from a fuzzed or real packet, depending on the given probability and if given packets is not None.


Returns a random ID


Chooses an interface on the machine to use for socket testing.

utils.get_logger(basepath, log_dir, logger_name, log_name, environment_id, log_level='DEBUG', file_log_level='DEBUG', demo_mode=False)

Configures and returns a logger.


Iterates over this current directory to retrieve plugins.

utils.get_worker(name, logger)

Returns information dictionary about a worker given its name.

utils.import_plugin(plugin, side)

Imports given plugin. :param - plugin: plugin to import (e.g. “http”) :param - side: which side of the connection should be imported (“client” or “server”)

utils.parse(requested_trees, logger)

Parses a string representation of a solution into its object form.

utils.punish_complexity(fitness, logger, ind)

Reduces fitness based on number of actions - optimizes for simplicity.

utils.punish_fitness(fitness, logger, eng)

Adjusts fitness based on additional optimizer functions.

utils.punish_unused(fitness, logger, ind)

Punishes strategy for each action that was not run.


Reads the pcap file associated with the last evaluation of this strategy. Returns a list of Geneva Packet objects.


Sets up Geneva folder structure.


Converts string representations of scapy protocol objects to their actual objects. For example, “TCP” to the scapy TCP object.

utils.write_fitness(fitness, output_path, eid)

Writes fitness to disk.