def __init__(self, name):
super(InplaySwitch, self).__init__(name)
INPLAY_DEFEND = ParallelOne("PARALLEL_DEFEND")
INPLAY_DEFEND.add_child(Analyst.BallMoved("Ball moved"))
EXE_SELECTOR = Selector("EXE_SELECTOR")
ONE_ROBOT = ParallelAll("ONE_ROBOT")
ONE_ROBOT.add_child(Analyst.ThereIsOnlyOneRobot("ThereIsOneRobot"))
ONE_ROBOT.add_child(Attacker.StopGame("AttackerStop", 0))
EXE_SELECTOR.add_child(ONE_ROBOT)
SOME_ROBOTS = ParallelAll("SOME_ROBOTS")
SOME_ROBOTS.add_child(Analyst.ThereAreRobots("ThereAreRobots"))
SOME_ROBOTS.add_child(GoalKeeper.Defense("GoalKeeperDefense",0))
# SOME_ROBOTS.add_child(Attacker.StopGame("AttackerStop", 1))
SOME_ROBOTS.add_child(Attacker.ChipKickGuard("ChipKickGuard", 1))
SOME_ROBOTS.add_child(Defender.Defense("DefenderDefense", 2))
EXE_SELECTOR.add_child(SOME_ROBOTS)
INPLAY_DEFEND.add_child(EXE_SELECTOR)
INPLAY = InPlay.Execute("Execute inplay")
self.add_child(INPLAY_DEFEND)
self.add_child(INPLAY)
def playGameMode():
resetEachFrame()
shouldIStartDefend = Defender.shouldIStartDefend()
shouldIEndDefend = Defender.shouldIEndDefend()
shouldIStrike = Striker.shouldIBecomeStriker()
shouldIBackOff = BackOff.shouldIVisualBackOff()
shouldISupport = Supporter.ShouldIBecomeSupporter()
headFlag = True
if Attacker.lockMode:
print "Entering Lock Mode for Attacker!!!"
Attacker.DecideNextAction()
headFlag = False # for grab/turn/kick
IndicatorAction.showHeadColor((True, True, False))
elif Edger.lockMode:
Edger.DecideNextAction()
headFlag = False
IndicatorAction.showHeadColor((False, True, False))
elif ((shouldIStartDefend or Defender.lockDefender) and \
not shouldIEndDefend):
Global.myRole = Constant.DEFENDER
Defender.DecideNextAction()
IndicatorAction.showHeadColor((True, False, False))
elif shouldIStrike:
Striker.DecideNextAction()
IndicatorAction.showHeadColor((False, False, True))
elif shouldIBackOff:
BackOff.DecideNextAction()
IndicatorAction.showHeadColor((False, True, True))
elif shouldISupport:
Supporter.DecideNextAction()
IndicatorAction.showHeadColor((True, False, True))
elif Edger.shouldIBecomeEdger():
Edger.DecideNextAction()
headFlag = False
IndicatorAction.showHeadColor((False, True, False))
else:
Attacker.DecideNextAction()
IndicatorAction.showHeadColor((True, True, False))
if BackOff.shouldISideBackOff():
Global.myRole = Constant.SIDEBACKOFF
Global.finalAction[Constant.AAForward] = \
Global.finalAction[Constant.AAForward] * 0.6
IndicatorAction.showHeadColor((False, True, True))
if headFlag:
FWHead.DecideNextAction()
if Kick.shouldIContinueKick():
Kick.continueKick()
def __init__(self, name):
super(ExeNormal, self).__init__(name)
self.add_child(Analyst.ThereAreRobots("ThereAreRobots"))
self.add_child(GoalKeeper.StopGame("GoalKeeper", 0))
self.add_child(Attacker.StopGame("Attacker", 1))
self.add_child(Defender.StopGame("Defender", 2))
def __init__(self, name):
super(UltimateOffense, self).__init__(name)
IS_ULTIMATE_OFFENSIVE = Analyst.IsUltimateOffensive(
"IS_ULTIMATE_OFFENSIVE")
EXE_SELECTOR = Selector("EXE_SELECTOR")
ONE_ROBOT = ParallelAll("ONE_ROBOT")
ONE_ROBOT.add_child(Analyst.ThereIsOnlyOneRobot("ThereIsOneRobot"))
ONE_ROBOT.add_child(
GoalKeeper.UltimateOffense("GoalKeeperUltOffense", 0))
EXE_SELECTOR.add_child(ONE_ROBOT)
SOME_ROBOTS = ParallelAll("SOME_ROBOTS")
SOME_ROBOTS.add_child(Analyst.ThereAreRobots("ThereAreRobots"))
SOME_ROBOTS.add_child(
GoalKeeper.UltimateOffense("GoalKeeperUltOffense", 0))
SOME_ROBOTS.add_child(Attacker.UltimateOffense("AttackerUltOffense",
1))
SOME_ROBOTS.add_child(Defender.UltimateOffense("DefenderUltOffense",
2))
EXE_SELECTOR.add_child(SOME_ROBOTS)
self.add_child(IS_ULTIMATE_OFFENSIVE)
self.add_child(EXE_SELECTOR)
def __init__(self, name):
super(Prepare, self).__init__(name)
EXE_SELECTOR = Selector("EXE_SELECTOR")
ONE_ROBOT = ParallelAll("ONE_ROBOT")
ONE_ROBOT.add_child(Analyst.ThereIsOnlyOneRobot("ThereIsOneRobot"))
ONE_ROBOT.add_child(Attacker.StopGame("AttackerStop", 0))
EXE_SELECTOR.add_child(ONE_ROBOT)
SOME_ROBOTS = ParallelAll("SOME_ROBOTS")
SOME_ROBOTS.add_child(Analyst.ThereAreRobots("ThereAreRobots"))
SOME_ROBOTS.add_child(GoalKeeper.Defense("GoalKeeperDefense", 0))
# SOME_ROBOTS.add_child(Attacker.StopGame("AttackerStop", 1))
SOME_ROBOTS.add_child(Attacker.ChipKickGuard("ChipKickGuard", 1))
SOME_ROBOTS.add_child(Defender.SetplayDefense("DefenderDefense", 2))
EXE_SELECTOR.add_child(SOME_ROBOTS)
self.add_child(IsKICKOFF_ENEMY("IsKICKOFF_ENEMY"))
self.add_child(EXE_SELECTOR)
def __init__(self):
#attribute for total turns from FileIO
self.totalTurns = 0
#attributes for attack and defense types
self.probXLowAttack = 0
self.probLowAttack = 0
self.probMediumAttack = 0
self.probHighAttack = 0
self.probXLowDefense = 0
self.probLowDefense = 0
self.probMediumDefense = 0
self.probHighDefense = 0
# attributes for attack and defense tally types
self.tallyHighAttack = 0
self.tallyMediumAttack = 0
self.tallyLowAttack = 0
self.tallyXLowAttack = 0
self.tallyHighDefense = 0
self.tallyMediumDefense = 0
self.tallyLowDefense = 0
self.tallyXLowDefense = 0
# attributes for summary of results and turnbyturn
self.attackType = ""
self.defenseType = ""
self.result = ""
self.num = 1
self.totalBlocks = 0
self.totalHits = 0
# Manager creates 3 objects and calls the following:
self.aFileIO = FileIO()
self.aFileIO.readingFile()
self.assigningProbabiltiesTurns()
self.anAttacker = Attacker(self.probHighAttack,self.probMediumAttack, self.probLowAttack, self.probXLowAttack)
self.aDefender = Defender(self.probHighDefense, self.probMediumDefense, self.probLowDefense, self.probXLowDefense)
def __init__(self, name):
super(ExeOneRobot, self).__init__(name)
self.add_child(Analyst.ThereIsOnlyOneRobot("ThereIsOneRobot"))
self.add_child(Attacker.StopGame("Attacker", 0))
def main():
args = parse_args()
if args.clear and args.clear > 0:
print("Clearing all unnecessary files!")
CommandRunner.run_command("rm -R tmp/ > /dev/null", silent=True)
CommandRunner.run_command("rm -R outputs/ > /dev/null", silent=True)
CommandRunner.run_command("rm -R $HOME/.hashcat > /dev/null",
silent=True)
CommandRunner.run_command("rmdir hashcat* > /dev/null", silent=True)
CommandRunner.run_command("rm hashcat.* > /dev/null", silent=True)
CommandRunner.run_command("rmdir hashcat* > /dev/null", silent=True)
CommandRunner.run_command("rm hashcat.* > /dev/null", silent=True)
CommandRunner.run_command("rm *.pyc > /dev/null", silent=True)
CommandRunner.run_command("rm custom_list.txt > /dev/null",
silent=True)
CommandRunner.run_command("rm -R __pycache__ > /dev/null", silent=True)
print('Done!')
exit(0)
if args.hashes and args.hashes > 0:
print_hashcat_help_without_arguments(args.hashcat_path)
exit(1)
if args.session:
print("Restoring from session " + args.session)
CommandRunner.run_command(args.hashcat_path + " --session " +
args.session + " --restore",
interuptable=True)
phase = CommandRunner.run_command('cat $HOME/.hashcat/sessions/' +
args.session + '.phase',
interuptable=False,
return_value=True,
silent=True)
args.phase = int(phase)
attacker = Attacker.SmartHCAttacker()
attacker.session = "--session " + get_random_token(8)
if not os.path.exists('tmp'):
CommandRunner.run_command("mkdir tmp", silent=True)
if not os.path.exists('outputs'):
CommandRunner.run_command("mkdir outputs", silent=True)
if args.workload_profile < 0 or args.workload_profile > 4:
print("The workload profile can only be 1 <= w <= 4")
exit(1)
else:
attacker.workload_profile = args.workload_profile
if args.company_name:
attacker.company_name = args.company_name
if args.url:
attacker.url = args.url
if args.cewl_depth:
attacker.cewl_depth = args.cewl_depth
if args.force and args.force > 0:
attacker.is_add_force_flag = True
if args.hashcat_hash_type:
attacker.hashcat_hash_option = args.hashcat_hash_type
else:
hash_type = '5600'
attacker.hashcat_hash_option = hash_type
print("Using default hash type NetNTLMv2 (-m {})".format(hash_type))
if args.show:
attacker.show_when_done = args.show > 0
if args.smart_dict:
attacker.smart_file = args.smart_dict
if args.custom_list:
attacker.custom_list = args.custom_list
if not args.hash_file:
print_error_and_usage_then_exit(
"Hash file path (-f) needed for phase 1 to 6!")
else:
attacker.hashes_file = args.hash_file
if args.phase <= 0:
if not args.company_name:
print_error_and_usage_then_exit(
"Company name (-n) needed for phase 0!")
attacker.phase_zero()
if args.phase <= 1:
attacker.attack_dictio()
for i in range(2, 7):
if (args.phase <= i):
attacker.attack_mask(phase_selection=i)
class Manager:
"""
Function: __init__().
@ 1 Argument type: __init__(self)
@returns (none)
"""
def __init__(self):
#attribute for total turns from FileIO
self.totalTurns = 0
#attributes for attack and defense types
self.probXLowAttack = 0
self.probLowAttack = 0
self.probMediumAttack = 0
self.probHighAttack = 0
self.probXLowDefense = 0
self.probLowDefense = 0
self.probMediumDefense = 0
self.probHighDefense = 0
# attributes for attack and defense tally types
self.tallyHighAttack = 0
self.tallyMediumAttack = 0
self.tallyLowAttack = 0
self.tallyXLowAttack = 0
self.tallyHighDefense = 0
self.tallyMediumDefense = 0
self.tallyLowDefense = 0
self.tallyXLowDefense = 0
# attributes for summary of results and turnbyturn
self.attackType = ""
self.defenseType = ""
self.result = ""
self.num = 1
self.totalBlocks = 0
self.totalHits = 0
# Manager creates 3 objects and calls the following:
self.aFileIO = FileIO()
self.aFileIO.readingFile()
self.assigningProbabiltiesTurns()
self.anAttacker = Attacker(self.probHighAttack,self.probMediumAttack, self.probLowAttack, self.probXLowAttack)
self.aDefender = Defender(self.probHighDefense, self.probMediumDefense, self.probLowDefense, self.probXLowDefense)
"""
Function: assigningProbabiltiesTurns()
@ 1 Argument type: assigningProbabiltiesTurns(self)
@returns (none)
"""
def assigningProbabiltiesTurns(self):
# Assigning Attacker Probabilities from FileIO to new variables
self.probHighAttack = self.aFileIO.probHighAttack
self.probMediumAttack = self.aFileIO.probMediumAttack
self.probLowAttack = self.aFileIO.probLowAttack
self.probXLowAttack = self.aFileIO.probExtraLowAttack
# Assigning Defense Probabilities from FileIO to new variables
self.probHighDefense = self.aFileIO.probHighDefense
self.probMediumDefense = self.aFileIO.probMediumDefense
self.probLowDefense = self.aFileIO.probLowDefense
self.probXLowDefense = self.aFileIO.probExtraLowDefense
# Assigning Total Turns from FIleIO to new variable
self.totalTurns = self.aFileIO.totalTurns
"""
Function: checkingHitBlock()
@ 1 Argument type: checkingHitBlock(self)
@returns (string, int, int)
"""
def checkingHitBlock(self):
self.result = ""
if (self.anAttacker.xLowAttack == self.aDefender.xLowDefense) and (self.anAttacker.xLowAttack != 0) and (self.aDefender.xLowDefense != 0):
self.result = "Blocked"
elif (self.anAttacker.lowAttack == self.aDefender.lowDefense) and (self.anAttacker.lowAttack != 0) and (self.aDefender.lowDefense != 0):
self.result = "Blocked"
elif (self.anAttacker.mediumAttack == self.aDefender.mediumDefense) and (self.anAttacker.mediumAttack != 0) and (self.aDefender.mediumDefense != 0):
self.result = "Blocked"
elif (self.anAttacker.highAttack == self.aDefender.highDefense) and (self.anAttacker.highAttack != 0) and (self.aDefender.highDefense != 0):
self.result = "Blocked"
else:
self.result = "Hit"
if (self.result == "Blocked"):
self.totalBlocks = self.totalBlocks + 1
elif (self.result == "Hit"):
self.totalHits = self.totalHits + 1
return (self.result, self.totalBlocks, self.totalHits)
"""
Function: turnByTurnResults()
@ 1 Argument type: turnByTurnResults(self, string)
@returns (none)
"""
def turnByTurnResults(self,results):
print ("MK round %s:\t" %self.num,"ATTACK: %s\t, " %self.anAttacker.attackType, "DEFENSE: %s,\t" %self.aDefender.defenseType, ".........", results)
self.num = self.num + 1
"""
Function: simulationSummary()
@ 1 Argument type: simulationSummary(self, int, int)
@returns (none)
"""
def simulationSummary(self, totalBlocks, totalHits):
print ()
print ("Summary of kombat")
print ("Total hits: %s" %totalHits, " Total blocks: %s" %totalBlocks)
tallyAttacker1 = int ((self.anAttacker.tallyXLowAttack/self.totalTurns)*100)
tallyAttacker2 = int ((self.anAttacker.tallyLowAttack/self.totalTurns)*100)
tallyAttacker3 = int ((self.anAttacker.tallyMediumAttack/self.totalTurns)*100)
tallyAttacker4 = int ((self.anAttacker.tallyHighAttack/self.totalTurns)*100)
print ("Attacker Proportions: X-Low %s%%," %tallyAttacker1, "Low %s%%, " %tallyAttacker2, end="")
print ("Medium %s%%," %tallyAttacker3, "High %s%%" %tallyAttacker4)
tallyDefender1 = int((self.aDefender.tallyXLowDefense/self.totalTurns)*100)
tallyDefender2 = int((self.aDefender.tallyLowDefense/self.totalTurns)*100)
tallyDefender3 = int((self.aDefender.tallyMediumDefense/self.totalTurns)*100)
tallyDefender4 = int((self.aDefender.tallyHighDefense/self.totalTurns)*100)
print ("Defender Proportions: X-Low %s%%," %tallyDefender1, "Low %s%%, " %tallyDefender2, end="")
print ("Medium %s%%," %tallyDefender3, "High %s%%" %tallyDefender4)
"""
Function: runSimulation()
@ 1 Argument type: runSimulation(self)
@returns (none)
"""
def runSimulation(self):
turn = 1
randomNumber = 1
while (turn <= self.aFileIO.totalTurns):
self.anAttacker.randomProbabilitiesAttack(randomNumber)
self.aDefender.randomProbabilitiesDefense(randomNumber)
results, totalBlocks, totalHits = self.checkingHitBlock()
self.turnByTurnResults(results)
turn = turn + 1
self.simulationSummary(totalBlocks,totalHits)