class DynamicChallenge(Challenges):
__mapper_args__ = {'polymorphic_identity': 'dynamic'}
id = db.Column(None, db.ForeignKey('challenges.id'), primary_key=True)
initial = db.Column(db.Integer)
minimum = db.Column(db.Integer)
decay = db.Column(db.Integer)
def __init__(self,
name,
description,
value,
category,
category2,
type='dynamic',
minimum=1,
decay=50):
self.name = name
self.description = description
self.value = value
self.initial = value
self.category = category
self.category2 = category2
self.type = type
self.minimum = minimum
self.decay = decay
class MultiSolves(db.Model):
__tablename__ = "multi_solves"
user_id = db.Column(db.Integer,
db.ForeignKey("users.id", ondelete="CASCADE"),
primary_key=True)
challenge_category = db.Column(db.String(80), primary_key=True)
challenge_data = db.Column(db.String(80), primary_key=True)
class multiChallenge(Challenges):
__mapper_args__ = {"polymorphic_identity": "multi"}
id = db.Column(None, db.ForeignKey("challenges.id"), primary_key=True)
json = db.Column(db.Text)
def __init__(self, *args, **kwargs):
super(multiChallenge, self).__init__(**kwargs)
class KeyedChallenge(Challenges):
__mapper_args__ = {'polymorphic_identity': 'keyed'}
id = db.Column(None, db.ForeignKey('challenges.id'), primary_key=True)
value = db.Column(db.Integer, default=0)
key = db.Column(db.Text, unique=True)
identifier = db.Column(db.Text, unique=True)
salt = db.Column(db.Text, unique=True)
def __init__(self, *args, **kwargs):
super(KeyedChallenge, self).__init__(**kwargs)
self.key = nacl.encoding.Base64Encoder.encode(
nacl.utils.random(nacl.secret.SecretBox.KEY_SIZE))
self.salt = nacl.encoding.Base64Encoder.encode(
nacl.utils.random(nacl.secret.SecretBox.KEY_SIZE))
def getflag(self):
user = get_current_user()
team = get_current_team()
user_id = user.id,
team_id = team.id if team else None,
box = nacl.secret.SecretBox(
nacl.encoding.Base64Encoder.decode(self.key))
salt = nacl.encoding.Base64Encoder.decode(self.salt)
flag = 'U' + str(user_id) + 'T' + str(team_id) + 'F' + salt
return 'flag(' + nacl.encoding.Base64Encoder.encode(
box.encrypt(flag)) + ')'
class FirstBloodChallenge(Challenges):
__mapper_args__ = {"polymorphic_identity": "firstblood"}
id = db.Column(db.Integer,
db.ForeignKey("challenges.id", ondelete="CASCADE"),
primary_key=True)
first_blood_bonus = db.Column(db.JSON)
def __init__(self, *args, **kwargs):
# This is kind of a hack because serializeJSON in CTFd does not support arrays
first_blood_bonus = None
for attr, value in kwargs.items():
if attr.startswith('first_blood_bonus'):
first_blood_bonus = []
if first_blood_bonus is not None:
for i in itertools.count():
attr = 'first_blood_bonus[{0}]'.format(i)
if attr not in kwargs:
break
first_blood_bonus.append(
int(kwargs[attr]) if kwargs[attr] != '' else None)
del kwargs[attr]
while first_blood_bonus[-1] is None:
first_blood_bonus.pop()
kwargs['first_blood_bonus'] = first_blood_bonus
super(FirstBloodChallenge, self).__init__(**kwargs)
class GlowwormConfigs(db.Model):
key = db.Column(db.String(length=128), primary_key=True)
value = db.Column(db.Text)
def __init__(self, key, value):
self.key = key
self.value = value
class IntegratedChallenge(Challenges):
__mapper_args__ = {"polymorphic_identity": "integrated"}
id = db.Column(None, db.ForeignKey("challenges.id"), primary_key=True)
challengeName = db.Column(db.String(200))
def __init__(self, *args, **kwargs):
super(IntegratedChallenge, self).__init__(**kwargs)
self.initial = kwargs["value"]
class OracleChallenges(Challenges):
__mapper_args__ = {"polymorphic_identity": "oracle"}
id = db.Column(None, db.ForeignKey("challenges.id"), primary_key=True)
oracle = db.Column(db.String(255), default="")
def __init__(self, *args, **kwargs):
super(OracleChallenges, self).__init__(**kwargs)
self.oracle = kwargs["oracle"]
class vSphereVMsConfig(db.Model):
id = db.Column(db.Integer, primary_key=True)
option = db.Column(db.Text)
value = db.Column(db.Text)
def __init__(self, option, value):
self.option = option
self.value = value
class JudgeCaseFiles(db.Model):
id = db.Column(db.Integer, primary_key=True)
challenge_id = db.Column(db.Integer, db.ForeignKey('challenges.id'))
location = db.Column(db.Text)
def __init__(self, challenge_id, location):
self.challenge_id = challenge_id
self.location = location
class SteamChallengeModel(Challenges):
__mapper_args__ = {"polymorphic_identity": "steam"}
id = db.Column(None, db.ForeignKey("challenges.id"), primary_key=True)
steam_key = db.Column(db.Text, default="")
steam_gamename = db.Column(db.Text, default="")
# I probably don't need todo this but don't really want to write the SQL query to get the first solver
first_solver = db.Column(db.Integer, db.ForeignKey("users.id"))
def __init__(self, *args, **kwargs):
super(SteamChallengeModel, self).__init__(**kwargs)
class LahChallenge(Challenges):
__mapper_args__ = {'polymorphic_identity': 'lah'}
id = db.Column(None, db.ForeignKey('challenges.id'), primary_key=True)
unlock_order = db.Column(db.Integer, default=99)
is_unlocked = db.Column(db.Boolean, default=False)
def __init__(self, *args, **kwargs):
super(LahChallenge, self).__init__(**kwargs)
self.is_unlocked = int(kwargs['unlock_order']) == 0
class LinearUnlockingModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
is_hidden = db.Column(db.Boolean,
server_default=expression.false(),
nullable=False)
def __init__(self, name):
self.name = name
class ChallengeQuiz(db.Model):
id = db.Column(db.Integer, primary_key=True)
challenge = db.Column(db.Integer,
db.ForeignKey("challenges.id", ondelete="CASCADE"))
quiz = db.Column(db.String(100))
def __init__(self, quiz: str, challenge: Challenges):
self.quiz = quiz
self.challenge = challenge
class VMs(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
chalid = db.Column(db.Integer, db.ForeignKey('challenges.id'))
desc = db.Column(db.Text)
def __init__(self, name, chalid, desc):
self.name = name
self.chalid = chalid
self.desc = desc
class UnlockState(db.Model):
id = db.Column(db.Integer, primary_key=True)
selected = db.Column(db.Integer, db.ForeignKey('lah_challenge.id'), nullable=True, default=None)
unlocker_id = db.Column(None, db.ForeignKey('users.id'), nullable=True, default=1)
expiration = db.Column(db.DateTime, nullable=True, default=datetime.datetime.fromtimestamp(13569465600))
__table_args__ = (
db.CheckConstraint('(selected IS NULL) <> (unlocker_id IS NULL)'),
db.CheckConstraint('(expiration IS NULL) = (unlocker_id IS NULL)'),
)
class MultiAnswerChallenge(Challenges):
__mapper_args__ = {'polymorphic_identity': 'multianswer'}
id = db.Column(db.Integer,
db.ForeignKey("challenges.id", ondelete="CASCADE"),
primary_key=True)
initial = db.Column(db.Integer, default=0)
def __init__(self, *args, **kwargs):
super(DynamicChallenge, self).__init__(**kwargs)
self.initial = kwargs["value"]
class InvitedTeams(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), unique=True)
email = db.Column(db.String(128), unique=True)
token = db.Column(db.String(32), unique=True)
def __init__(self, name, email, token):
self.name = name
self.email = email
self.token = token
class NaumachiaChallengeModel(Challenges):
__mapper_args__ = {'polymorphic_identity': 'naumachia'}
id = db.Column(
db.Integer, db.ForeignKey("challenges.id", ondelete="CASCADE"), primary_key=True
)
naumachia_name = db.Column(db.String(80))
def __init__(self, *args, **kwargs):
super().__init__(**kwargs)
self.naumachia_name = kwargs["naumachia_name"]
class WriteupDynamicChallenge(Challenges):
__mapper_args__ = {"polymorphic_identity": "dynamic_wp"}
id = db.Column(None, db.ForeignKey("challenges.id"), primary_key=True)
initial = db.Column(db.Integer, default=0)
minimum = db.Column(db.Integer, default=0)
decay = db.Column(db.Integer, default=0)
def __init__(self, *args, **kwargs):
super(WriteupDynamicChallenge, self).__init__(**kwargs)
self.initial = kwargs["value"]
class ManualChallenge(Challenges):
__mapper_args__ = {"polymorphic_identity": "manual"}
id = db.Column(db.Integer,
db.ForeignKey("challenges.id", ondelete="CASCADE"),
primary_key=True)
initial = db.Column(db.Integer, default=0)
def __init__(self, *args, **kwargs):
super(ManualChallenge, self).__init__(**kwargs)
self.initial = kwargs["value"]
class Writeup(db.Model):
wid = db.Column(db.Integer,primary_key=True)
cid = db.Column(None,db.ForeignKey("challenges.id"),nullable=False)
uid = db.Column(db.Integer,nullable=False)
path = db.Column(db.String(200),nullable=False)
def __init__(self,cid,uid,path):
self.cid = int(cid)
self.uid = int(uid)
self.path = path
class DynamicChallenge(Challenges):
__mapper_args__ = {'polymorphic_identity': 'dynamic'}
id = db.Column(None, db.ForeignKey('challenges.id'), primary_key=True)
initial = db.Column(db.Integer, default=0)
minimum = db.Column(db.Integer, default=0)
decay = db.Column(db.Integer, default=0)
def __init__(self, *args, **kwargs):
super(DynamicChallenge, self).__init__(**kwargs)
self.initial = kwargs['value']
class WhaleConfig(db.Model):
key = db.Column(db.String(length=128), primary_key=True)
value = db.Column(db.Text)
def __init__(self, key, value):
self.key = key
self.value = value
def __repr__(self):
return "<WhaleConfig (0) {1}>".format(self.key, self.value)
class WhaleContainer(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(None, db.ForeignKey("users.id"))
challenge_id = db.Column(None, db.ForeignKey("challenges.id"))
start_time = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
renew_count = db.Column(db.Integer, nullable=False, default=0)
status = db.Column(db.Integer, default=1)
uuid = db.Column(db.String(256))
port = db.Column(db.Integer, nullable=True, default=0)
flag = db.Column(db.String(128), nullable=False)
# Relationships
user = db.relationship("Users",
foreign_keys="WhaleContainer.user_id",
lazy="select")
challenge = db.relationship("Challenges",
foreign_keys="WhaleContainer.challenge_id",
lazy="select")
def __init__(self, user_id, challenge_id, flag, uuid, port):
self.user_id = user_id
self.challenge_id = challenge_id
self.start_time = datetime.now()
self.renew_count = 0
self.flag = flag
self.uuid = str(uuid)
self.port = port
def __repr__(self):
return "<WhaleContainer ID:(0) {1} {2} {3} {4}>".format(
self.id, self.user_id, self.challenge_id, self.start_time,
self.renew_count)
class WhaleContainer(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(None, db.ForeignKey("users.id"))
challenge_id = db.Column(None, db.ForeignKey("challenges.id"))
start_time = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
renew_count = db.Column(db.Integer, nullable=False, default=0)
status = db.Column(db.Integer, default=1)
uuid = db.Column(db.String(256))
port = db.Column(db.Integer, nullable=True, default=0)
flag = db.Column(db.String(128), nullable=False)
# Relationships
user = db.relationship("Users",
foreign_keys="WhaleContainer.user_id",
lazy="select")
challenge = db.relationship("DynamicDockerChallenge",
foreign_keys="WhaleContainer.challenge_id",
lazy="select")
@property
def http_subdomain(self):
return Template(
get_config('whale:template_http_subdomain',
'{{ container.uuid }}')).render(container=self)
def __init__(self, user_id, challenge_id, port):
self.user_id = user_id
self.challenge_id = challenge_id
self.start_time = datetime.now()
self.renew_count = 0
self.uuid = str(uuid.uuid4())
self.port = port
self.flag = Template(
get_config('whale:template_chall_flag',
'{{ "flag{"+uuid.uuid4()|string+"}" }}')).render(
container=self,
uuid=uuid,
random=random,
get_config=get_config)
@property
def user_access(self):
return Template(
WhaleRedirectTemplate.query.filter_by(
key=self.challenge.redirect_type).first().access_template
).render(container=self, get_config=get_config)
@property
def frp_config(self):
return Template(
WhaleRedirectTemplate.query.filter_by(
key=self.challenge.redirect_type).first().frp_template).render(
container=self, get_config=get_config)
def __repr__(self):
return "<WhaleContainer ID:{0} {1} {2} {3} {4}>".format(
self.id, self.user_id, self.challenge_id, self.start_time,
self.renew_count)
class GenFlagsMap(db.model):
id = db.Column(Integer, db.ForeignKey('challenges.id'))
teamid = db.Column(None, db.ForeignKey('teams.id'), primary_key=True)
description = db.Column(db.Text)
flag = db.Column(db.Text)
def __init__(self, teamid, description, type, flag):
self.teamid = teamid
self.flag = flag
self.type = type
self.description = description
class Dependencies(db.Model):
id = db.Column(db.Integer, primary_key=True)
chalid = db.Column(db.Integer, db.ForeignKey('challenges.id'))
dependson = db.Column(db.Integer, db.ForeignKey('challenges.id'))
def __init__(self, chalid, dependson):
self.chalid = chalid
self.dependson = dependson
def __repr__(self):
return '<dependency {}, {}>'.format(self.chalid, self.dependson)
class Containers(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
buildfile = db.Column(db.Text)
def __init__(self, name, buildfile=''):
self.name = name
self.buildfile = buildfile
def __repr__(self):
return "<Container ID:(0) {1}>".format(self.id, self.name)
class LiveFireChallengeModel(Challenges):
__mapper_args__ = {"polymorphic_identity": "livefire"}
id = db.Column(db.Integer,
db.ForeignKey("challenges.id", ondelete="CASCADE"),
primary_key=True)
vmname = db.Column(db.String(64))
lastrevert = db.Column(db.Text, default=makeDateTime)
def __init__(self, *args, **kwargs):
super(LiveFireChallengeModel, self).__init__(**kwargs)
self.initial = kwargs["value"]
