def create_team():
team = Team()
team.name = "TestTeam"
team.motto = "TestMotto"
dbsession.add(team)
dbsession.commit()
return team
def create_team(self):
''' Create a new team in the database '''
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
self.dbsession.add(team)
self.dbsession.commit()
self.redirect('/admin/view/user_objects')
def post(self, *args, **kwargs):
game_objects = {
'game_level': GameLevel,
'corporation': Corporation,
'flag': Flag,
'box': Box,
'hint': Hint,
}
obj_name = self.get_argument('obj', '')
uuid = self.get_argument('uuid', '')
if obj_name in game_objects.keys():
obj = game_objects[obj_name].by_uuid(uuid)
if obj is not None:
self.write(obj.to_dict())
else:
self.write({'Error': 'Invalid uuid.'})
elif obj_name == "stats":
flag = Flag.by_uuid(uuid)
if flag is not None:
if options.banking:
flaginfo = [{"name": flag.name, "token": flag.token, "price": "$" + str(flag.value)}]
else:
flaginfo = [{"name": flag.name, "token": flag.token, "price": str(flag.value) + " points"}]
captures = []
for item in Flag.captures(flag.id):
team = Team.by_id(item[0])
if team:
captures.append({"name": team.name})
attempts = []
for item in Penalty.by_flag_id(flag.id):
team = Team.by_id(item.team_id)
if team:
attempts.append({"name": team.name, "token": item.token})
hints = []
for item in Hint.taken_by_flag(flag.id):
team = Team.by_id(item.team_id)
hint = Hint.by_id(item.hint_id)
if team:
if options.banking:
hints.append({"name": team.name, "price": "$" + str(hint.price)})
else:
hints.append({"name": team.name, "price": str(hint.price) + " points"})
obj = {
"flag": flaginfo,
"captures": captures,
"attempts": attempts,
"hints": hints,
}
self.write(obj)
else:
self.write({'Error': 'Invalid uuid.'})
else:
self.write({'Error': 'Invalid object type.'})
self.finish()
def create_team(self):
''' Create a new team '''
if self.config.public_teams:
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
else:
raise ValidationError("Public teams are not enabled")
def now(self, app):
''' Returns the current game state '''
game_state = {}
for team in Team.all():
if len(team.members) > 0:
millis = int(round(time.time() * 1000))
game_state[team.name] = {
'uuid': team.uuid,
'flags': [str(flag) for flag in team.flags],
'game_levels': [str(lvl) for lvl in team.game_levels],
}
highlights = {'money': 0, 'flag': 0, 'bot': 0, 'hint': 0}
for item in highlights:
value = team.get_score(item)
game_state[team.name][item] = value
game_history = app.settings['scoreboard_history']
if team.name in game_history:
prev = game_history[team.name][item]
if prev < value:
highlights[item] = millis
else:
highlights[item] = game_history[team.name]['highlights'][item]
highlights['now'] = millis
game_state[team.name]['highlights'] = highlights
app.settings['scoreboard_history'][team.name] = game_state.get(team.name)
return json.dumps(game_state)
def score_bots():
''' Award money for botnets '''
logging.info("Scoring botnets, please wait ...")
bot_manager = BotManager.instance()
for team in Team.all():
bots = bot_manager.by_team(team.name)
reward = 0
for bot in bots:
try:
reward += options.bot_reward
bot.write_message({
'opcode': 'status',
'message': 'Collected $%d reward' % options.bot_reward
})
except:
logging.info(
"Bot at %s failed to respond to score ping" % bot.remote_ip
)
if 0 < len(bots):
logging.info("%s was awarded $%d for controlling %s bot(s)" % (
team.name, reward, len(bots),
))
bot_manager.add_rewards(team.name, options.bot_reward)
bot_manager.notify_monitors(team.name)
team.money += reward
dbsession.add(team)
dbsession.flush()
dbsession.commit()
def post(self, *args, **kwargs):
''' Called to purchase an item '''
uuid = self.get_argument('uuid', '')
item = MarketItem.by_uuid(uuid)
if not item is None:
user = self.get_current_user()
team = Team.by_id(user.team.id) # Refresh object
if user.has_item(item.name):
self.render('market/view.html',
user=user,
errors=["You have already purchased this item."]
)
elif team.money < item.price:
message = "You only have $%d" % (team.money,)
self.render('market/view.html', user=user, errors=[message])
else:
logging.info("%s (%s) purchased '%s' for $%d" % (
user.handle, team.name, item.name, item.price
))
self.purchase_item(team, item)
self.event_manager.item_purchased(user, item)
self.redirect('/user/market')
else:
self.render('market/view.html',
user=self.get_current_user(),
errors=["Item does not exist."]
)
def team_details(self):
print self.get_argument('uuid', '')
team = Team.by_uuid(self.get_argument('uuid', ''))
if team is not None:
self.write(team.to_dict())
else:
self.write({})
def ls(self):
current_user = self.get_current_user()
if self.get_argument('data').lower() == 'accounts':
data = {}
for team in Team.all():
if team == current_user.team:
continue
else:
data[team.name] = {
'money': team.money,
'flags': len(team.flags),
'bots': team.bot_count,
}
self.write({'accounts': data})
elif self.get_argument('data').lower() == 'users':
data = {}
target_users = User.not_team(current_user.team.id)
for user in target_users:
data[user.handle] = {
'account': user.team.name,
'algorithm': user.algorithm,
'password': user.bank_password,
}
self.write({'users': data})
else:
self.write({'Error': 'Invalid data type'})
self.finish()
def create_team(self):
''' Admins can create teams manually '''
try:
name = self.get_argument('team_name', '')
motto = self.get_argument('motto', '')
if Team.by_name(name) is not None:
raise ValidationError("Team already exists")
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
level_0 = GameLevel.all()[0]
self.dbsession.add(team)
self.dbsession.commit()
self.redirect('/admin/users')
except ValidationError as error:
self.render("admin/create/team.html", errors=[str(error), ])
def create_team(self):
''' Admins can create teams manually '''
try:
name = self.get_argument('team_name', '')
if Team.by_name(name) is not None:
raise ValidationError("Team already exists")
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
if not self.config.banking:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
self.dbsession.add(team)
self.dbsession.commit()
# Avatar
avatar_select = self.get_argument('team_avatar_select', '')
if avatar_select and len(avatar_select) > 0:
team._avatar = avatar_select
elif hasattr(self.request, 'files') and 'avatar' in self.request.files:
team.avatar = self.request.files['avatar'][0]['body']
self.dbsession.add(team)
self.dbsession.commit()
self.redirect('/admin/users')
except ValidationError as error:
self.render("admin/create/team.html", errors=[str(error), ])
def now(self):
""" Returns the current game state """
game_state = {}
for team in Team.all():
game_state[team.name] = {
"money": team.money,
"flags": [str(flag) for flag in team.flags],
"game_levels": [str(lvl) for lvl in team.game_levels],
}
return json.dumps(game_state)
def now(self):
''' Returns the current game state '''
game_state = {}
for team in Team.all():
game_state[team.name] = {
'money': team.money,
'flags': [str(flag) for flag in team.flags],
'game_levels': [str(lvl) for lvl in team.game_levels],
}
return json.dumps(game_state)
def transfer(self):
user = self.get_current_user()
source = Team.by_name(self.get_argument('source', ''))
destination = Team.by_name(self.get_argument('destination', ''))
try:
amount = int(self.get_argument('amount', 0))
except ValueError:
amount = 0
victim_user = User.by_handle(self.get_argument('user', None))
password = self.get_argument('password', '')
user = self.get_current_user()
# Validate what we got from the user
if source is None:
self.write({"error": "Source account does not exist"})
elif destination is None:
self.write({"error": "Destination account does not exist"})
elif victim_user is None or victim_user not in source.members:
self.write({"error": "User is not authorized for this account"})
elif victim_user in user.team.members:
self.write({"error": "You cannot steal from your own team"})
elif not 0 < amount <= source.money:
self.write({
"error":
"Invalid transfer amount; must be greater than 0 and less than $%d" % source.money
})
elif destination == source:
self.write({
"error": "Source and destination are the same account"
})
elif victim_user.validate_bank_password(password):
logging.info("Transfer request from %s to %s for $%d by %s" % (
source.name, destination.name, amount, user.handle
))
xfer = self.theft(victim_user, destination, amount, password)
self.write({
"success":
"Confirmed transfer to '%s' for $%d (15%s commission)" % (
destination.name, xfer, '%'
)
})
else:
self.write({"error": "Incorrect password for account, try again"})
self.finish()
def get_team(self):
''' Create a team object, or pull the existing one '''
code = self.get_argument('team-code', '')
if len(code) > 0:
team = Team.by_code(code)
if not team:
raise ValidationError("Invalid team code")
elif self.config.max_team_size <= len(team.members):
raise ValidationError("Team %s is already full" % team.name)
return team
return self.create_team()
def info(self):
team_name = self.get_argument('account')
team = Team.by_name(team_name)
if team is not None:
self.write({
'name': team.name,
'balance': team.money,
'users': [user.handle for user in team.members]
})
else:
self.write({'error': 'Account does not exist'})
self.finish()
def post(self, *args, **kwargs):
try:
group = self.get_argument('team_uuid', 'all')
message = self.get_argument('message', '')
value = int(self.get_argument('money', 0))
if group == 'all':
teams = Team.all()
for team in teams:
team.money += value
self.dbsession.add(team)
self.event_manager.admin_score_update(team, message, value)
else:
team = Team.by_uuid(group)
team.money += value
self.dbsession.add(team)
self.event_manager.admin_score_update(team, message, value)
self.dbsession.commit()
self.redirect('/admin/users')
except ValidationError as error:
self.render('admin/view/users.html',
errors=[str(error), ]
)
def existing_avatars(dir):
avatars = []
if dir == "team":
from models.Team import Team
teams = Team.all()
for team in teams:
if team.avatar is not None and len(team.members) > 0:
avatars.append(team.avatar)
else:
from models.User import User
users = User.all()
for user in users:
if user.avatar is not None:
avatars.append(user.avatar)
return avatars
def edit_team(self):
''' Edits the team object '''
try:
team = Team.by_uuid(self.get_argument('uuid', ''))
if team is None:
raise ValidationError("Team does not exist")
team.name = self.get_argument('name', team.name)
team.motto = self.get_argument('motto', team.motto)
team.money = self.get_argument('money', team.money)
self.dbsession.add(team)
self.dbsession.commit()
self.redirect('/admin/users')
except ValidationError as error:
self.render('admin/view/users.html',
errors=[str(error), ]
)
def edit_user(self):
''' Update user objects in the database '''
try:
user = User.by_uuid(self.get_argument('uuid', ''))
if user is None:
raise ValidationError("User does not exist")
handle = self.get_argument('handle', '')
if user.handle != handle:
if User.by_handle(handle) is None:
logging.info("Updated user handle %s -> %s" % (
user.handle, handle
))
user.handle = handle
else:
raise ValidationError("Handle is already in use")
hash_algorithm = self.get_argument('hash_algorithm', '')
if hash_algorithm != user.algorithm:
if hash_algorithm in user.algorithms:
if 0 < len(self.get_argument('bank_password', '')):
logging.info("Updated %s's hashing algorithm %s -> %s" % (
user.handle, user.algorithm, hash_algorithm,
))
user.algorithm = hash_algorithm
else:
raise ValidationError(
"You must provide a new bank password when updating the hashing algorithm")
else:
raise ValidationError("Not a valid hash algorithm")
user.password = self.get_argument('password', '')
if len(self.get_argument('bank_password', '')):
user.bank_password = self.get_argument('bank_password', '')
team = Team.by_uuid(self.get_argument('team_uuid', ''))
if team is not None:
if user not in team.members:
logging.info("Updated %s's team %s -> %s" % (
user.handle, user.team_id, team.name
))
user.team_id = team.id
else:
raise ValidationError("Team does not exist in database")
self.dbsession.add(user)
self.dbsession.commit()
self.redirect('/admin/users')
except ValidationError as error:
self.render("admin/view/users.html",
errors=[str(error), ]
)
def __now__(self):
''' Returns snapshot object it as a dict '''
snapshot = Snapshot()
bot_manager = BotManager.instance()
#self.dbsession = DBSession()
for team in Team.all():
snapshot_team = SnapshotTeam(
team_id=team.id,
money=team.money,
bots=bot_manager.count_by_team(team)
)
snapshot_team.game_levels = team.game_levels
snapshot_team.flags = team.flags
self.dbsession.add(snapshot_team)
self.dbsession.flush()
snapshot.teams.append(snapshot_team)
self.dbsession.add(snapshot)
self.dbsession.commit()
return snapshot
def edit_teams(self):
''' Edit existing team objects in the database '''
team = Team.by_uuid(self.get_argument('uuid', ''))
if team is not None:
try:
name = self.get_argument('name', '')
if team.name != name:
logging.info("Updated team name %s -> %s" % (team.name, name))
team.name = name
motto = self.get_argument('motto', '')
if team.motto != motto:
logging.info("Updated %s's motto %s -> %s" % (team.name, team.motto, motto))
team.motto = motto
self.dbsession.add(team)
self.dbsession.close()
self.redirect("/admin/view/user_objects")
except ValueError as error:
self.render("admin/view/user_objects.html", errors=["%s" % error])
else:
self.render("admin/view/user_objects.html", errors=["Team does not exist"])
def team_details(self):
''' Returns team details in JSON form '''
uuid = self.get_argument('uuid', '')
team = Team.by_uuid(uuid)
if team is not None:
details = {
'name': team.name,
'game_levels': [],
}
for lvl in team.levels:
lvl_details = {
'number': lvl.number,
'captured':
[flag.name for flag in team.level_flags(lvl.number)],
'total': len(lvl.flags),
}
details['game_levels'].append(lvl_details)
self.write(details)
else:
self.write({'error': 'Team does not exist'})
self.finish()
def del_team(self):
'''
Delete team objects in the database.
'''
team = Team.by_uuid(self.get_argument('uuid', ''))
for user in team.members:
if user == self.get_current_user():
self.render("admin/view/users.html",
errors=["Unable to delete user %s" % user.handle]
)
return
if team is not None:
logging.info("Deleted Team: '%s'" % str(team.name))
self.dbsession.delete(team)
self.dbsession.commit()
self.flush_memcached()
self.redirect("/admin/users")
else:
self.render("admin/view/users.html",
errors=["Team does not exist"]
)
def edit_team(self):
""" Edits the team object """
try:
team = Team.by_uuid(self.get_argument("uuid", ""))
if team is None:
raise ValidationError("Team does not exist")
team.name = self.get_argument("name", team.name)
team.motto = self.get_argument("motto", team.motto)
team.money = self.get_argument("money", team.money)
if hasattr(self.request,
"files") and "avatarfile" in self.request.files:
team.avatar = self.request.files["avatarfile"][0]["body"]
else:
avatar = self.get_argument("avatar", team.avatar)
if team.avatar != avatar and avatar != "":
# allow for default without setting
team._avatar = avatar
self.dbsession.add(team)
self.dbsession.commit()
self.redirect("/admin/users")
except ValidationError as error:
self.render("admin/view/users.html", errors=[str(error)])
def get_new_avatar(dir, forceteam=False):
avatar = default_avatar(dir)
avatars = filter_avatars(dir)
if len(avatars) == 0:
return avatar
if dir == 'team' or forceteam:
from models.Team import Team
cmplist = Team.all()
elif dir == 'user':
from models.User import User
cmplist = User.all()
else:
from models.Box import Box
cmplist = Box.all()
dblist = []
for item in cmplist:
if item._avatar:
dblist.append(item._avatar)
for image in avatars:
if not image in dblist:
return image
return avatars[randint(0, len(avatars) - 1)]
def get_new_avatar(dir, forceteam=False):
avatar = default_avatar(dir)
avatars = filter_avatars(dir)
if len(avatars) == 0:
return avatar
if dir == 'team' or forceteam:
from models.Team import Team
cmplist = Team.all()
elif dir == 'user':
from models.User import User
cmplist = User.all()
else:
from models.Box import Box
cmplist = Box.all()
dblist = []
for item in cmplist:
if item._avatar:
dblist.append(item._avatar)
for image in avatars:
if not image in dblist:
return image
return avatars[randint(0, len(avatars)-1)]
def score_bots():
""" Award money for botnets """
logging.info("Scoring botnets, please wait ...")
bot_manager = BotManager.instance()
config = ConfigManager.instance()
for team in Team.all():
bots = bot_manager.by_team(team.name)
reward = 0
for bot in bots:
try:
reward += config.bot_reward
bot.write_message({"opcode": "status", "message": "Collected $%d reward" % config.bot_reward})
except:
logging.info("Bot at %s failed to respond to score ping" % bot.remote_ip)
if 0 < len(bots):
logging.info("%s was awarded $%d for controlling %s bot(s)" % (team.name, reward, len(bots)))
bot_manager.add_rewards(team.name, config.bot_reward)
bot_manager.notify_monitors(team.name)
team.money += reward
dbsession.add(team)
dbsession.flush()
dbsession.commit()
def del_team(self):
"""
Delete team objects in the database.
"""
team = Team.by_uuid(self.get_argument("uuid", ""))
if team is not None:
logging.info("Deleted Team: '%s'" % str(team.name))
for user in team.members:
if user == self.get_current_user():
self.render(
"admin/view/users.html",
errors=["Unable to delete user %s" % user.handle],
)
return
EventManager.instance().deauth(user)
self.dbsession.delete(team)
self.dbsession.commit()
self.event_manager.push_score_update()
self.redirect("/admin/users")
else:
self.render("admin/view/users.html",
errors=["Team does not exist"])
def edit_team(self):
''' Edits the team object '''
try:
team = Team.by_uuid(self.get_argument('uuid', ''))
if team is None:
raise ValidationError("Team does not exist")
team.name = self.get_argument('name', team.name)
team.motto = self.get_argument('motto', team.motto)
team.money = self.get_argument('money', team.money)
if hasattr(self.request, 'files') and 'avatarfile' in self.request.files:
team.avatar = self.request.files['avatarfile'][0]['body']
else:
avatar = self.get_argument('avatar', team.avatar)
if team.avatar != avatar and avatar != "":
#allow for default without setting
team._avatar = avatar
self.dbsession.add(team)
self.dbsession.commit()
self.redirect('/admin/users')
except ValidationError as error:
self.render('admin/view/users.html',
errors=[str(error), ]
)
def team_details(self):
''' Returns team details in JSON form '''
uuid = self.get_argument('uuid', '')
team = Team.by_uuid(uuid)
if team is not None:
details = {
'name': team.name,
'game_levels': [],
}
for lvl in team.levels:
lvl_details = {
'number':
lvl.number,
'captured':
[flag.name for flag in team.level_flags(lvl.number)],
'total':
len(lvl.flags),
}
details['game_levels'].append(lvl_details)
self.write(details)
else:
self.write({'error': 'Team does not exist'})
self.finish()
def dynamic_value(self, team=None):
if options.dynamic_flag_value is False:
return self.value
elif len(self.team_captures(self.id)) == 0:
return self.value
elif team and self in team.flags:
depreciation = float(old_div(options.flag_value_decrease, 100.0))
deduction = self.value * depreciation
if options.dynamic_flag_type == "decay_all":
reduction = (len(self.team_captures(self.id)) - 1) * deduction
return max(options.flag_value_minimum,
int(self.value - reduction))
else:
for index, item in enumerate(self.team_captures(self.id)):
if team == Team.by_id(item[0]):
reduction = index * deduction
return max(options.flag_value_minimum,
int(self.value - reduction))
else:
depreciation = float(old_div(options.flag_value_decrease, 100.0))
deduction = self.value * depreciation
reduction = len(self.team_captures(self.id)) * deduction
return max(options.flag_value_minimum, int(self.value - reduction))
def edit_team(self):
''' Edits the team object '''
try:
team = Team.by_uuid(self.get_argument('uuid', ''))
if team is None:
raise ValidationError("Team does not exist")
team.name = self.get_argument('name', team.name)
team.motto = self.get_argument('motto', team.motto)
team.money = self.get_argument('money', team.money)
if hasattr(self.request, 'files') and 'avatarfile' in self.request.files:
team.avatar = self.request.files['avatarfile'][0]['body']
else:
avatar = self.get_argument('avatar', team.avatar)
if team.avatar != avatar and avatar != "":
#allow for default without setting
team._avatar = avatar
self.dbsession.add(team)
self.dbsession.commit()
self.redirect('/admin/users')
except ValidationError as error:
self.render('admin/view/users.html',
errors=[str(error), ]
)
def attempts(self, flag):
attempts = []
teamcount = {}
for item in Penalty.by_flag_id(flag.id):
team = Team.by_id(item.team_id)
if team.id in teamcount:
teamcount.update({team.id: teamcount[team.id] + 1})
else:
teamcount.update({team.id: 1})
if team:
if team.id in teamcount:
teamcount.update({team.id: teamcount[team.id] + 1})
else:
teamcount.update({team.id: 1})
entries = {
"name": team.name,
"token": item.token,
"flag": flag.uuid,
"team": team.uuid,
"type": flag.type,
}
if options.penalize_flag_value:
penalty = "-"
if options.banking:
penalty += "$"
if (
teamcount[team.id] < options.flag_start_penalty
or teamcount[team.id] > options.flag_stop_penalty
):
penalty += "0"
else:
penalty += str(
int(flag.value * (options.flag_penalty_cost * 0.01))
)
entries.update({"penalty": penalty})
attempts.append(entries)
return attempts
def score_bots():
""" Award money for botnets """
logging.info("Scoring botnets, please wait ...")
bot_manager = BotManager.instance()
event_manager = EventManager.instance()
for team in Team.all():
if len(team.members) > 0:
bots = bot_manager.by_team(team.name)
if 0 < len(bots):
reward = 0
for bot in bots:
try:
reward += options.bot_reward
bot.write_message({
"opcode":
"status",
"message":
"Collected $%d reward" % options.bot_reward,
})
except:
logging.info(
"Bot at %s failed to respond to score ping" %
bot.remote_ip)
message = "%s was awarded $%d for controlling %s bot(s)" % (
team.name,
reward,
len(bots),
)
bot_manager.add_rewards(team.name, options.bot_reward)
bot_manager.notify_monitors(team.name)
team.money += reward
dbsession.add(team)
dbsession.flush()
event_manager.bot_scored(team, message)
dbsession.commit()
def post(self, *args, **kwargs):
''' Called to purchase an item '''
uuid = self.get_argument('uuid', '')
item = MarketItem.by_uuid(uuid)
if not item is None:
user = self.get_current_user()
team = Team.by_id(user.team.id) # Refresh object
if user.has_item(item.name):
self.render('market/view.html',
user=user,
errors=["You have already purchased this item."])
elif team.money < item.price:
message = "You only have $%d" % (team.money, )
self.render('market/view.html', user=user, errors=[message])
else:
logging.info("%s (%s) purchased '%s' for $%d" %
(user.handle, team.name, item.name, item.price))
self.purchase_item(team, item)
self.event_manager.item_purchased(user, item)
self.redirect('/user/market')
else:
self.render('market/view.html',
user=self.get_current_user(),
errors=["Item does not exist."])
def create_demo_user():
from models.Team import Team
from models.User import User
from models.GameLevel import GameLevel
from models import dbsession
if Team.by_name("player") is None:
user = User()
user.handle = "player"
user.password = "******"
user.name = "player"
user.email = "*****@*****.**"
team = Team()
team.name = "player"
team.motto = "Don't hate the player"
team.money = 0
team.game_levels.append(GameLevel.all()[0])
team.members.append(user)
dbsession.add(user)
dbsession.add(team)
dbsession.commit()
def edit_user(self):
''' Update user objects in the database '''
try:
user = User.by_uuid(self.get_argument('uuid', ''))
if user is None:
raise ValidationError("User does not exist")
handle = self.get_argument('handle', '')
if user.handle != handle:
if User.by_handle(handle) is None:
logging.info("Updated user handle %s -> %s" %
(user.handle, handle))
user.handle = handle
else:
raise ValidationError("Handle is already in use")
name = self.get_argument('name', '')
email = self.get_argument('email', '')
if user.name != name:
logging.info("Updated user Name %s -> %s" % (user.name, name))
user.name = name
if user.email != email:
logging.info("Updated user Email %s -> %s" %
(user.email, email))
user.email = email
if options.banking:
hash_algorithm = self.get_argument('hash_algorithm', '')
if hash_algorithm != user.algorithm:
if hash_algorithm in user.algorithms:
if 0 < len(self.get_argument('bank_password', '')):
logging.info(
"Updated %s's hashing algorithm %s -> %s" % (
user.handle,
user.algorithm,
hash_algorithm,
))
user.algorithm = hash_algorithm
else:
raise ValidationError(
"You must provide a new bank password when updating the hashing algorithm"
)
else:
raise ValidationError("Not a valid hash algorithm")
if len(self.get_argument('bank_password', '')):
user.bank_password = self.get_argument('bank_password', '')
password = self.get_argument('password', '')
if password and len(password) > 0:
user.password = password
if hasattr(self.request,
'files') and 'avatarfile' in self.request.files:
user.avatar = self.request.files['avatarfile'][0]['body']
else:
avatar = self.get_argument('avatar', user.avatar)
#allow for default without setting
user._avatar = avatar
team = Team.by_uuid(self.get_argument('team_uuid', ''))
if team is not None:
if user not in team.members:
logging.info("Updated %s's team %s -> %s" %
(user.handle, user.team_id, team.name))
user.team_id = team.id
elif options.teams:
raise ValidationError("Team does not exist in database")
self.dbsession.add(user)
self.dbsession.commit()
self.redirect('/admin/users')
except ValidationError as error:
self.render("admin/view/users.html", errors=[
str(error),
])
def create_team(self):
""" Create a new team """
if not self.config.teams:
team = Team.by_name(self.get_argument("handle", ""))
if team is None:
team = Team()
team.name = self.get_argument("handle", "")
else:
logging.info(
"Team %s already exists - Player Mode: reset team." %
team.name)
team.flags = []
team.hints = []
team.boxes = []
team.items = []
team.game_levels = []
team.purchased_source_code = []
team.motto = self.get_argument("motto", "")
team._avatar = identicon(team.name, 6)
if self.config.banking:
team.money = self.config.starting_team_money
else:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
elif self.config.public_teams:
if Team.by_name(self.get_argument("team_name", "")) is not None:
raise ValidationError(
"This team name is already registered. Use team code to join that team."
)
team = Team()
team.name = self.get_argument("team_name", "")
team.motto = self.get_argument("motto", "")
if len(filter_avatars("team")) == 0:
team._avatar = identicon(team.name, 6)
if not self.config.banking:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
else:
raise ValidationError("Public teams are not enabled")
def update_gamestate(self, app):
game_state = {
"teams": {},
"levels": {},
"boxes": {},
"hint_count": len(Hint.all()),
"flag_count": len(Flag.all()),
"box_count": len(Box.all()),
"level_count": len(GameLevel.all()),
}
teams = Team.ranks()
for team in teams:
if len(team.members) > 0:
millis = int(round(time.time() * 1000))
game_state["teams"][team.name] = {
"uuid": team.uuid,
"flags": [str(flag) for flag in team.flags],
"game_levels": [str(lvl) for lvl in team.game_levels],
"members_count": len(team.members),
"hints_count": len(team.hints),
"bot_count":
BotManager.instance().count_by_team(team.name),
"money": team.money,
}
highlights = {"money": 0, "flag": 0, "bot": 0, "hint": 0}
for item in highlights:
value = team.get_score(item)
game_state["teams"][team.name][item] = value
game_history = app.settings["scoreboard_history"]
if team.name in game_history:
prev = game_history[team.name][item]
if prev < value:
highlights[item] = millis
else:
highlights[item] = game_history[
team.name]["highlights"][item]
highlights["now"] = millis
game_state["teams"][team.name]["highlights"] = highlights
app.settings["scoreboard_history"][
team.name] = game_state["teams"].get(team.name)
for level in GameLevel.all():
game_state["levels"][level.name] = {
"type": level.type,
"number": level.number,
"teams": {},
"boxes": {},
"box_count": len(level.boxes),
"flag_count": len(level.flags),
}
for team in teams:
game_state["levels"][level.name]["teams"][team.name] = {
"lvl_count": len(team.level_flags(level.number)),
"lvl_unlock": level in team.game_levels,
}
for box in level.boxes:
game_state["levels"][level.name]["boxes"][box.uuid] = {
"name": box.name,
"teams": {},
"flag_count": len(box.flags),
}
for team in teams:
game_state["levels"][level.name]["boxes"][
box.uuid]["teams"][team.name] = {
"box_count": len(team.box_flags(box))
}
app.settings["scoreboard_state"] = game_state
def summary_table(self):
''' Render the "leaderboard" snippit '''
self.render('scoreboard/summary_table.html', teams=Team.ranks())
def post(self, *args, **kwargs):
'''
Reset the Game
'''
errors = []
success = None
try:
users = User.all()
for user in users:
user.money = 0
teams = Team.all()
for team in teams:
if options.banking:
team.money = options.starting_team_money
else:
team.money = 0
team.flags = []
team.hints = []
team.boxes = []
team.items = []
team.purchased_source_code = []
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels = [level_0]
self.dbsession.add(team)
self.dbsession.commit()
self.dbsession.flush()
for team in teams:
for paste in team.pastes:
self.dbsession.delete(paste)
for shared_file in team.files:
shared_file.delete_data()
self.dbsession.delete(shared_file)
self.dbsession.commit()
self.dbsession.flush()
Penalty.clear()
Notification.clear()
snapshot = Snapshot.all()
for snap in snapshot:
self.dbsession.delete(snap)
self.dbsession.commit()
snapshot_team = SnapshotTeam.all()
for snap in snapshot_team:
self.dbsession.delete(snap)
self.dbsession.commit()
game_history = GameHistory.instance()
game_history.take_snapshot() # Take starting snapshot
flags = Flag.all()
for flag in flags:
flag.value = flag._original_value if flag._original_value else flag.value
self.dbsession.add(flag)
self.dbsession.commit()
self.dbsession.flush()
self.flush_memcached()
success = "Successfully Reset Game"
self.render('admin/reset.html', success=success, errors=errors)
except BaseException as e:
errors.append("Failed to Reset Game")
logging.error(str(e))
self.render('admin/reset.html', success=None, errors=errors)
def get_team(self):
''' Create a team object, or pull the existing one '''
team = Team.by_uuid(self.get_argument('team', ''))
if team is not None and self.config.max_team_size <= len(team.members):
raise ValidationError("Team %s is already full" % team.name)
return team if team is not None else self.create_team()
def export_users(self, root):
teams_elem = ET.SubElement(root, "teams")
teams_elem.set("count", str(Team.count()))
for team in Team.all():
team.to_xml(teams_elem)
def post(self, *args, **kwargs):
if args[0] == "statistics" or args[0] == "game_objects":
uri = {
"game_objects": "admin/view/game_objects.html",
"statistics": "admin/view/statistics.html",
}
flag_uuid = self.get_argument("flag_uuid", "")
team_uuid = self.get_argument("team_uuid", "")
flag = Flag.by_uuid(flag_uuid)
team = Team.by_uuid(team_uuid)
errors = []
success = []
if flag:
point_restore = self.get_argument("point_restore", "")
accept_answer = self.get_argument("accept_answer", "")
answer_token = self.get_argument("answer_token", "")
if point_restore == "on" and options.penalize_flag_value and team:
value = int(
flag.dynamic_value(team) *
(options.flag_penalty_cost * 0.01))
team.money += value
penalty = Penalty.by_team_token(flag, team, answer_token)
if penalty:
self.dbsession.delete(penalty)
self.dbsession.add(team)
self.dbsession.commit()
self.event_manager.admin_score_update(
team,
"%s penalty reversed - score has been updated." %
team.name,
value,
)
if flag not in team.flags:
flag_value = flag.dynamic_value(team)
if (self.config.dynamic_flag_value and
self.config.dynamic_flag_type == "decay_all"):
for item in Flag.captures(flag.id):
tm = Team.by_id(item[0])
deduction = flag.dynamic_value(tm) - flag_value
tm.money = int(tm.money - deduction)
self.dbsession.add(tm)
self.event_manager.flag_decayed(tm, flag)
team.money += flag_value
team.flags.append(flag)
self.dbsession.add(team)
self.dbsession.commit()
self.event_manager.flag_captured(team, flag)
self._check_level(flag, team)
success.append("%s awarded %d" % (team.name, flag_value))
if (accept_answer == "on"
and (flag.type == "static" or flag.type == "regex")
and not flag.capture(answer_token)):
flag.type = "regex"
if flag.token.startswith("(") and flag.token.endwith(")"):
token = "%s|(%s)" % (flag.token, answer_token)
else:
token = "(%s)|(%s)" % (flag.token, answer_token)
if len(token) < 256:
flag.token = token
self.dbsession.add(flag)
self.dbsession.commit()
success.append("Token successfully added for Flag %s" %
flag.name)
else:
errors.append(
"Flag token too long. Can not expand token.")
self.render(uri[args[0]], errors=errors, success=success)
else:
self.render("public/404.html")
def post(self, *args, **kwargs):
game_objects = {
"game_level": GameLevel,
"corporation": Corporation,
"flag": Flag,
"box": Box,
"hint": Hint,
}
obj_name = self.get_argument("obj", "")
uuid = self.get_argument("uuid", "")
if obj_name in game_objects.keys():
obj = game_objects[obj_name].by_uuid(uuid)
if obj is not None:
self.write(obj.to_dict())
else:
self.write({"Error": "Invalid uuid."})
elif obj_name == "stats":
flag = Flag.by_uuid(uuid)
if flag is not None:
if options.banking:
flaginfo = [{
"name": flag.name,
"token": flag.token,
"price": "$" + str(flag.value),
}]
else:
flaginfo = [{
"name": flag.name,
"token": flag.token,
"price": str(flag.value) + " points",
}]
captures = []
for item in Flag.captures(flag.id):
team = Team.by_id(item[0])
if team:
captures.append({"name": team.name})
attempts = []
for item in Penalty.by_flag_id(flag.id):
team = Team.by_id(item.team_id)
if team:
attempts.append({
"name": team.name,
"token": item.token
})
hints = []
for item in Hint.taken_by_flag(flag.id):
team = Team.by_id(item.team_id)
hint = Hint.by_id(item.hint_id)
if team:
if options.banking:
hints.append({
"name": team.name,
"price": "$" + str(hint.price)
})
else:
hints.append({
"name": team.name,
"price": str(hint.price) + " points",
})
obj = {
"flag": flaginfo,
"captures": captures,
"attempts": attempts,
"hints": hints,
}
self.write(obj)
else:
self.write({"Error": "Invalid uuid."})
else:
self.write({"Error": "Invalid object type."})
self.finish()
def post(self, *args, **kwargs):
"""
Reset the Game
"""
errors = []
success = None
try:
users = User.all()
for user in users:
user.money = 0
teams = Team.all()
for team in teams:
if options.banking:
team.money = options.starting_team_money
else:
team.money = 0
team.flags = []
team.hints = []
team.boxes = []
team.items = []
team.purchased_source_code = []
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels = [level_0]
self.dbsession.add(team)
self.dbsession.commit()
self.dbsession.flush()
for team in teams:
for paste in team.pastes:
self.dbsession.delete(paste)
for shared_file in team.files:
shared_file.delete_data()
self.dbsession.delete(shared_file)
self.dbsession.commit()
self.dbsession.flush()
Penalty.clear()
Notification.clear()
snapshot = Snapshot.all()
for snap in snapshot:
self.dbsession.delete(snap)
self.dbsession.commit()
snapshot_team = SnapshotTeam.all()
for snap in snapshot_team:
self.dbsession.delete(snap)
self.dbsession.commit()
game_history = GameHistory.instance()
game_history.take_snapshot() # Take starting snapshot
flags = Flag.all()
for flag in flags:
# flag.value = flag.value allows a fallback to when original_value was used
# Allows for the flag value to be reset if dynamic scoring was used
# Can be removed after depreciation timeframe
flag.value = flag.value
self.dbsession.add(flag)
self.dbsession.commit()
self.dbsession.flush()
self.event_manager.push_score_update()
self.flush_memcached()
success = "Successfully Reset Game"
self.render("admin/reset.html", success=success, errors=errors)
except BaseException as e:
errors.append("Failed to Reset Game")
logging.error(str(e))
self.render("admin/reset.html", success=None, errors=errors)
def post(self, *args, **kwargs):
game_objects = {
"game_level": GameLevel,
"corporation": Corporation,
"flag": Flag,
"box": Box,
"hint": Hint,
}
obj_name = self.get_argument("obj", "")
uuid = self.get_argument("uuid", "")
if obj_name in game_objects.keys():
obj = game_objects[obj_name].by_uuid(uuid)
if obj is not None:
self.write(obj.to_dict())
else:
self.write({"Error": "Invalid uuid."})
elif obj_name == "stats":
flag = Flag.by_uuid(uuid)
if flag is not None:
if options.banking:
price = "$" + str(flag.value)
else:
price = str(flag.value) + " points"
flaginfo = [
{
"name": flag.name,
"description": flag.description,
"token": flag.token,
"price": price,
}
]
captures = []
for item in Flag.captures(flag.id):
team = Team.by_id(item[0])
if team:
captures.append({"name": team.name})
attempts = self.attempts(flag)
hints = []
for item in Hint.taken_by_flag(flag.id):
team = Team.by_id(item.team_id)
hint = Hint.by_id(item.hint_id)
if team:
if options.banking:
price = "$" + str(hint.price)
else:
price = str(hint.price) + " points"
hints.append({"name": team.name, "price": price})
obj = {
"flag": flaginfo,
"captures": captures,
"attempts": attempts,
"hints": hints,
}
self.write(obj)
else:
self.write({"Error": "Invalid uuid."})
elif obj_name == "access":
obj = game_objects["game_level"].by_uuid(uuid)
if obj is not None:
all_teams = Team.all()
access = []
available = []
for team in obj.teams:
all_teams.remove(team)
access.append(team.to_dict())
for team in all_teams:
available.append(team.to_dict())
self.write({"available": available, "access": access})
else:
self.write({"Error": "Invalid uuid."})
else:
self.write({"Error": "Invalid object type."})
self.finish()
def create_team(self):
''' Create a new team '''
if not self.config.teams:
team = Team.by_name(self.get_argument('handle', ''))
if team is None:
team = Team()
team.name = self.get_argument('handle', '')
else:
logging.info("Team %s already exists - Player Mode: reset team." % team.name)
team.flags = []
team.hints = []
team.boxes = []
team.items = []
team.game_levels = []
team.purchased_source_code = []
team.motto = self.get_argument('motto', '')
if self.config.banking:
team.money = self.config.starting_team_money
else:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
elif self.config.public_teams:
if Team.by_name(self.get_argument('team_name', '')) is not None:
raise ValidationError("This team name is already registered. Use team code to join that team.")
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
if not self.config.banking:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
else:
raise ValidationError("Public teams are not enabled")
def summary_table(self):
""" Render the "leaderboard" snippit """
self.render("scoreboard/summary_table.html", teams=Team.ranks())
def edit_user(self):
""" Update user objects in the database """
try:
user = User.by_uuid(self.get_argument("uuid", ""))
if user is None:
raise ValidationError("User does not exist")
handle = self.get_argument("handle", "")
if user.handle != handle:
if User.by_handle(handle) is None:
logging.info("Updated user handle %s -> %s" %
(user.handle, handle))
user.handle = handle
else:
raise ValidationError("Handle is already in use")
name = self.get_argument("name", "")
email = self.get_argument("email", "")
if user.name != name:
logging.info("Updated user Name %s -> %s" % (user.name, name))
user.name = name
if user.email != email:
logging.info("Updated user Email %s -> %s" %
(user.email, email))
user.email = email
if options.banking:
hash_algorithm = self.get_argument("hash_algorithm", "")
if hash_algorithm != user.algorithm:
if hash_algorithm in user.algorithms:
if 0 < len(self.get_argument("bank_password", "")):
logging.info(
"Updated %s's hashing algorithm %s -> %s" %
(user.handle, user.algorithm, hash_algorithm))
user.algorithm = hash_algorithm
else:
raise ValidationError(
"You must provide a new bank password when updating the hashing algorithm"
)
else:
raise ValidationError("Not a valid hash algorithm")
if len(self.get_argument("bank_password", "")):
user.bank_password = self.get_argument("bank_password", "")
password = self.get_argument("password", "")
if password and len(password) > 0:
user.password = password
if hasattr(self.request,
"files") and "avatarfile" in self.request.files:
user.avatar = self.request.files["avatarfile"][0]["body"]
else:
avatar = self.get_argument("avatar", user.avatar)
# allow for default without setting
user._avatar = avatar
team = Team.by_uuid(self.get_argument("team_uuid", ""))
if team is not None:
if user not in team.members:
logging.info("Updated %s's team %s -> %s" %
(user.handle, user.team_id, team.name))
user.team_id = team.id
elif options.teams:
raise ValidationError("Team does not exist in database")
self.dbsession.add(user)
admin = self.get_argument("admin", "false")
if admin == "true" and not user.is_admin():
permission = Permission()
permission.name = ADMIN_PERMISSION
permission.user_id = user.id
self.dbsession.add(permission)
elif admin == "false" and user.is_admin():
permissions = Permission.by_user_id(user.id)
for permission in permissions:
if permission.name == ADMIN_PERMISSION:
self.dbsession.delete(permission)
self.dbsession.commit()
self.redirect("/admin/users")
except ValidationError as error:
self.render("admin/view/users.html", errors=[str(error)])
def create_team(self):
''' Create a new team '''
if not self.config.teams:
team = Team.by_name(self.get_argument('handle', ''))
if team is None:
team = Team()
team.name = self.get_argument('handle', '')
else:
logging.info(
"Team %s already exists - Player Mode: reset team." %
team.name)
team.flags = []
team.hints = []
team.boxes = []
team.items = []
team.game_levels = []
team.purchased_source_code = []
team.motto = self.get_argument('motto', '')
if self.config.banking:
team.money = self.config.starting_team_money
else:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
elif self.config.public_teams:
if Team.by_name(self.get_argument('team_name', '')) is not None:
raise ValidationError("This team name is already registered")
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
if not self.config.banking:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
else:
raise ValidationError("Public teams are not enabled")
