230 lines
7.7 KiB
Raw Normal View History

import random
import actions.utils
import actions.tree
class Strategy(object):
def __init__(self, in_actions, out_actions, environment_id=None):
self.in_actions = in_actions
self.out_actions = out_actions
self.descendents = []
self.in_enabled = True
self.out_enabled = True
self.environment_id = environment_id = -1000
def __str__(self):
Builds a string describing the action trees for this strategy.
return "%s \/ %s" % (self.str_forest(self.out_actions).strip(), self.str_forest(self.in_actions).strip())
def __len__(self):
Returns the number of actions in this strategy.
num = 0
for tree in self.in_actions:
num += len(tree)
for tree in self.out_actions:
num += len(tree)
return num
def str_forest(self, forest):
Returns a string representation of a given forest (inbound or outbound)
rep = ""
for action_tree in forest:
rep += "%s " % str(action_tree)
return rep
def pretty_print(self):
return "%s \n \/ \n %s" % (self.pretty_str_forest(self.out_actions), self.pretty_str_forest(self.in_actions))
def pretty_str_forest(self, forest):
Returns a string representation of a given forest (inbound or outbound)
rep = ""
for action_tree in forest:
rep += "%s\n" % action_tree.pretty_print()
return rep
def initialize(self, logger, num_in_trees, num_out_trees, num_in_actions, num_out_actions, seed, disabled=None):
Initializes a new strategy object randomly.
# Disable specific forests if none requested
if num_in_trees == 0:
self.in_enabled = False
if num_out_trees == 0:
self.out_enabled = False
# If a specific population seed is requested, build using that
if seed:
starting_strat = actions.utils.parse(seed, logger)
self.out_actions = starting_strat.out_actions
self.in_actions = starting_strat.in_actions
return self
self.init_from_scratch(num_in_trees, num_out_trees, num_in_actions, num_out_actions, disabled=disabled)
return self
def init_from_scratch(self, num_in_trees, num_out_trees, num_in_actions, num_out_actions, disabled=None):
Initializes this individual by drawing random actions.
for _ in range(0, num_in_trees):
# Define a new in action tree
in_tree = actions.tree.ActionTree("in")
# Initialize the in tree
in_tree.initialize(num_in_actions, self.environment_id, disabled=disabled)
# Add them to this strategy
for _ in range(0, num_out_trees):
# Define a new out action tree
out_tree = actions.tree.ActionTree("out")
# Initialize the out tree
out_tree.initialize(num_out_actions, self.environment_id, disabled=disabled)
# Add them to this strategy
def act_on_packet(self, packet, logger, direction="out"):
Runs the strategy on a given scapy packet.
# If there are no actions to run for this strategy, just send the packet
if (direction == "out" and not self.out_actions) or \
(direction == "in" and not self.in_actions):
return [packet]
return self.run_on_packet(packet, logger, direction)
def run_on_packet(self, packet, logger, direction):
Runs the strategy on a given packet given the forest direction.
forest = self.out_actions
if direction == "in":
forest = self.in_actions
ran = False
original_packet = packet.copy()
packets_to_send = []
for action_tree in forest:
if action_tree.check(original_packet, logger):
logger.debug(" + %s action tree triggered: %s", direction, str(action_tree))
# If multiple trees run, the previous packet may have been tampered with. Ensure
# we're always acting on a fresh copy
fresh_packet = original_packet.copy()
packets_to_send +=, logger)
ran = True
# If no action tree was applicable, send the packet unimpeded
if not ran:
packets_to_send = [packet]
return packets_to_send
def mutate_dir(self, trees, direction, logger):
Mutates a list of trees. Requires the direction the tree operates on
(in or out).
pick = random.uniform(0, 1)
if pick < 0.1 or not trees:
new_tree = actions.tree.ActionTree(direction)
new_tree.initialize(1, self.environment_id)
elif pick < 0.2 and trees:
elif pick < 0.25 and trees and len(trees) > 1:
for action_tree in trees:
def mutate(self, logger):
Top level mutation function for a strategy. Simply mutates the out
and in trees.
if self.in_enabled:
self.mutate_dir(self.in_actions, "in", logger)
if self.out_enabled:
self.mutate_dir(self.out_actions, "out", logger)
return self
def swap_one(forest1, forest2):
Swaps a random tree from forest1 and forest2.
It picks a random element within forest1 and a random element within forest2,
chooses a random index within each forest, and inserts the random element
assert type(forest1) == list
assert type(forest2) == list
rand_idx1, rand_idx2 = 0, 0
donation, other_donation = None, None
if forest1:
donation = random.choice(forest1)
if len(forest1) > 0:
rand_idx1 = random.choice(list(range(0, len(forest1))))
if forest2:
other_donation = random.choice(forest2)
if len(forest2) > 0:
rand_idx2 = random.choice(list(range(0, len(forest2))))
if other_donation:
forest1.insert(rand_idx1, other_donation)
if donation:
forest2.insert(rand_idx2, donation)
return True
def do_mate(forest1, forest2):
Performs mating between two given forests (lists of trees).
With 80% probability, a random tree from each forest are mated,
otherwise, a random tree is swapped between them.
# If 80% and there are trees in both forests to mate, or
# if there is only 1 tree in each forest, mate those trees
if (random.random() < 0.8 and forest1 and forest2) or \
(len(forest1) == 1 and len(forest2) == 1):
tree1 = random.choice(forest1)
tree2 = random.choice(forest2)
return tree1.mate(tree2)
# Otherwise, swap a random tree from each forest
elif forest1 or forest2:
return swap_one(forest1, forest2)
return False
def mate(ind1, ind2, indpb):
Executes a uniform crossover that modify in place the two
individuals. The attributes are swapped according to the
*indpb* probability.
out_success, in_success = True, True
if ind1.out_enabled and random.random() < indpb:
out_success = do_mate(ind1.out_actions, ind2.out_actions)
if ind1.in_enabled and random.random() < indpb:
in_success = do_mate(ind1.in_actions, ind2.in_actions)
return out_success and in_success