class Flag(db.Model):
__tablename__ = "flags"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.UnicodeText())
flag = db.Column(db.String(128), index=True, unique=True, nullable=False)
points = db.Column(db.Integer)
machine = db.Column(db.Integer, db.ForeignKey('machines.id'))
def __init__(self, name, flag, points):
h = hashlib.sha512()
h.update(flag + config.SALT)
self.name = name
self.flag = h.hexdigest()
self.points = points
@staticmethod
def get(flag):
h = hashlib.sha512()
h.update(flag + config.SALT)
return Flag.query.filter(Flag.flag == h.hexdigest()).first()
@staticmethod
def total_points():
return db.session.query(db.func.sum(Flag.points)).first()[0] or 0
def __repr__(self):
return '<Flag: {0}: {1:d}>'.format(self.name, self.points)
def serialize(self):
return {
'name': self.name,
'points': self.points,
}
class Handle(db.Model):
__tablename__ = "handles"
id = db.Column(db.Integer, primary_key=True)
handle = db.Column(db.UnicodeText())
score = db.Column(db.Integer)
def __init__(self, handle, score):
self.handle = handle
self.score = score
@staticmethod
def get(handle):
return Handle.query.filter(Handle.handle == handle).first()
@staticmethod
def top_scores(lim=25):
return Handle.query.order_by(db.desc(Handle.score)).limit(lim)
def __repr__(self):
return '<Handle: {0}: {1:d}>'.format(self.handle, self.score)
def serialize(self):
return {
'handle': self.handle,
'score': self.score,
}
class Password(db.Model):
__tablename__ = "passwords"
id = db.Column(db.Integer, primary_key=True)
algo = db.Column(db.String(64))
password = db.Column(db.String, index=True, unique=True, nullable=False)
points = db.Column(db.Integer)
def __init__(self, algo, password, points):
self.algo = algo
self.password = password
self.points = points
@staticmethod
def get(password):
return Password.query.filter(Password.password == password).first()
@staticmethod
def total_points():
return db.session.query(db.func.sum(Password.points)).first()[0] or 0
def __repr__(self):
return '<Password: {0}: {1}: {2:d}>'.format(self.algo, self.password,
self.points)
def serialize(self):
return {
'algo': self.algo,
'password': self.password,
'points': self.points,
}
class Machine(db.Model):
__tablename__ = "machines"
id = db.Column(db.Integer, primary_key=True)
hostname = db.Column(db.String(255))
dirty = db.Column(db.Boolean, default=False)
def __init__(self, hostname):
self.hostname = hostname
def __repr__(self):
return '<Machine: {0}>'.format(self.hostname)
def serialize(self):
return {
'hostname': self.hostname,
'dirty': self.dirty,
}
class PasswordEntry(db.Model):
__tablename__ = "password_entries"
id = db.Column(db.Integer, primary_key=True)
handle = db.Column(db.Integer, db.ForeignKey('handles.id'))
password = db.Column(db.Integer, db.ForeignKey('passwords.id'))
plaintext = db.Column(db.Text)
datetime = db.Column(db.DateTime(), default=datetime.datetime.now)
ip = db.Column(db.String(255))
user_agent = db.Column(db.Unicode(255))
def __init__(self, handle, password, plaintext, ip="", user_agent=""):
self.handle = handle
self.password = password
self.ip = ip
self.user_agent = user_agent
# encrypt the plaintext password before storing
key = RSA.importKey(open(config.ENCRYPT_KEYFILE).read())
cipher = PKCS1_OAEP.new(key)
self.plaintext = base64.b64encode(
cipher.encrypt(plaintext.encode('utf-8')))
def __repr__(self):
return '<PasswordEntry: {0:d}: {1}: {2}>'.format(
self.handle, self.password, self.datetime)
def serialize(self, pw=None):
data = {
'handle': self.handle,
'password': self.password,
'datetime': self.datetime,
}
if pw:
data.update(pw.serialize())
return data
class FlagEntry(db.Model):
__tablename__ = "flag_entries"
id = db.Column(db.Integer, primary_key=True)
handle = db.Column(db.Integer, db.ForeignKey('handles.id'))
flag = db.Column(db.Integer, db.ForeignKey('flags.id'))
datetime = db.Column(db.DateTime(), default=datetime.datetime.now)
ip = db.Column(db.String(255))
user_agent = db.Column(db.Unicode(255))
def __init__(self, handle, flag, ip="", user_agent=""):
self.handle = handle
self.flag = flag
self.ip = ip
self.user_agent = user_agent
def __repr__(self):
return '<FlagEntry: {0:d}: {1}: {2}>'.format(self.handle,
self.flag,
self.datetime)
def serialize(self, flag=None):
data = {
'handle': self.handle,
'flag': self.flag,
'datetime': self.datetime,
}
if flag:
data.update(flag.serialize())
return data