def encryption_oracle(plain):
key_length = 16
block_size = 16
rng = SystemRandom()
key = random_bytes(key_length)
mode = rng.randrange(1, 3)
iv = random_bytes(block_size)
if mode == AES.MODE_ECB:
aes = AES.new(key, mode)
else:
aes = AES.new(key, mode, iv=iv)
prefix = random_bytes(rng.randrange(5, 11))
suffix = random_bytes(rng.randrange(5, 11))
plain = pad(prefix + plain + suffix, block_size)
return aes.encrypt(plain)
class Game:
def __init__(self, guaranteed_questions: List[int]):
self.guaranteed_questions = guaranteed_questions
self.question_number = 1
self.game_on = False
self.question_shown = False
self.question_answered = False
self.current_question = []
self.fifty_fifty = 0
self.switch = 0
self.double_dip = 0
self.guaranteed_sum = 0
self.rng = SystemRandom()
self.questions_path = Path("app") / "questions" / "questions.txt"
self.music_path = Path("app") / "music"
common_symbols = ["q" + str(i) for i in range(5, 16)]
common_symbols_two = ["q1-5", "q6-11", "q7-12", "q8-13", "q9-14"]
question_theme_symbols = ["q1-5"] + common_symbols[1:]
question_themes = [
self.music_path / (symbol + "music.mp3")
for symbol in question_theme_symbols
]
final_ans_symbols = common_symbols_two[1:] + ["q10-15"]
final_ans_themes = [
self.music_path / (symbol + "final.mp3")
for symbol in final_ans_symbols
]
correct_ans_symbols = ["q1-4"] + common_symbols
correct_ans_themes = [
self.music_path / (symbol + "correct.mp3")
for symbol in correct_ans_symbols
]
wrong_ans_symbols = common_symbols_two + ["q10"] + ["q15"]
wrong_ans_themes = [
self.music_path / (symbol + "wrong.mp3")
for symbol in wrong_ans_symbols
]
lets_play_symbols = common_symbols_two + ["q10-15"]
lets_play_symbols.remove("q6-11")
lets_play_symbols.insert(1, "q6")
lets_play_symbols.append("q11")
lets_play_themes = [
self.music_path / (symbol + "letsplay.mp3")
for symbol in lets_play_symbols
]
self.lifeline_themes = [
self.music_path / "50-50.mp3",
self.music_path / "doubledip1guess.mp3",
self.music_path / "doubledip1ans.mp3",
self.music_path / "doubledip2guess.mp3",
self.music_path / "doubledip2ans.mp3",
self.music_path / "switchthequestion.mp3"
]
fst_guaranteed = guaranteed_questions[0]
snd_guaranteed = guaranteed_questions[1]
victory = guaranteed_questions[2]
lp_indices = [0] + [-1] * (fst_guaranteed-1) +\
[(i-fst_guaranteed+1) % 7 for i in range(fst_guaranteed, snd_guaranteed+1)] +\
[(i-snd_guaranteed+1) % 7 for i in range(snd_guaranteed+1, victory)]
q_indices = [0] * (fst_guaranteed) + [
(i - fst_guaranteed + 1) % 11
for i in range(fst_guaranteed, victory)
]
fa_indices = [-1] * (fst_guaranteed) + [
(i - fst_guaranteed) % 5 for i in range(fst_guaranteed, victory)
]
ca_indices = [0] * (fst_guaranteed - 1) + [
(i - fst_guaranteed + 1) % 12
for i in range(fst_guaranteed, victory + 1)
]
wa_indices = [0] * (fst_guaranteed) + [(i-fst_guaranteed+1) % 6
for i in range(fst_guaranteed, snd_guaranteed)] +\
[(i-snd_guaranteed+1) % 5
for i in range(snd_guaranteed, victory-1)] + [6]
self.music_settings = [[
lets_play_themes[lp_indices[i]] if lp_indices[i] >= 0 else None,
question_themes[q_indices[i]],
final_ans_themes[fa_indices[i]] if fa_indices[i] >= 0 else None,
correct_ans_themes[ca_indices[i]], wrong_ans_themes[wa_indices[i]]
] for i in range(victory)]
def _get_questions_file_content(self) -> str:
with codecs.open(self.questions_path, "r", "utf-8") as questions_file:
file_content = questions_file.read()
try:
return decryption(file_content.encode())
except (InvalidToken, Error):
return file_content
return None
def get_questions(self) -> None:
questions_data = self._get_questions_file_content().splitlines()
self._questions = [[
int(questions_data[i]), questions_data[i + 1],
questions_data[i + 2], questions_data[i + 3],
questions_data[i + 4], questions_data[i + 5]
] for i in range(0, int(len(questions_data)), 6)]
self._questions = sorted(self._questions, key=lambda x: x[0])
def choose_random_question(self) -> list:
q_split = int(len(self._questions) / self.guaranteed_questions[-1])
minimum = (self.question_number - 1) * q_split
maximum = self.question_number * q_split
if self.question_number == self.guaranteed_questions[-1]:
maximum = len(self._questions) - 1
rand_index = self.rng.randrange(minimum, maximum)
question = self._questions[rand_index]
self._questions.remove(question)
self.current_question = question
return question
def answer_correct(self, answer: str, question: list) -> bool:
return answer == question[2]
def lifeline_fifty_fifty(self, question: list) -> list:
self.fifty_fifty = self.question_number
fst_wrong_answer = question[self.rng.randrange(3, 5)]
question.remove(fst_wrong_answer)
snd_wrong_answer = question[self.rng.randrange(3, 4)]
question.remove(snd_wrong_answer)
return [fst_wrong_answer, snd_wrong_answer]
def lifeline_switch(self):
self.switch = self.question_number
return self.choose_random_question()
def get_music_for_question(self):
if self.question_number != self.guaranteed_questions[-1] + 1:
return self.music_settings[self.question_number - 1]
return None
def reset_lifelines(self):
self.fifty_fifty = 0
self.switch = 0
self.double_dip = 0
from algorithms import sqm
# USED FOR SECURE NUMBER GENERATION
crypto_gen = SystemRandom()
# PUBLIC PARAMETERS
p = crypto_gen.getrandbits(128)
alpha = crypto_gen.getrandbits(128)
# MAKE SURE ALPHA IS A GENERATOR AND SMALLER THAN p
while alpha > p and sqm(alpha, int((p - 1) / 2), p) != 1:
if not sqm(alpha, p - 1, p) == 1:
alpha = crypto_gen.getrandbits(128)
# PRIVATE KEY GENERATING
a = crypto_gen.randrange(2, p - 2) # KEY a
b = crypto_gen.randrange(2, p - 2) # KEY b
# PUBLIC KEYS
K_pub_A = sqm(alpha, a, p) # KEY A
K_pub_B = sqm(alpha, b, p) # KEY B
# SHARED KEY (SECRET)
K_ab = sqm(K_pub_B, a, p)
# CHECK SHARED KEY
if not K_ab == sqm(K_pub_A, b, p):
print("[FATAL ERROR] Shared key's are not matching")
else:
print(f"[PUBLIC] p = ({hex(p)}), alpha = ({hex(alpha)})")
print(f"[PRIVATE EXCHANGED] {hex(K_ab)}")
def save_ans(ans):
with open('/userans/' + sha256(ans.encode('ascii')).hexdigest() + '.cs',
'w') as f:
f.write(ans)
if __name__ == '__main__':
template_txt = ""
user_input = ""
password = ""
session = ""
for i in range(60):
password += chr(randgen.randrange(ord('a'), ord('z') + 1))
for i in range(60):
session += chr(randgen.randrange(ord('a'), ord('z') + 1))
template_path = "./template.cs"
with open(template_path, 'r') as f:
template_txt = f.read()
print(hello_output)
tmp = ""
while tmp != "END":
user_input += tmp + '\n'
tmp = input()
if len(user_input) > PROGRAM_MAX_LEN:
print("too long!!")
sys.exit()
item = input("What are you giving away? ")
n = int(input("How many {} are you giving away? ".format(item)))
participants = int(input("How many people are participating? "))
print("To start, participants 0 through {} get one of the {} (for now...)".format(n - 1, item))
bus = list(range(n))
print()
print("List anyone who was gone, end with a blank line...")
s = n
while True:
line = input()
if line == '':
break
print("Participant {} gets one of the {} (for now) then.".format(s, item))
bus[bus.index(int(line))] = s
s += 1
j = n
for e in range(s, participants):
here = input("Is participant {} here (y/n)? ".format(e)) == 'y'
if not here:
continue
j = j + 1
if rng.random() < n / j:
i = rng.randrange(0, n)
print("Participant {} steals one of the {} from participant {}!".format(e, item, bus[i]))
bus[i] = e
else:
print("Nothing happened.")
class RPSAgent(object):
def __init__(self, configuration):
self.obs = None
self.config = configuration
self.history = pd.DataFrame(
columns=["step", "action", "opponent_action"])
self.history.set_index("step", inplace=True)
self.history = self.history.astype({
"action": np.int,
"opponent_action": np.int
})
# How the game would have happened if we always chose the actions selected by our agent
self.alternate_history = pd.DataFrame(
columns=["step", "action", "opponent_action"])
self.alternate_history.set_index("step", inplace=True)
self.history = self.history.astype({
"action": np.int,
"opponent_action": np.int
})
self.step = 0
self.score = 0
self.random = SystemRandom()
def agent(self,
observation,
configuration=None,
history=None) -> Tuple[int, pd.DataFrame]:
if self.random.randint(0, 10) == 7:
# Change the random seed
self.random = SystemRandom()
if configuration is not None:
self.config = configuration
if history is not None:
self.history = history
self.obs = observation
self.step = self.obs.step
# Append the last action of the opponent to the history
if self.step > 0:
self.history.loc[self.step - 1,
"opponent_action"] = self.obs.lastOpponentAction
self.alternate_history.loc[
self.step - 1, "opponent_action"] = self.obs.lastOpponentAction
self.score = get_score(self.history)
if self.score - 20 > (1000 - self.step):
# Don't waste computation time
action = self.random.randint(0, 2)
if self.random.randint(0, 10) <= 3:
action = (action + 1) % SIGNS
return action, history
# Choose an action and append it to the history
action = self.act()
self.alternate_history.loc[self.step] = {
"action": action,
"opponent_action": None,
}
# Calculate the probability of a win for random play
# Taken from https://www.kaggle.com/c/rock-paper-scissors/discussion/197402
win_prob = 0.5 + 0.5 * math.erf(
((observation.reward - 20) + 1) / math.sqrt(
(2 / 3) * (1000 - observation.step)))
if (win_prob >= 0.92 and get_score(self.history, 10) < 5
and self.random.randrange(0, 100) <= win_prob * 100):
# Try to secure the win with random play
action = self.random.randint(0, 2)
if self.random.randint(0, 10) <= 3:
action = (action + 2) % SIGNS
elif get_score(self.alternate_history, 15) < -4:
# If we got outplayed in the last 15 steps, play the counter of the chosen action´s counter with a
# certain probability
if self.random.randint(0, 100) <= 20:
action = (action + 2) % SIGNS
else:
# Play randomly
action = self.random.randint(0, 2)
if self.random.randint(0, 10) <= 3:
action = (action + 1) % SIGNS
self.history.loc[self.step] = {
"action": action,
"opponent_action": None
}
return action, self.history
def act(self) -> int:
pass
