def shifttext(self, shift, msg):
msg = msg.strip().lower()
data = []
for c in msg:
if c.strip() and c in self.ALPHABET:
data.append(self.ALPHABET[(self.ALPHABET.index(c) + shift) % 26])
else:
data.append(c)
output = ''.join(data)
return output
def check(self, answer):
# Update will only change the message if the timer is expired
self.update()
if answer.strip().lower() == self.message.strip().lower():
self.num_solved += 1
if self.num_solved >= self.num_to_solve:
self.solved = True
else:
# If they're not done, generate a new encrypted message
self.generate_enc_message()
return True
# They have to get all 50 in a row correct
self.reset()
return False
Session.register_challenge(Rot)
from core.challenge import Challenge, ChallengeMetadata
from core.session import Session
from flags import FlagGenerator
FLAGS = FlagGenerator.generate_flags()
class JackIt(Challenge):
meta = ChallengeMetadata(
challenge_id="jackit_game",
name="Game Programming Challenge",
description="2D Side-scrolling game where you modify code to win",
price=0,
value=153,
flag="",
sort_order=1,
js_function="jackIt()")
def __init__(self):
super().__init__()
self.solved = True
self.purchased = True
def check(self, answer):
self.solved = True
return True
Session.register_challenge(JackIt)
from core.challenge import Challenge, ChallengeMetadata
from core.session import Session
from flags import FlagGenerator
FLAGS = FlagGenerator.generate_flags()
class SentenceBot(Challenge):
meta = ChallengeMetadata(challenge_id="sentence_bot",
name="Sentence Bot",
description="RE The Flag",
price=0,
value=FLAGS["sentence_bot_challenge"][1],
flag="",
sort_order=0,
js_function="sentenceBot()")
def __init__(self):
super().__init__()
self.solved = True
self.purchased = True
def check(self, answer):
self.solved = True
return True
Session.register_challenge(SentenceBot)
from core.challenge import Challenge, ChallengeMetadata
from core.session import Session, AuthenticatedSession
from flags import FlagGenerator
FLAGS = FlagGenerator.generate_flags()
class PaidContent(Challenge):
meta = ChallengeMetadata(
challenge_id="paid_content",
name="Paid Content",
description="Pay for things you want!",
price=25,
value=FLAGS["paid_content_challenge"][1],
flag=FLAGS["paid_content_challenge"][0],
js_function="paidContent()",
sort_order=2
)
def check(self, answer):
if isinstance(answer, AuthenticatedSession):
if answer.paid:
self.solved = True
return True
return False
Session.register_challenge(PaidContent)
self.cipher = self.sxor(self.cipher_key, self.message)
def generate_key(self):
key_len = 6
for _ in range(key_len):
self.key += self.alnum[random.randint(0, (len(self.alnum) - 1))]
self.cipher_key = str(self.key) * (int(len(self.message) / len(self.key)) + 1)
def sxor(self, s1, s2):
# convert strings to a list of character pair tuples
# go through each tuple, converting them to ASCII code (ord)
# perform exclusive or on the ASCII code
# then convert the result back to ASCII (chr)
# merge the resulting array of characters as a string
return bytes([(ord(a) ^ ord(b)) for a, b in zip(s1, s2)])
def to_json(self):
obj = super().to_json()
obj.update({
"cipher_text": str(self.cipher.hex())
})
return obj
def check(self, answer):
if answer.strip() == self.key or answer.strip() == self.cipher_key:
self.solved = True
return True
return False
Session.register_challenge(Xor)
from core.challenge import Challenge, ChallengeMetadata
from core.session import Session
from flags import FlagGenerator
FLAGS = FlagGenerator.generate_flags()
class JackIt(Challenge):
meta = ChallengeMetadata(
challenge_id="jackit_game",
name="Game Programming Challenge",
description="2D Side-scrolling game where you modify code to win",
price=0,
value=153,
flag="",
sort_order=1,
js_function="jackIt()"
)
def __init__(self):
super().__init__()
self.solved = True
self.purchased = True
def check(self, answer):
self.solved = True
return True
Session.register_challenge(JackIt)
def __init__(self):
super().__init__()
random.seed()
self.password = ""
self.score = 0
for _ in range(self.password_len):
self.password += self.chars[random.randint(0, len(self.chars) - 1)]
def to_json(self):
obj = super().to_json()
obj.update({"score": self.score})
return obj
def get_fitness(self, answer):
score = 0
for i, c in enumerate(answer):
if self.password[i] == c:
score += 1
self.score = (score / len(self.password)) * 100
if self.score == 100:
# Only solved when the score is 100
self.solved = True
def check(self, answer):
answer = answer.strip()
self.get_fitness(answer)
return True
Session.register_challenge(Genetic)
super().__init__()
random.seed()
self.password = ""
self.score = 0
for _ in range(self.password_len):
self.password += self.chars[random.randint(0, len(self.chars) - 1)]
def to_json(self):
obj = super().to_json()
obj.update({
"score": self.score
})
return obj
def get_fitness(self, answer):
score = 0
for i, c in enumerate(answer):
if self.password[i] == c:
score += 1
self.score = (score / len(self.password)) * 100
if self.score == 100:
# Only solved when the score is 100
self.solved = True
def check(self, answer):
answer = answer.strip()
self.get_fitness(answer)
return True
Session.register_challenge(Genetic)
FLAGS = FlagGenerator.generate_flags()
class SuperAdmin(Challenge):
meta = ChallengeMetadata(challenge_id="super_admin",
name="Super Admin",
description="Are you admin tho?",
price=0,
value=FLAGS["super_admin_challenge"][1],
flag=FLAGS["super_admin_challenge"][0],
js_function="superAdmin()",
sort_order=0)
def __init__(self):
super().__init__()
self.solved = True
self.purchased = True
def to_json(self):
obj = super().to_json()
obj.update({"flag": self.meta.flag})
return obj
def check(self, answer):
self.solved = True
return True
Session.register_challenge(SuperAdmin)
flag=FLAGS["brutal_force_challenge"][0],
js_function="brutalForce()",
sort_order=1)
def __init__(self):
super().__init__()
random.seed() # uses current system time
self.pin = random.randint(666, 9999) # The user's random PIN number
self.pin_hash = hashlib.sha256(str(
self.pin).encode('utf-8')).hexdigest()
def to_json(self):
obj = super().to_json()
obj.update({"pin_hash": self.pin_hash})
return obj
def check(self, answer):
try:
answer = int(answer)
if answer < 1 or answer > 9999:
return False
except ValueError:
return False
if answer == self.pin:
self.solved = True
return True
return False
Session.register_challenge(BrutalForce)
from core.challenge import Challenge, ChallengeMetadata
from core.session import Session, AuthenticatedSession
from flags import FlagGenerator
FLAGS = FlagGenerator.generate_flags()
class PaidContent(Challenge):
meta = ChallengeMetadata(challenge_id="paid_content",
name="Paid Content",
description="Pay for things you want!",
price=25,
value=FLAGS["paid_content_challenge"][1],
flag=FLAGS["paid_content_challenge"][0],
js_function="paidContent()",
sort_order=2)
def check(self, answer):
if isinstance(answer, AuthenticatedSession):
if answer.paid:
self.solved = True
return True
return False
Session.register_challenge(PaidContent)
self.cipher = self.sxor(self.cipher_key, self.message)
def generate_key(self):
key_len = 6
for _ in range(key_len):
self.key += self.alnum[random.randint(0, (len(self.alnum) - 1))]
self.cipher_key = str(
self.key) * (int(len(self.message) / len(self.key)) + 1)
def sxor(self, s1, s2):
# convert strings to a list of character pair tuples
# go through each tuple, converting them to ASCII code (ord)
# perform exclusive or on the ASCII code
# then convert the result back to ASCII (chr)
# merge the resulting array of characters as a string
return bytes([(ord(a) ^ ord(b)) for a, b in zip(s1, s2)])
def to_json(self):
obj = super().to_json()
obj.update({"cipher_text": str(self.cipher.hex())})
return obj
def check(self, answer):
if answer.strip() == self.key or answer.strip() == self.cipher_key:
self.solved = True
return True
return False
Session.register_challenge(Xor)
from core.challenge import Challenge, ChallengeMetadata
from core.session import Session
from flags import FlagGenerator
FLAGS = FlagGenerator.generate_flags()
class SentenceBot(Challenge):
meta = ChallengeMetadata(
challenge_id="sentence_bot",
name="Sentence Bot",
description="RE The Flag",
price=0,
value=FLAGS["sentence_bot_challenge"][1],
flag="",
sort_order=0,
js_function="sentenceBot()"
)
def __init__(self):
super().__init__()
self.solved = True
self.purchased = True
def check(self, answer):
self.solved = True
return True
Session.register_challenge(SentenceBot)
js_function="brutalForce()",
sort_order=1
)
def __init__(self):
super().__init__()
random.seed() # uses current system time
self.pin = random.randint(666, 9999) # The user's random PIN number
self.pin_hash = hashlib.sha256(str(self.pin).encode('utf-8')).hexdigest()
def to_json(self):
obj = super().to_json()
obj.update({
"pin_hash": self.pin_hash
})
return obj
def check(self, answer):
try:
answer = int(answer)
if answer < 1 or answer > 9999:
return False
except ValueError:
return False
if answer == self.pin:
self.solved = True
return True
return False
Session.register_challenge(BrutalForce)
class SuperAdmin(Challenge):
meta = ChallengeMetadata(
challenge_id="super_admin",
name="Super Admin",
description="Are you admin tho?",
price=0,
value=FLAGS["super_admin_challenge"][1],
flag=FLAGS["super_admin_challenge"][0],
js_function="superAdmin()",
sort_order=0
)
def __init__(self):
super().__init__()
self.solved = True
self.purchased = True
def to_json(self):
obj = super().to_json()
obj.update({
"flag": self.meta.flag
})
return obj
def check(self, answer):
self.solved = True
return True
Session.register_challenge(SuperAdmin)
data = []
for c in msg:
if c.strip() and c in self.ALPHABET:
data.append(self.ALPHABET[(self.ALPHABET.index(c) + shift) %
26])
else:
data.append(c)
output = ''.join(data)
return output
def check(self, answer):
# Update will only change the message if the timer is expired
self.update()
if answer.strip().lower() == self.message.strip().lower():
self.num_solved += 1
if self.num_solved >= self.num_to_solve:
self.solved = True
else:
# If they're not done, generate a new encrypted message
self.generate_enc_message()
return True
# They have to get all 50 in a row correct
self.reset()
return False
Session.register_challenge(Rot)
