repo stringlengths 7 90 | file_url stringlengths 81 315 | file_path stringlengths 4 228 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 14:38:15 2026-01-05 02:33:18 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2021/crypto/Keeper_of_the_Flag/kotf.py | ctfs/redpwn/2021/crypto/Keeper_of_the_Flag/kotf.py | #!/usr/local/bin/python3
from Crypto.Util.number import *
from Crypto.PublicKey import DSA
from random import *
from hashlib import sha1
rot = randint(2, 2 ** 160 - 1)
chop = getPrime(159)
def H(s):
x = bytes_to_long(sha1(s).digest())
return pow(x, rot, chop)
L, N = 1024, 160
dsakey = DSA.generate(1024)
p = dsakey.p
q = dsakey.q
h = randint(2, p - 2)
g = pow(h, (p - 1) // q, p)
if g == 1:
print("oops")
exit(1)
print(p)
print(q)
print(g)
x = randint(1, q - 1)
y = pow(g, x, p)
print(y)
def verify(r, s, m):
if not (0 < r and r < q and 0 < s and s < q):
return False
w = pow(s, q - 2, q)
u1 = (H(m) * w) % q
u2 = (r * w) % q
v = ((pow(g, u1, p) * pow(y, u2, p)) % p) % q
return v == r
pad = randint(1, 2 ** 160)
signed = []
for i in range(2):
print("what would you like me to sign? in hex, please")
m = bytes.fromhex(input())
if m == b'give flag' or m == b'give me all your money':
print("haha nice try...")
exit()
if m in signed:
print("i already signed that!")
exit()
signed.append(m)
k = (H(m) + pad + i) % q
if k < 1:
exit()
r = pow(g, k, p) % q
if r == 0:
exit()
s = (pow(k, q - 2, q) * (H(m) + x * r)) % q
if s == 0:
exit()
print(H(m))
print(r)
print(s)
print("ok im done for now")
print("you visit the flag keeper...")
print("for flag, you must bring me signed message:")
print("'give flag':" + str(H(b"give flag")))
r1 = int(input())
s1 = int(input())
if verify(r1, s1, b"give flag"):
print(open("flag.txt").readline())
else:
print("sorry")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2021/crypto/retrosign/server.py | ctfs/redpwn/2021/crypto/retrosign/server.py | #!/usr/local/bin/python
from Crypto.Util.number import getPrime, bytes_to_long
from Crypto.Hash import SHA256
from binascii import unhexlify
from secrets import randbelow
with open('flag.txt','r') as f:
flag = f.read().strip()
def sha256(val):
h = SHA256.new()
h.update(val)
return h.digest()
def execute(cmd):
if cmd == "sice_deets":
print(flag)
elif cmd == "bad_signature":
print("INTRUSION DETECTED!")
else:
print("Command unknown.")
def authorize_command(cmd, sig):
assert len(sig) == 128*2
a = bytes_to_long(sig[:128])
b = bytes_to_long(sig[128:])
if (a**2 + k*b**2) % n == bytes_to_long(sha256(cmd)):
execute(cmd.decode())
else:
execute("bad_signature")
p = getPrime(512)
q = getPrime(512)
n = p * q
k = randbelow(n)
def interact():
print("===============================================================================")
print("This mainframe is protected with state-of-the-art intrusion detection software.")
print("All commands are passed through a signature-based filter.")
print("===============================================================================")
print("The following configuration is in place:")
print(f"n = {n};\nk = {k};")
print("Server configured.")
cmd = input(">>> ").strip().lower().encode()
sig = unhexlify(input("$$$ "))
authorize_command(cmd, sig)
print("Connection closed.")
if __name__ == "__main__":
try:
interact()
except:
print("An error has occurred.")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2021/web/cool/app.py | ctfs/redpwn/2021/web/cool/app.py | from flask import (
Flask,
request,
render_template_string,
session,
redirect,
send_file
)
from random import SystemRandom
import sqlite3
import os
app = Flask(__name__)
app.secret_key = os.getenv('FLASK_KEY')
rand = SystemRandom()
allowed_characters = set(
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789'
)
def execute(query):
con = sqlite3.connect('db/db.sqlite3')
cur = con.cursor()
cur.execute(query)
con.commit()
return cur.fetchall()
def generate_token():
return ''.join(
rand.choice(list(allowed_characters)) for _ in range(32)
)
def create_user(username, password):
if any(c not in allowed_characters for c in username):
return (False, 'Alphanumeric usernames only, please.')
if len(username) < 1:
return (False, 'Username is too short.')
if len(password) > 50:
return (False, 'Password is too long.')
other_users = execute(
f'SELECT * FROM users WHERE username=\'{username}\';'
)
if len(other_users) > 0:
return (False, 'Username taken.')
execute(
'INSERT INTO users (username, password)'
f'VALUES (\'{username}\', \'{password}\');'
)
return (True, '')
def check_login(username, password):
if any(c not in allowed_characters for c in username):
return False
correct_password = execute(
f'SELECT password FROM users WHERE username=\'{username}\';'
)
if len(correct_password) < 1:
return False
return correct_password[0][0] == password
@app.route('/', methods=['GET', 'POST'])
def login():
error = ''
if request.method == 'POST':
valid_login = check_login(
request.form['username'],
request.form['password']
)
if valid_login:
session['username'] = request.form['username']
return redirect('/message')
error = 'Incorrect username or password.'
if 'username' in session:
return redirect('/message')
return render_template_string('''
<link rel="stylesheet" href="/static/style.css" />
<div class="container">
<p>Log in to see Aaron's message!</p>
<form method="POST">
<label for="username">Username</label>
<input type="text" name="username" />
<label for="password">Password</label>
<input type="password" name="password" />
<input type="submit" value="Log In" />
</form>
<p>{{ error }}</p>
<a href="/register">Register</a>
<div class="container">
''', error=error)
@app.route('/register', methods=['GET', 'POST'])
def register():
message = ''
if request.method == 'POST':
success, message = create_user(
request.form['username'],
request.form['password']
)
if success:
session['username'] = request.form['username']
return redirect('/message')
return render_template_string('''
<link rel="stylesheet" href="/static/style.css" />
<div class="container">
<p>Register!</p>
<form method="POST">
<label for="username">Username</label>
<input type="text" name="username" />
<label for="password">Password</label>
<input type="password" name="password" />
<input type="submit" value="Register" />
</form>
<p>{{ error }}</p>
</div>
''', error=message)
@app.route('/message')
def message():
if 'username' not in session:
return redirect('/')
if session['username'] == 'ginkoid':
return send_file(
'flag.mp3',
attachment_filename='flag-at-end-of-file.mp3'
)
return '''
<link rel="stylesheet" href="/static/style.css" />
<div class="container">
<p>You are logged in!</p>
<p>Unfortunately, Aaron's message is for cool people only.</p>
<p>(like ginkoid)</p>
<a href="/logout">Log out</a>
</div>
'''
@app.route('/logout')
def logout():
if 'username' not in session:
return redirect('/')
del session['username']
return redirect('/')
def init():
# this is terrible but who cares
execute('''
CREATE TABLE IF NOT EXISTS users (
username TEXT PRIMARY KEY,
password TEXT
);
''')
execute('DROP TABLE users;')
execute('''
CREATE TABLE users (
username TEXT PRIMARY KEY,
password TEXT
);
''')
# put ginkoid into db
ginkoid_password = generate_token()
execute(
'INSERT OR IGNORE INTO users (username, password)'
f'VALUES (\'ginkoid\', \'{ginkoid_password}\');'
)
execute(
f'UPDATE users SET password=\'{ginkoid_password}\''
f'WHERE username=\'ginkoid\';'
)
init()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2021/web/pastebin-3/app/app.py | ctfs/redpwn/2021/web/pastebin-3/app/app.py | import os
import secrets
import sqlite3
from flask import (
Flask,
flash,
redirect,
render_template,
request,
session
)
app = Flask(__name__)
app.secret_key = os.getenv('FLASK_KEY')
def execute(query, params=()):
con = sqlite3.connect('../db/db.sqlite3')
cur = con.cursor()
cur.execute(query, params)
con.commit()
return cur.fetchall()
def check_login(username, password):
(result,), = execute(
'''
SELECT EXISTS(
SELECT * FROM users WHERE
username = ? AND
password = ?
);
''',
params=(username, password)
)
return result
def create_account(username, password):
if len(username) < 4:
return (False, 'Username too short.')
(exists,), = execute(
'''
SELECT EXISTS(
SELECT * FROM users WHERE username = ?
);
''',
params=(username,)
)
if exists:
return (False, 'Username taken.')
execute(
'INSERT INTO users (username, password) VALUES (?, ?);',
params=(username, password)
)
return (True, '')
def create_paste(paste, username):
paste_id = secrets.token_hex(32)
execute(
'INSERT INTO pastes (id, paste, username) VALUES (?, ?, ?);',
params=(paste_id, paste, username)
)
return paste_id
def get_pastes(username):
return [paste_id[0] for paste_id in execute(
'SELECT id FROM pastes WHERE username = ?',
params=(username,)
)]
def get_paste(paste_id):
results = execute(
'SELECT paste FROM pastes WHERE id = ?',
params=(paste_id,)
)
if len(results) < 1:
return 'Paste not found!'
return results[0][0]
@app.route('/')
def index():
if 'username' in session:
return redirect('/home')
return render_template('index.html')
@app.route('/login', methods=['POST'])
def login():
success = check_login(
request.form['username'],
request.form['password']
)
if success:
session['username'] = request.form['username']
flash('Logged in successfully!')
return redirect('/home')
flash('Incorrect username or password.')
return redirect('/')
@app.route('/register', methods=['GET', 'POST'])
def register():
if 'username' in session:
return redirect('/home')
if request.method == 'POST':
username = request.form['username']
success, message = create_account(
username,
request.form['password']
)
if not success:
flash(message)
return redirect('/register')
session['username'] = username
flash('Account created successfully.')
return redirect('/home')
return render_template('register.html')
@app.route('/home')
def home():
if 'username' not in session:
return redirect('/')
return render_template(
'home.html',
pastes=get_pastes(session['username'])
)
@app.route('/create_paste', methods=['POST'])
def create():
if 'username' not in session:
return redirect('/')
paste_id = create_paste(
request.form['paste'],
session['username']
)
return redirect(f'/view?id={paste_id}')
@app.route('/view', methods=['GET'])
def view():
paste_id = request.args.get('id')
return render_template(
'view.html',
paste_id=paste_id,
sandbox_url=os.getenv('SANDBOX_URL')
)
@app.route('/search')
def search():
if 'username' not in session:
return redirect('/')
if 'query' not in request.args:
flash('Please provide a query!')
return redirect('/home')
query = str(request.args.get('query'))
results = (
paste for paste in get_pastes(session['username'])
if query in get_paste(paste)
)
try:
flash(f'Result found: {next(results)}.')
except StopIteration:
flash('No results found.')
return redirect('/home')
@app.route('/logout')
def logout():
if 'username' in session:
del session['username']
return redirect('/')
def init():
# this is terrible but who cares
execute('''
CREATE TABLE IF NOT EXISTS users (
username TEXT PRIMARY KEY,
password TEXT
);
''')
execute('DROP TABLE users;')
execute('''
CREATE TABLE users (
username TEXT PRIMARY KEY,
password TEXT
);
''')
# we also need a table for pastes
execute('''
CREATE TABLE IF NOT EXISTS pastes (
id TEXT PRIMARY KEY,
paste TEXT,
username TEXT
);
''')
execute('DROP TABLE pastes;')
execute('''
CREATE TABLE pastes (
id TEXT PRIMARY KEY,
paste TEXT,
username TEXT
);
''')
# put admin into db
admin_password = secrets.token_hex(32)
execute(
'INSERT OR IGNORE INTO users (username, password) VALUES (?, ?);',
params=('admin', admin_password)
)
execute(
'UPDATE users SET password = ? WHERE username = ?;',
params=(admin_password, 'admin')
)
create_paste(os.getenv('FLAG'), 'admin')
init()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2021/web/pastebin-3/sandbox/app.py | ctfs/redpwn/2021/web/pastebin-3/sandbox/app.py | import sqlite3
from flask import (
Flask,
render_template_string,
request,
)
app = Flask(__name__)
def execute(query, params=()):
con = sqlite3.connect('../db/db.sqlite3')
cur = con.cursor()
cur.execute(query, params)
con.commit()
return cur.fetchall()
def get_paste(paste_id):
results = execute(
'SELECT paste FROM pastes WHERE id = ?',
params=(paste_id,)
)
if len(results) < 1:
return 'Paste not found!'
return results[0][0]
@app.route('/')
def index():
paste_id = request.args.get('id')
return render_template_string(
'''
<script src="/static/purify.min.js"></script>
<script>
(async() => {
await new Promise(
(resolve) => window.addEventListener('load', resolve)
);
document.body.innerHTML = DOMPurify.sanitize(
`{{ paste | tojson }}`.slice(1, -1)
);
})()
</script>
''',
paste=get_paste(paste_id)
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/rev/drive/run.py | ctfs/redpwn/2022/rev/drive/run.py | #!/usr/local/bin/python
import subprocess
from binascii import unhexlify
i = input()
p = subprocess.run(["./drive"], input=unhexlify(i), capture_output=True)
print(p.stdout.decode())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/rev/slices/slices.py | ctfs/redpwn/2022/rev/slices/slices.py |
flag = input('Enter flag: ')
def fail():
print('Wrong!')
exit(-1)
if len(flag) != 32: fail()
if flag[:5] != 'hope{': fail()
if flag[-1] != '}': fail()
if flag[5::3] != 'i0_tnl3a0': fail()
if flag[4::4] != '{0p0lsl': fail()
if flag[3::5] != 'e0y_3l': fail()
if flag[6::3] != '_vph_is_t': fail()
if flag[7::3] != 'ley0sc_l}': fail()
print('Congrats!')
print('flag is: ', flag)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/rev/dumb/check.py | ctfs/redpwn/2022/rev/dumb/check.py |
import json
import subprocess
flag = input('Flag: ').encode('ascii')
assert len(flag) == 32
inp = {
"flag": list(bytes(flag))
}
open('tmp_input.json', 'w').write(json.dumps(inp))
rcode = subprocess.run('snarkjs wc ./parts/main.wasm tmp_input.json tmp_witness.wtns', shell=True)
if rcode.returncode == 1:
print('Failed!')
exit(-1)
print('Generating proof...')
subprocess.run('snarkjs plonk prove parts/circuit_final.zkey tmp_witness.wtns tmp_proof.json tmp_public.json', shell=True)
print('Do you know the flag?')
pub = json.load(open('tmp_public.json', 'r'))
print('Public: ', pub)
if pub == ["1"]:
print('good :)')
else:
print('bad :(')
subprocess.run('snarkjs plonk verify parts/verification_key.json tmp_public.json tmp_proof.json', shell=True)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/rev/dumb/proof.py | ctfs/redpwn/2022/rev/dumb/proof.py | import json
import subprocess
print('I know the flag:')
pub = json.load(open('parts/public.json', 'r'))
print('Public: ', pub)
if pub == ["1"]:
print('good :)')
else:
print('bad :(')
subprocess.run('snarkjs plonk verify parts/verification_key.json parts/public.json parts/proof.json', shell=True)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/crypto/replacement/encrypt.py | ctfs/redpwn/2022/crypto/replacement/encrypt.py | import random
with open('text.txt') as f:
plaintext = f.read()
with open('flag.txt') as f:
plaintext += '\n' + f.read()
characters = set(plaintext) - {'\n'}
shuffled = list(characters)
random.shuffle(shuffled)
replacement = dict(zip(characters, shuffled))
ciphertext = ''.join(replacement.get(c, c) for c in plaintext)
with open('output.txt', 'w') as f:
f.write(ciphertext)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/crypto/obp/encrypt.py | ctfs/redpwn/2022/crypto/obp/encrypt.py | import random
with open('flag.txt', 'rb') as f:
plaintext = f.read()
key = random.randrange(256)
ciphertext = [key ^ byte for byte in plaintext]
with open('output.txt', 'w') as f:
f.write(bytes(ciphertext).hex())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/crypto/streamlined/streamlined.py | ctfs/redpwn/2022/crypto/streamlined/streamlined.py | import random
with open("aooo.txt", "r") as f:
plaintext = f.read()
assert len(plaintext) == 14332
with open("flag.txt", "r") as f:
flag = f.read()
assert len(flag) == 52 and flag.startswith("hope{") and flag.endswith("}")
plaintext = plaintext + flag
plaintext = plaintext.encode()
N = 8 * len(plaintext)
plaintext_bits = ["{:08b}".format(i) for i in plaintext]
plaintext_bits = "".join(plaintext_bits)
plaintext_bits = [int(i) for i in plaintext_bits]
key_bits = [random.randrange(2) for i in range(N // 5)] * (5 + 1)
ciphertext_bits = [i ^ j for i,j in zip(plaintext_bits, key_bits)]
ciphertext_string = ''.join([str(i) for i in ciphertext_bits])
with open("stream_output.txt", "w") as f:
f.write(ciphertext_string)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/crypto/small-fortune/script.py | ctfs/redpwn/2022/crypto/small-fortune/script.py | from Crypto.Util.number import *
from gmpy2 import legendre
flag = bytes_to_long(open("flag.txt", "rb").read())
p, q = getPrime(256), getPrime(256)
n = p * q
x = getRandomRange(0, n)
while legendre(x, p) != -1 or legendre(x, q) != -1:
x = getRandomRange(0, n)
def gm_encrypt(msg, n, x):
y = getRandomRange(0, n)
enc = []
while msg:
bit = msg & 1
msg >>= 1
enc.append((pow(y, 2) * pow(x, bit)) % n)
y += getRandomRange(1, 2**48)
return enc
print("n =", n)
print("x =", x)
print("enc =", gm_encrypt(flag, n, x)) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/crypto/reverse-rsa/reverse-rsa.py | ctfs/redpwn/2022/crypto/reverse-rsa/reverse-rsa.py | #!/usr/local/bin/python
import re
from Crypto.Util.number import isPrime, GCD
flag_regex = rb"hope{[a-zA-Z0-9_\-]+}"
with open("ciphertext.txt", "r") as f:
c = int(f.read(), 10)
print(f"Welcome to reverse RSA! The encrypted flag is {c}. Please provide the private key.")
p = int(input("p: "), 10)
q = int(input("q: "), 10)
e = int(input("e: "), 10)
N = p * q
phi = (p-1) * (q-1)
if (p < 3) or not isPrime(p) or (q < 3) or not isPrime(q) or (e < 2) or (e > phi) or GCD(p,q) > 1 or GCD(e, phi) != 1:
print("Invalid private key")
exit()
d = pow(e, -1, phi)
m = pow(c, d, N)
m = int.to_bytes(m, 256, 'little')
m = m.strip(b"\x00")
if re.fullmatch(flag_regex, m) is not None:
print("Clearly, you must already know the flag!")
with open('flag.txt','rb') as f:
flag = f.read()
print(flag.decode())
else:
print("hack harder")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/crypto/pem/generate.py | ctfs/redpwn/2022/crypto/pem/generate.py | from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
with open('flag.txt','rb') as f:
flag = f.read()
key = RSA.generate(2048)
cipher_rsa = PKCS1_OAEP.new(key)
enc = cipher_rsa.encrypt(flag)
with open('privatekey.pem','wb') as f:
f.write(key.export_key('PEM'))
with open("encrypted.bin", "wb") as f:
f.write(enc)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/crypto/DESpicable-you/encrypt.py | ctfs/redpwn/2022/crypto/DESpicable-you/encrypt.py | from os import urandom
def encipher(a,b):
c = ''
for i, j in zip(a,b):
c+=chr(ord(i)^ord(j))
return c
def rekey(key):
k = ""
for i,c in enumerate(key):
if i == len(key)-1:
k += c
k += chr(ord(c)^ord(key[0]))
else:
k += c
k += chr(ord(c)^ord(key[i+1]))
key = k
def main():
key = urandom(8)
with open('flag.txt') as f:
plaintext = f.read()
i = 0
ct = ''
while i < len(plaintext):
ct += encipher(plaintext[i:i+len(key)],key)
i += len(key)
rekey(key)
f2 = open('output.txt', 'w')
f2.write(ct)
f2.close()
main()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/crypto/kfb/server.py | ctfs/redpwn/2022/crypto/kfb/server.py | #!/usr/local/bin/python -u
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad
from Crypto.Util.strxor import strxor
from more_itertools import ichunked
BLOCK = AES.block_size
FLAG = open('flag.txt', 'rb').read().strip()
def encrypt_block(k, pt):
cipher = AES.new(k, AES.MODE_ECB)
return cipher.encrypt(pt)
def encrypt(k, pt):
assert len(k) == BLOCK
pt = pad(pt, BLOCK)
ct = b''
for bk in ichunked(pt, BLOCK):
ct += strxor(encrypt_block(k, k), bytes(bk))
return ct
def main():
k = get_random_bytes(BLOCK)
enc = encrypt(k, FLAG)
print(f'> {enc.hex()}')
pt = bytes.fromhex(input('< '))[:BLOCK]
enc = encrypt(k, pt)
print(f'> {enc.hex()}')
if __name__ == '__main__':
main()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/oeps/server.py | ctfs/redpwn/2022/web/oeps/server.py | from aiohttp import web
class Server:
def __init__(self):
self.app = web.Application()
def get(self, path, c_type='text/html'):
def handle(handler):
decorated_handler = self._handle_factory(handler, c_type)
self.app.add_routes([web.get(path, decorated_handler)])
return handle
def post(self, path, c_type='text/html'):
def handle(handler):
decorated_handler = self._handle_factory(handler, c_type)
self.app.add_routes([web.post(path, decorated_handler)])
return handle
def _handle_factory(self, handler, c_type):
async def decorated_handler(request):
status, data, headers, *_ = await handler(request) + ({},)
if status == 200:
return web.Response(
text=data,
content_type=c_type,
headers=headers
)
if status == 302:
raise web.HTTPFound(location=data)
return web.Response(text=data, status=status, headers=headers)
return decorated_handler
def run(self, host, port):
web.run_app(self.app, host=host, port=port)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/oeps/app.py | ctfs/redpwn/2022/web/oeps/app.py | import os
import random
import sqlite3
from server import Server
# database stuff
connection = sqlite3.connect(':memory:')
def init():
connection.execute('''
create table approved (
id integer primary key autoincrement,
sentence text
);
''')
connection.execute('''
create table pending (
id integer primary key autoincrement,
user text,
sentence text
);
''')
connection.execute('''
create table users (
token text
);
''')
connection.execute('''
create table flags (
flag text
);
''')
initial = [
'rats live on no evil star',
'kayak',
'mr owl ate my metal worm',
'do geese see god',
'313',
'a man a plan a canal panama',
'doc note i dissent a fast never prevents a fatness i diet on cod',
'live on time emit no evil',
]
for palindrome in initial:
connection.execute('''
insert into approved (sentence) values ('%s');
''' % palindrome)
connection.execute('''
insert into flags (flag) values ('%s');
''' % os.environ.get('FLAG', 'flag is missing!'))
init()
# handle requests
ALLOWED_CHARACTERS = set(
'abcdefghijklmnopqrstuvwxyz' +
'ABCDEFGHIJKLMNOPQRSTUVWXYZ' +
'0123456789 '
)
server = Server()
@server.get('/')
async def root(request):
token = request.cookies.get('token', '')
requires_cookie = (
any(c not in ALLOWED_CHARACTERS for c in token) or
len(connection.execute('''
select * from users where token = '%s';
''' % token).fetchall()) != 1
)
headers = {}
if requires_cookie:
token = ''.join(random.choice('0123456789abcdef') for _ in range(32))
headers['set-cookie'] = f'token={token}'
connection.execute('''
insert into users (token) values ('%s');
''' % token)
pending = connection.execute('''
select sentence from pending where user = '%s';
''' % token).fetchall()
return (200, '''
<title>OEPS</title>
<link rel="stylesheet" href="/style.css" />
<div class="container">
<h1>The On-Line Encyclopedia of Palidromic Sentences</h1>
Enter a word or phrase:
<form action="/search" method="GET">
<input type="text" name="search" placeholder="on" />
<input type="submit" value="Search" />
</form>
<h2>Submit Sentence:</h2>
New palindrome:
<form action="/submit" method="POST">
<input type="text" name="submission" />
<input type="submit" value="Submit" />
</form>
<div style="color: red">%s</div>
<h2>Pending submissions:</h2>
<ul>%s</ul>
</div>
''' % (
request.query.get('error', '').replace('<', '<'),
''.join(f'<li>{palindrome}</li>' for (palindrome,) in pending),
), headers)
@server.get('/search')
async def search(request):
if 'error' in request.query:
return (200, '''
<title>OEPS</title>
<link rel="stylesheet" href="/style.css" />
<div class="container">
<h1>The On-Line Encyclopedia of Palidromic Sentences</h1>
Enter a word or phrase:
<form action="/search" method="GET">
<input type="text" name="search" placeholder="on" />
<input type="submit" value="Search" />
</form>
<div style="color: red">%s</div>
<hr noshade />
</div>
''' % request.query.get('error', '').replace('<', '<'))
else:
search = request.query.get('search', '')
if search == '':
return (302, '/search?error=Search cannot be empty!')
if any(c not in ALLOWED_CHARACTERS for c in search):
return (302, '/search?error=Search must be alphanumeric!')
result = connection.execute('''
select sentence from approved where sentence like '%%%s%%';
''' % search).fetchall()
count = len(result)
return (200, '''
<title>OEPS</title>
<link rel="stylesheet" href="/style.css" />
<div class="container">
<h1>The On-Line Encyclopedia of Palidromic Sentences</h1>
Enter a word or phrase:
<form action="/search" method="GET">
<input type="text" name="search" placeholder="on" />
<input type="submit" value="Search" />
</form>
<hr noshade />
<h2>%s</h2>
<ul>%s</ul>
</div>
''' % (
'No results.' if count == 0 else f'Results ({count}):',
''.join(f'<li>{palindrome}</li>' for (palindrome,) in result),
))
@server.post('/submit')
async def submit(request):
token = request.cookies.get('token', '')
logged_in = (
all(c in ALLOWED_CHARACTERS for c in token) and
len(connection.execute('''
select * from users where token = '%s';
''' % token).fetchall()) == 1
)
if not logged_in:
return (302, '/?error=Authentication error.')
data = await request.post()
submission = data.get('submission', '')
if submission == '':
return (302, '/?error=Submission cannot be empty.')
stripped = submission.replace(' ', '')
if stripped != stripped[::-1]:
return (302, '/?error=Submission must be a palindrome.')
connection.execute('''
insert into pending (user, sentence) values ('%s', '%s');
''' % (
token,
submission
))
return (302, '/')
@server.get('/style.css', c_type='text/css')
async def style(request):
del request
return (200, '''
* {
font-family: 'Helvetica Neue', sans-serif;
box-sizing: border-box;
}
html, body { margin: 0; }
.container {
padding: 2rem;
width: 90%;
max-width: 900px;
margin: auto;
}
input:not([type="submit"]) {
width: 100%;
padding: 8px;
margin: 8px 0;
}
''')
server.run('0.0.0.0', 3000)
connection.close()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/secure-page/server.py | ctfs/redpwn/2022/web/secure-page/server.py | from aiohttp import web
class Server:
def __init__(self):
self.app = web.Application()
def get(self, path, c_type='text/html'):
def handle(handler):
decorated_handler = self._handle_factory(handler, c_type)
self.app.add_routes([web.get(path, decorated_handler)])
return handle
def post(self, path, c_type='text/html'):
def handle(handler):
decorated_handler = self._handle_factory(handler, c_type)
self.app.add_routes([web.post(path, decorated_handler)])
return handle
def _handle_factory(self, handler, c_type):
async def decorated_handler(request):
status, data, headers, *_ = await handler(request) + ({},)
if status == 200:
return web.Response(
text=data,
content_type=c_type,
headers=headers
)
if status == 302:
raise web.HTTPFound(location=data)
return web.Response(text=data, status=status, headers=headers)
return decorated_handler
def run(self, host, port):
web.run_app(self.app, host=host, port=port)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/secure-page/app.py | ctfs/redpwn/2022/web/secure-page/app.py | import os
from server import Server
server = Server()
@server.get('/')
async def root(request):
admin = request.cookies.get('admin', '')
headers = {}
if admin == '':
headers['set-cookie'] = 'admin=false'
if admin == 'true':
return (200, '''
<title>Secure Page</title>
<link rel="stylesheet" href="/style.css" />
<div class="container">
<h1>Secure Page</h1>
%s
</div>
''' % os.environ.get('FLAG', 'flag is missing!'), headers)
else:
return (200, '''
<title>Secure Page</title>
<link rel="stylesheet" href="/style.css" />
<div class="container">
<h1>Secure Page</h1>
Sorry, you must be the admin to view this content!
</div>
''', headers)
@server.get('/style.css', c_type='text/css')
async def style(request):
del request
return (200, '''
* {
font-family: 'Helvetica Neue', sans-serif;
box-sizing: border-box;
}
html, body { margin: 0; }
.container {
padding: 2rem;
width: 90%;
max-width: 900px;
margin: auto;
}
input:not([type="submit"]) {
width: 100%;
padding: 8px;
margin: 8px 0;
}
''')
server.run('0.0.0.0', 3000)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/flag-viewer/server.py | ctfs/redpwn/2022/web/flag-viewer/server.py | from aiohttp import web
class Server:
def __init__(self):
self.app = web.Application()
def get(self, path, c_type='text/html'):
def handle(handler):
decorated_handler = self._handle_factory(handler, c_type)
self.app.add_routes([web.get(path, decorated_handler)])
return handle
def post(self, path, c_type='text/html'):
def handle(handler):
decorated_handler = self._handle_factory(handler, c_type)
self.app.add_routes([web.post(path, decorated_handler)])
return handle
def _handle_factory(self, handler, c_type):
async def decorated_handler(request):
status, data, headers, *_ = await handler(request) + ({},)
if status == 200:
return web.Response(
text=data,
content_type=c_type,
headers=headers
)
if status == 302:
raise web.HTTPFound(location=data)
return web.Response(text=data, status=status, headers=headers)
return decorated_handler
def run(self, host, port):
web.run_app(self.app, host=host, port=port)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/flag-viewer/app.py | ctfs/redpwn/2022/web/flag-viewer/app.py | import os
import random
from server import Server
server = Server()
@server.get('/')
async def root(request):
return (200, '''
<title>Flag Viewer</title>
<link rel="stylesheet" href="/style.css" />
<div class="container">
<h1>The Flag Viewer</h1>
<form action="/flag" method="POST">
<input
type="text"
name="user"
placeholder="Username"
pattern="^(?!admin).*$"
oninvalid="this.setCustomValidity('Name not allowed!')"
oninput="this.setCustomValidity('')"
/>
<input type="submit" value="Submit" />
</form>
<div>%s</div>
</div>
''' % (
request.query.get('message', '').replace('<', '<'),
))
@server.post('/flag')
async def flag(request):
data = await request.post()
user = data.get('user', '')
if user != 'admin':
return (302, '/?message=Only the "admin" user can see the flag!')
return (302, f'/?message={os.environ.get("FLAG", "flag missing!")}')
@server.get('/style.css', c_type='text/css')
async def style(request):
del request
return (200, '''
* {
font-family: 'Helvetica Neue', sans-serif;
box-sizing: border-box;
}
html, body { margin: 0; }
.container {
padding: 2rem;
width: 90%;
max-width: 900px;
margin: auto;
}
input:not([type="submit"]) {
width: 100%;
padding: 8px;
margin: 8px 0;
}
''')
server.run('0.0.0.0', 3000)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/reverser/app.py | ctfs/redpwn/2022/web/reverser/app.py | from flask import Flask, render_template_string, request
app = Flask(__name__)
@app.get('/')
def index():
result = '''
<link rel="stylesheet" href="style.css" />
<div class="container">
<h1>Text Reverser</h1>
Reverse any text... now as a web service!
<form method="POST">
<input type="text" name="text">
<input type="submit" value="Reverse">
</form>
</div>
'''
return render_template_string(result)
@app.post('/')
def reverse():
result = '''
<link rel="stylesheet" href="style.css" />
<div class="container">
<h1>Text Reverser</h1>
Reverse any text... now as a web service!
<form method="POST">
<input type="text" name="text">
<input type="submit" value="Reverse">
</form>
<p>Output: %s</p>
</div>
'''
output = request.form.get('text', '')[::-1]
return render_template_string(result % output)
@app.get('/style.css')
def style():
return '''
* {
font-family: 'Helvetica Neue', sans-serif;
box-sizing: border-box;
}
html, body { margin: 0; }
.container {
padding: 2rem;
width: 90%;
max-width: 900px;
margin: auto;
}
input:not([type="submit"]) {
width: 100%;
padding: 8px;
margin: 8px 0;
}
'''
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/your-space/app/model.py | ctfs/redpwn/2022/web/your-space/app/model.py | from datetime import datetime
from sqlalchemy.ext.hybrid import hybrid_property
from werkzeug.security import check_password_hash, generate_password_hash
from . import db, login
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), unique=True, nullable=False)
_password = db.Column(db.String(96), nullable=False)
webhook = db.Column(db.String(96), nullable=False, default="")
spaces = db.relationship("Space", backref="user", lazy=True)
subscriptions = db.relationship("Subscription", backref="user", lazy=True)
def check_password(self, password):
return check_password_hash(self.password, password)
@hybrid_property
def password(self):
return self._password
@password.setter
def password(self, password):
self._password = generate_password_hash(password)
@staticmethod
@login.user_loader
def get_by_id(user_id):
return User.query.get(int(user_id))
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
return str(self.id)
class Subscription(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
space_id = db.Column(db.Integer, db.ForeignKey("space.id"))
class Space(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
name = db.Column(db.String(32), nullable=False, default="")
posts = db.relationship("Post", backref="space", lazy=True)
subscriptions = db.relationship("Subscription", backref="space", lazy=True)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
space_id = db.Column(db.Integer, db.ForeignKey("space.id"), nullable=False)
content = db.Column(db.Text(), nullable=False, default="")
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/your-space/app/form.py | ctfs/redpwn/2022/web/your-space/app/form.py | from flask_wtf import FlaskForm
from wtforms import (
PasswordField,
StringField,
SubmitField,
TextAreaField,
ValidationError,
)
from wtforms.validators import InputRequired, Length
from .model import User
def validate_username(_form, field):
if User.query.filter_by(username=field.data).count():
raise ValidationError("username is taken")
class LoginForm(FlaskForm):
username = StringField(
"username", validators=[InputRequired("username is required")]
)
password = PasswordField(
"password", validators=[InputRequired("password is required")]
)
submit = SubmitField("login")
class RegisterForm(FlaskForm):
username = StringField(
"username",
validators=[
InputRequired("username is required"),
Length(max=32, message="username too long"),
validate_username,
],
)
password = PasswordField(
"password", validators=[InputRequired("password is required")]
)
submit = SubmitField("register")
class SpaceForm(FlaskForm):
name = StringField(
"name",
validators=[
InputRequired("name is required"),
Length(max=32, message="name too long"),
],
)
submit = SubmitField("create")
class WebhookForm(FlaskForm):
webhook = StringField(
"webhook",
validators=[
InputRequired("webhook is required"),
Length(max=96, message="webhook too long"),
],
)
submit = SubmitField("update")
class PostForm(FlaskForm):
content = TextAreaField("content")
submit = SubmitField("post")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/your-space/app/config.py | ctfs/redpwn/2022/web/your-space/app/config.py | import os
class Config:
SQLALCHEMY_DATABASE_URI = "sqlite:///db.sqlite"
SQLALCHEMY_TRACK_MODIFICATIONS = False
CACHE_TYPE = "RedisCache"
WTF_CSRF_ENABLED = False
class ProdConfig(Config):
DEBUG = False
SECRET_KEY = os.environ.get("SECRET_KEY")
CACHE_REDIS_URL = "redis://redis:6379/0"
class DevConfig(Config):
DEBUG = True
SECRET_KEY = "secret key"
CACHE_REDIS_URL = "redis://localhost:6379/0"
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/your-space/app/__init__.py | ctfs/redpwn/2022/web/your-space/app/__init__.py | from pathlib import Path
from flask import Flask
from flask_caching import Cache
from flask_login import LoginManager
from flask_sqlalchemy import SQLAlchemy
from .notify import start_notifier
cache = Cache()
db = SQLAlchemy()
login = LoginManager()
login.login_view = "auth.login"
login.login_message = "not logged in"
flag_path = Path(__file__).parent / "flag.txt"
assert flag_path.is_file()
flag = flag_path.read_text().strip()
def create_app():
app = Flask(__name__)
if app.env == "production":
app.config.from_object("app.config.ProdConfig")
flag_path.unlink()
else:
app.config.from_object("app.config.DevConfig")
cache.init_app(app)
db.init_app(app)
login.init_app(app)
from .routes import auth, main, space
app.register_blueprint(auth)
app.register_blueprint(main)
app.register_blueprint(space)
with app.app_context():
db.create_all()
start_notifier()
return app
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/your-space/app/notify.py | ctfs/redpwn/2022/web/your-space/app/notify.py | import json
from io import StringIO
from multiprocessing import Process, Queue
import pycurl
queue = Queue()
def notify_single(url, body):
c = pycurl.Curl()
c.setopt(pycurl.URL, url)
c.setopt(
pycurl.HTTPHEADER,
[
"Accept: application/json",
"Content-Type: application/json",
],
)
c.setopt(pycurl.POST, 1)
c.setopt(pycurl.TIMEOUT_MS, 1000)
c.setopt(pycurl.READDATA, StringIO(body))
c.setopt(pycurl.WRITEFUNCTION, len)
c.setopt(pycurl.POSTFIELDSIZE, len(body))
c.perform()
def worker(queue):
while True:
url, body = queue.get()
try:
notify_single(url, body)
except:
pass
def notify(post):
for sub in post.space.subscriptions:
url = sub.user.webhook
body = {
"space": post.space.name,
"content": post.content,
"timestamp": post.timestamp.timestamp(),
}
body = json.dumps(body)
queue.put((url, body))
def start_notifier():
p = Process(target=worker, args=(queue,))
p.daemon = True
p.start()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/your-space/app/routes/main.py | ctfs/redpwn/2022/web/your-space/app/routes/main.py | from flask import Blueprint, flash, render_template
from flask_login import current_user, login_required
from .. import db
from ..form import WebhookForm
from ..model import Space
main = Blueprint("main", __name__)
@main.route("/")
def home():
spaces = Space.query.all()
return render_template("home.html", spaces=spaces)
@main.route("/profile", methods=["GET", "POST"])
@login_required
def profile():
form = WebhookForm()
if form.validate_on_submit():
current_user.webhook = form.webhook.data
db.session.add(current_user)
db.session.commit()
flash("webhook updated")
return render_template("profile.html", form=form)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/your-space/app/routes/__init__.py | ctfs/redpwn/2022/web/your-space/app/routes/__init__.py | from .auth import auth
from .main import main
from .space import space
__all__ = ["auth", "main", "space"]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/your-space/app/routes/auth.py | ctfs/redpwn/2022/web/your-space/app/routes/auth.py | from flask import Blueprint, flash, redirect, render_template, request, url_for
from flask_login import current_user, login_user, logout_user
from .. import db
from ..form import LoginForm, RegisterForm
from ..model import User
auth = Blueprint("auth", __name__)
@auth.route("/login", methods=["GET", "POST"])
def login():
if current_user.is_authenticated:
return redirect(url_for("main.home"))
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
if user:
if user.check_password(form.password.data):
login_user(user)
flash("logged in")
next_url = request.args.get("next")
if next_url is not None and next_url.startswith("/"):
return redirect(next_url)
return redirect(url_for("main.profile"))
else:
flash("invalid login")
return render_template("login.html", form=form)
@auth.route("/register", methods=["GET", "POST"])
def register():
if current_user.is_authenticated:
return redirect(url_for("main.home"))
form = RegisterForm()
if form.validate_on_submit():
user = User(username=form.username.data, password=form.password.data)
db.session.add(user)
db.session.commit()
login_user(user)
flash("logged in")
return redirect(url_for("main.profile"))
return render_template("register.html", form=form)
@auth.route("/logout")
def logout():
logout_user()
flash("logged out")
return redirect(url_for("main.home"))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2022/web/your-space/app/routes/space.py | ctfs/redpwn/2022/web/your-space/app/routes/space.py | from flask import Blueprint, abort, flash, redirect, render_template, url_for
from flask_login import current_user, login_required
from .. import cache, db
from ..form import PostForm, SpaceForm
from ..model import Post, Space, Subscription
from ..notify import notify
space = Blueprint("space", __name__)
def get_subscription(user, space):
query = Subscription.query.filter_by(user=user).filter_by(space=space)
return query.first()
@cache.memoize(timeout=60)
def num_subscriptions(space_id):
return len(Subscription.query.filter_by(space_id=space_id).all())
@space.route("/space/<space_id>")
def view(space_id):
space = Space.query.get(space_id)
if space is None:
return abort(404)
subscribed = None
if current_user.is_authenticated:
subscribed = get_subscription(current_user, space) is not None
subs = num_subscriptions(space.id)
return render_template("space.html", subscribed=subscribed, subs=subs, space=space)
@space.route("/create", methods=["GET", "POST"])
@login_required
def create():
form = SpaceForm()
if form.validate_on_submit():
space = Space(name=form.name.data, user=current_user)
db.session.add(space)
db.session.commit()
flash("space created")
return redirect(url_for("space.view", space_id=space.id))
return render_template("create.html", form=form)
@space.route("/space/<space_id>/post", methods=["GET", "POST"])
@login_required
def post(space_id):
space = Space.query.get(space_id)
if space is None:
return abort(404)
if space.user_id != current_user.id:
return abort(403)
form = PostForm()
if form.validate_on_submit():
post = Post(content=form.content.data, space=space)
db.session.add(post)
db.session.commit()
notify(post)
flash("post created")
return redirect(url_for("space.view", space_id=space.id))
return render_template("post.html", form=form, space=space)
@space.route("/space/<space_id>/sub")
@login_required
def sub(space_id):
space = Space.query.get(space_id)
if space is None:
return abort(404)
if get_subscription(current_user, space) is None:
subscription = Subscription(user=current_user, space=space)
db.session.add(subscription)
db.session.commit()
flash("subscribed")
return redirect(url_for("space.view", space_id=space.id))
@space.route("/space/<space_id>/unsub")
@login_required
def unsub(space_id):
space = Space.query.get(space_id)
if space is None:
return abort(404)
subscription = get_subscription(current_user, space)
if subscription is not None:
db.session.delete(subscription)
db.session.commit()
flash("unsubscribed")
return redirect(url_for("space.view", space_id=space.id))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/redpwn/2020/four-function-heap/starter.py | ctfs/redpwn/2020/four-function-heap/starter.py | from pwn import *
e = ELF("./four-function-heap")
libc = ELF("./libc.so.6")
p = process(e.path)
def alloc(idx, size, data="AAAA"):
p.sendline("1")
p.sendlineafter(":", str(idx))
p.sendlineafter(":", str(size))
p.sendlineafter(":", data)
p.recvuntil(":")
def free(idx):
p.sendline("2")
p.sendlineafter(":", str(idx))
p.recvuntil(":")
def show(idx):
p.sendline("3")
p.sendlineafter(": ", str(idx))
p.recvuntil(":")
# Your Code Here
p.interactive()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PBjar/2021/crypto/ReallynotSecureAlgorithm/script.py | ctfs/PBjar/2021/crypto/ReallynotSecureAlgorithm/script.py | from Crypto.Util.number import *
with open('flag.txt','rb') as f:
flag = f.read().strip()
e=65537
p=getPrime(128)
q=getPrime(128)
n=p*q
m=bytes_to_long(flag)
ct=pow(m,e,n)
print (p)
print (q)
print (e)
print (ct)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PBjar/2021/crypto/Not_Baby/script.py | ctfs/PBjar/2021/crypto/Not_Baby/script.py | from Crypto.Util.number import *
with open('flag.txt','rb') as g:
flag = g.read().strip()
with open('nums.txt','r') as f:
s=f.read().strip().split()
a=int(s[0])
b=int(s[1])
c=int(s[2])
e=65537
n=a**3+b**3-34*c**3
m=bytes_to_long(flag)
ct=pow(m,e,n)
print ("n: ",n)
print ("e: ",e)
print ("ct: ",ct)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PBjar/2021/crypto/Iloveyou3000/script.py | ctfs/PBjar/2021/crypto/Iloveyou3000/script.py | import random
from Crypto.Util.number import *
def newflag(oldflag):
s=list("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPWRSTUVWXYYZ")
for i in range(random.randint(1,10)):
oldflag=random.choice(s)+oldflag
for i in range(random.randint(1,10)):
oldflag=oldflag+random.choice(s)
return oldflag
with open('flag.txt','r') as f:
flag = f.read().strip()
flag=newflag(flag).encode()
m=bytes_to_long(flag)
def cooooolerRandom(x,y):
base=random.randint(2,5)
e=base
operation=random.choice([-1,1]) #subtraction or addition
_range=random.randint(1,6) #rolling some dice
change=sum([random.randint(-_range,_range) for i in range(random.randint(1,100))]) #chillllly am I right?
e*=(x+operation*change)
operation2=random.choice([-1,1]) #subtraction or addition
_range=random.randint(1,6) #rolling some more dice
change2=sum([random.randint(-_range,_range) for i in range(random.randint(1,100))]) #someone get me a blanket pleasee
e*=(y+operation2*change2)
return e+base,base
print("Weclome to...urr...cool crypto problem thing")
print("We wanted to find out why picking e is sooooo important")
print("Like smh, who needs a good e value???")
print("You know what...I'll show them...I'll give you 3000 different examples on why any e is a good e value!")
example_count=int(input("How many examples do you want?: "))
if (example_count<1 or example_count>3000):
print("Come on man ;(")
exit(1)
for i in range(example_count):
p=getPrime(256)
q=getPrime(256)
n=p*q
assert(m<n)
e,b=cooooolerRandom(p,q)
ct=pow(m,e,n)
print("Ciphertext: "+str(ct))
print("Modulus: "+str(n))
print("Base: "+str(b))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PBjar/2021/crypto/not_baby_fixed/script.py | ctfs/PBjar/2021/crypto/not_baby_fixed/script.py | from Crypto.Util.number import *
with open('flag.txt','rb') as g:
flag = g.read().strip()
with open('nums.txt','r') as f:
s=f.read().strip().split()
a=int(s[0])
b=int(s[1])
c=int(s[2])
e=65537
n=a**3+b**3-34*c**3
m=bytes_to_long(flag)
ct=pow(m,e,n)
print ('n:',n)
print ('e:',e)
print ('ct:',ct)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PBjar/2021/crypto/leftovers/script.py | ctfs/PBjar/2021/crypto/leftovers/script.py | from random import *
def gen():
mod=randint(10**9,10**10)
while (mod%2==0):
mod=randint(10**9,10**10)
return mod
mod=gen()
small=mod
while True:
for i in range(2,int((mod+5)**(1/2))):
if mod%i==0:
small=i
break
if small!=mod:
mod*=small
break
mod=gen()
lst=[]
for i in range(small-1):
lst.append(1)
r=randint(min(10,small-1),small*3)
for i in range(r):
lst.append(0)
shuffle(lst)
print ("Alright, I will send you a string, where each char contains either 0 or 1.")
print ("Then you will send me a list of integers back with the same size, separated by spaces.")
print ("Now for each number in your list, a, if it satisfies a to the power of "+str(small)+" is congruent to 1 mod "+str(mod)+" it will encode to 1.")
print ("Otherwise, your number will encode to 0. Now I will concattenate all of your encoded numbers into a string.")
print ("If this string equals the original string I sent you, then you will get the flag :yayy:.")
print ("One final caveat: all your numbers must be unique and positive integers greater than 1 and less than "+str(mod)+".")
string=""
for i in lst:
string+=str(i)
print (string)
s=input("Enter: ").strip().split()
s=[int(i) for i in s]
check=True
for i in s:
if i>=mod or i<=1:
check=False
break
check=check & (len(s)==len(lst))
check=check & (len(s)==len(set(s)))
cs=""
for i in s:
if pow(i,small,mod)==1:
cs+="1"
else:
cs+="0"
check=check & (cs==string)
if check:
with open('flag.txt','rb') as f:
flag = f.read().strip()
print (flag)
else:
print ("Better luck next time!")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PBjar/2021/crypto/knapsack/knapsack.py | ctfs/PBjar/2021/crypto/knapsack/knapsack.py | from Crypto.Util.number import getPrime
from sympy import nextprime
from random import randint
flag = open('./flag.txt', 'rb').read().strip()
flagbits = bin(int.from_bytes(flag, 'big'))[2:]
n, r = len(flagbits), getPrime(8)
w = [randint(1, 69)]
for i in range(1, n):
w.append(randint(sum(w[:i]) + 1, w[-1] * r))
q = nextprime(r * w[-21])
b = [r * i % q for i in w]
c = sum((0 if i == '0' else 1) * j for i, j in zip(flagbits, b))
f = open('./output.txt', 'w')
print('b: ' + str(b), file = f)
print('c: ' + str(c), file = f)
f.close()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PBjar/2021/crypto/MRSA/script.py | ctfs/PBjar/2021/crypto/MRSA/script.py | from Crypto.Util.number import *
with open('flag.txt','rb') as f:
flag = f.read().strip()
e=65537
p=getPrime(256)
q=getPrime(128)
n=p*q
m=bytes_to_long(flag)
ct=pow(m,e,n)
print ('n:',n)
print ('e:',e)
print ('ct:',ct)
def enc(msg):
print (p%msg)
try:
br="#"
print (br*70)
print ("Now here's the More part!!!")
print ("Enter some number, and I will encrypt it for you")
print ("But you gotta follow the condition that your number gotta be less than q (and like legitamite)")
print (br*70)
s=int(input("Enter: ").strip())
assert(s>0 and s<q)
enc(s)
except:
print ("Bruh why you be like this")
exit()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PBjar/2021/crypto/MRSA2/script.py | ctfs/PBjar/2021/crypto/MRSA2/script.py | from Crypto.Util.number import *
with open('flag.txt','rb') as f:
flag = f.read().strip()
e=65537
p=getPrime(256)
q=getPrime(256)
n=p*q
phi=(p-1)*(q-1)
m=bytes_to_long(flag)
d=pow(e,-1,phi)
ct=pow(m,e,n)
print ('n:',n)
print ('e:',e)
print ('ct:',ct)
def enc(msg):
print (d%msg)
try:
br="#"
print (br*70)
print ("Now here's the More part!!!")
print ("Enter some number, and I will encrypt it for you")
print ("But you gotta follow the condition that your number gotta be less than 2^140 (and like legitamite)")
print (br*70)
s=int(input("Enter: ").strip())
assert(s>0 and s<2**140)
enc(s)
except:
print ("Bruh why you be like this")
exit()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/AirOverflow/2024/misc/Ba_Sing_Se/ba-sing-se.py | ctfs/AirOverflow/2024/misc/Ba_Sing_Se/ba-sing-se.py | #!/usr/local/bin/python
""" Purely aesthetics. """
colors = {
"[BLACK]" : "\033[0;30m",
"[RED]" : "\033[0;31m",
"[GREEN]" : "\033[0;32m",
"[BROWN]" : "\033[0;33m",
"[BLUE]" : "\033[0;34m",
"[PURPLE]" : "\033[0;35m",
"[CYAN]" : "\033[0;36m",
"[LIGHT_GRAY]" : "\033[0;37m",
"[DARK_GRAY]" : "\033[1;30m",
"[LIGHT_RED]" : "\033[1;31m",
"[LIGHT_GREEN]" : "\033[1;32m",
"[YELLOW]" : "\033[1;33m",
"[LIGHT_BLUE]" : "\033[1;34m",
"[LIGHT_PURPLE]" : "\033[1;35m",
"[LIGHT_CYAN]" : "\033[1;36m",
"[WHITE]" : "\033[1;37m",
"[BOLD]" : "\033[1m",
"[FAINT]" : "\033[2m",
"[ITALIC]" : "\033[3m",
"[UNDERLINE]" : "\033[4m",
"[BLINK]" : "\033[5m",
"[NEGATIVE]" : "\033[7m",
"[CROSSED]" : "\033[9m",
"[END]" : "\033[0m" }
def colorize(msg : str, override_color: str = "") -> str:
if override_color: msg = f"[{override_color.upper()}]" + msg
for color in colors.items():
msg = msg.replace(color[0].upper(), color[1])
msg += colors["[END]"]
return msg
def log(msg, level="", show_level=True, *args, **kwargs):
LEVELS = { "error": "[RED]ERROR", "info": "[BLUE]INFO", "log": "[GREEN]LOG"}
level = LEVELS[level.lower()] if level in LEVELS.keys() else ""
if show_level and level: print(f"[{colorize(level)}] - ", end="")
print(f"{colorize(msg)}", *args, **kwargs)
def __read__(filename: str, __default: str = "DEFAULT", __raise : bool = False, __show : bool = False) -> str:
try:
with open(filename, "r") as f:
return f.read()
except FileNotFoundError:
if __raise:
log(f"File [RED]{filename}[END] not found. Please contact an administrator.", level="error")
exit(1)
return __default
except Exception as E:
log(f"An error occurred! ", level="error", end="")
if __show: log(f"Details: [YELLOW]{E}[END]", show_level=False, end="")
log("Exiting...", level="error")
exit(1)
def __err(msg):
log("[[RED]ANGRY Aang[END]] - Did you really think the walls would be this easy to penetrate??\n")
log(colorize(msg, override_color="red"))
log("The avatar got pretty angry and threw you out!", level="error")
exit(1)
def __check__(__str: str, ifexist: str):
for bk in BLACKLIST_KEYWORDS:
if bk in __str:
__err(ifexist)
for bo in BLACKLIST_OPERATORS:
if bo in __str:
__err(ifexist)
BLACKLIST_KEYWORDS = [
"import", "from", "for", "eval", "exec", "with", "global", "local",
"flag", "open", "dict", "ord", "sys", "os", "builtins", "momos_secret",
"print", "subprocess", "system", "popen", "read", "write", "readline",
"write", "list", "tuple", "str", "int", "float", "bool", "bytes", "bytearray",
"memoryview", "set", "frozenset", "range", "complex", "type", "dir", "help",
"vars", "locals", "globals", "hasattr", "getattr", "setattr", "delattr",
"issubclass", "isinstance", "callable", "compile", "iter", "ast", 'f"',
"AOF", "CTF", "base64", "binascii", "is", "not", "and", "or",
"if", "while", "else", "elif"
]
BLACKLIST_OPERATORS = [
">", "|", "=", "<", "()", "{", "}", "[", "]", "_", "-", "/", "\\",
"*", ",", ".", "&", "%", "!", "@", "#", "$", "^", "?", " ", ":", ";",
"\"", "'", "~"
]
if __name__ == "__main__":
avatar_prompt = colorize("[[YELLOW]Avatar Aang[END]]")
your_prompt = colorize("[[GREEN]You[END]] ")
avatar = __read__("arts/avatar.art", __default="<Good Avatar Art>")
desc = __read__("arts/description.txt", __default="<Some descriptive message>")
angry_avatar = __read__("arts/angry.art", __default="😠")
confused_avatar = __read__("arts/confused.art", __default="😕")
momos_secret = __read__("flag.txt", __default="You got the flag.")
log(colorize(avatar, override_color="yellow"))
log(colorize(desc))
log(f"{avatar_prompt} I need your help. Can you help me?")
try:
stance = input(your_prompt)
except KeyboardInterrupt:
log("You left the avatar hanging [GREEN]:(", level="error")
exit(1)
__check__(__str=stance, ifexist=angry_avatar)
log(colorize(confused_avatar, override_color="green"))
log(f"{avatar_prompt} Wait, [BLUE]whaaaaaaaaaaaaaaaaaaaaaaaat??")
log(f"{avatar_prompt} Let me try this as well: [CYAN]{stance}")
try:
eval(eval(stance))
log(f"{avatar_prompt} It, worked??")
except:
log(f"{avatar_prompt} This did not work. You made me look like a fool!")
__err(angry_avatar) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/AirOverflow/2024/crypto/Impurity/impurity.py | ctfs/AirOverflow/2024/crypto/Impurity/impurity.py | #!/usr/local/bin python3
from Crypto.Util.number import bytes_to_long, getPrime, long_to_bytes
def get_key():
p = getPrime(512)
q = getPrime(512)
n = p * q
e = 0x10001
phi = (p - 1) * (q - 1)
return (e, n, phi)
def encrypt(m, e, n):
return pow(m, e, n)
def encrypt_flag(flag, e, n):
return encrypt(flag, e, n)
def get_flag():
try:
with open("/flag") as f:
FLAG = f.read().strip()
return FLAG
except:
print("[ERROR] - Please contact an Administrator.")
def decrypt_flag(n, e,phi,flag):
d = pow(e, -1, phi)
print("hehe adding some impurity so it makes it strong, oh wait this is rsa not steel")
impurity = encrypt(2, e, n)
new_flag = impurity * flag
print(f"Here is the decrypted flag: {pow(new_flag, d, n)}")
def main():
print("Welcome to the RSA encryption service!")
e, n , phi = get_key()
print(f"Here is the public key: (e={e}, n={n})")
while True:
print("1. Encrypt a message")
print("2. Get flag")
print("3. Decrypt the flag")
print("4. Exit")
choice = int(input("Enter your choice: "))
if choice == 1:
message = int(input("Enter the message you want to encrypt: "))
print(f"Here is the encrypted message: {encrypt(message, e, n)}")
elif choice == 2:
flag = get_flag().encode()
print(f"Here is the encrypted flag: {encrypt_flag(bytes_to_long(flag), e, n)}")
elif choice == 3:
flag = encrypt_flag(bytes_to_long(get_flag().encode()), e, n)
decrypt_flag(n,e,phi,flag)
break
elif choice == 4:
print("Goodbye!")
break
else:
print("Invalid choice")
if __name__ == "__main__":
main() | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/misc/wow/src/main.py | ctfs/pingCTF/2023/misc/wow/src/main.py | import random
import os
FLAG = os.getenv("FLAG", "ping{FAKE}")
random.seed(random.randint(0, 10_000_000))
opponent_balance = 10_000_000
user_balance = 50
round_num = 1
def print_balance():
print(f"{user_balance=}")
print(f"{opponent_balance=}")
def spacer():
print("-" * 64)
def roll(n: int):
return random.randint(1, n)
def roll_number(n: int, user: str = "user"):
if user == "user":
user = "opponent"
else:
user = "user"
if n == 1:
return user
else:
number = roll(n)
print(f"{user} rolls {number}")
return roll_number(number, user)
def round():
global user_balance, opponent_balance
if user_balance > 10_000_000:
print(f"{FLAG=}")
exit(0)
print_balance()
spacer()
bet = int(input("How much do you want to bet? "))
if bet > user_balance:
print("You don't have enough money!")
return
if bet <= 0 or bet > opponent_balance:
print("Invalid amound of money")
return
user_balance -= bet
opponent_balance -= bet
winnings = bet + bet
winner = roll_number(100)
if winner == "user":
print("You won!")
user_balance += winnings
else:
print("You lost!")
opponent_balance += winnings
def main():
print("welcome to the death roll!")
print(
"it is a game that is common in WoW game on chat to risk or double your gold!"
)
print("short example on how it works:")
spacer()
print("you have 50 gold")
print("you can bet 1-50 gold")
print("First roll is random number from 1 to 100")
print("when you roll 47 then the opponent rolls from 1 to 47")
print("when opponent roll 20 then you roll from 1 to 20")
print("the person who gets to roll 1 loses the money")
start = input("Do you want to start? (y/n): ")
while start != "n" and start != "y":
start = input("Do you want to start? (y/n): ")
if start == "n":
exit(0)
while True:
round()
if __name__ == "__main__":
main()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/misc/you_spin_me_round/src/main.py | ctfs/pingCTF/2023/misc/you_spin_me_round/src/main.py | import random
import time
from flag import FLAG
from messages import hello, m_task1, m_task2, m_task3, m_correct, m_incorrect
TIME_LIMIT_SEC = 10
def task1(n):
x = random.randint(100, 10000)
y = random.randint(1, 100)
solution = x // y
m_task1(x, solution, n)
answer = int(input('Enter what should be under "?" in the task above: '))
user_solution = x // answer
if user_solution == solution:
m_correct()
else:
user_solution = f"{x} // {answer} = {user_solution}"
correct_solution = f"{x} // {y} = {solution}"
m_incorrect(user_solution, correct_solution)
exit(1)
def task2(n):
x = random.randint(100000, 1000000000) / 100
y = random.randint(1, 100000) / 100
solution = x % y
m_task2(x, solution, n)
answer = float(input('Enter what should be under "?" in the task above: '))
user_solution = x % answer
if user_solution == solution:
m_correct()
else:
user_solution = f"{x} % {answer} = {user_solution}"
correct_solution = f"{x} % {y} = {solution}"
m_incorrect(user_solution, correct_solution)
exit(1)
def task3(n):
x = random.randint(100000, 1000000000) / 100
y = random.randint(1, 100000) / 100
solution = x % y
m_task3(x, y, n)
user_solution = input('Enter what should be under "?" in the task above: ')
if user_solution != str(solution) and float(user_solution) == solution and not user_solution.endswith('0'):
m_correct()
else:
opt_text = f'This is a special case! You need to satisfy the following condition to pass it.'
opt_text += f'\n"{user_solution}" != str({solution}) and float("{user_solution}") == {solution} and not "{user_solution}".endswith("0")'
m_incorrect(user_solution, solution, opt_text)
exit(1)
def task4():
print('START')
time_start = time.time()
for i in range(4, 1_000):
task = random.randint(1, 3)
eval(f'task{task}({i})')
time_end = time.time()
if time_end - time_start > TIME_LIMIT_SEC:
print('You are too slow!')
exit(1)
def main():
# quantum security random seed security layer - impossible to crack on a classical calculators
seed = random.randint(0, 1_000_000)
random.seed(seed)
hello(random.randint(1, 100), random.randint(1, 100))
task1(1)
task2(2)
task3(3)
print('Good job! :) You proved you are a human!!!\n\n')
print('However unfortunately this is not enough to get the flag. As friendly as I am, I can only provide the flag to the fellow bots.\n\n')
print('To prove it you need to solve task 4 in a limited time.\n\n')
task4()
print(f'{FLAG=}')
if __name__ == '__main__':
main()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/misc/you_spin_me_round/src/messages.py | ctfs/pingCTF/2023/misc/you_spin_me_round/src/messages.py | def beep(n: int):
return (('BEEP ' * n).strip())
def boop(n: int):
return (('BOOP ' * n).strip())
def m_correct():
print('''
CORRECT
''')
def m_incorrect(wrong_solution, correct_solution, opt=None):
print(f'''
INCORRECT
YOUR SOLUTION:\t{wrong_solution}
CORRECT:\t\t{correct_solution}
OPTIONAL:\t\t{opt}
''')
def hello(beeps, boops):
print(f'''
Hello, I am a bot that can spin you round, baby, right round, like a record, baby, right round, round, round.
{beep(beeps)} {boop(boops)}
PLEASE ENTER CORRECT SOLUTIONS TO AUTHORIZE:
''')
def m_task1(x, solution, n):
print(f'''
Task {n}: {x} // ? = {solution}
''')
def m_task2(x, solution, n):
print(f'''
Task {n}: {x} % ? = {solution}
''')
def m_task3(x, y, n):
print(f'''
Task {n}: {x} % {y} = ?
''')
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/misc/you_spin_me_round/src/flag.py | ctfs/pingCTF/2023/misc/you_spin_me_round/src/flag.py | import os
FLAG = os.environ.get("FLAG", "flag{FAKE}")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/rev/python_rev_for_freaks/python_freak.py | ctfs/pingCTF/2023/rev/python_rev_for_freaks/python_freak.py | from base64 import b64decode
exec(b64decode('exec(b64decode('import sys
exec(b64decode('exec(b64decode('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'))'))'))'))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/crypto/easy_rsa/main.py | ctfs/pingCTF/2023/crypto/easy_rsa/main.py | from Crypto.Util.number import getPrime
from Crypto.Util.number import bytes_to_long
p = getPrime(2048)
q = getPrime(2048)
n = p * q
e = 65537
d = pow(e, -1, (p-1)*(q-1))
flag = open("flag.txt","rb").read()
print(f"q & p = {q & p}")
print(f"q & (p << 1) = {q & (p << 1)}")
print(f"n = {n}")
print(f"ct = {pow(bytes_to_long(flag), e, n)}")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/crypto/shrek/src/shrek.py | ctfs/pingCTF/2023/crypto/shrek/src/shrek.py | import random
class Shrek:
def __init__(self):
file = open("shrek.txt")
self.parts = list(file.read().split())
alphabet = ""
for part in self.parts:
for letter in part:
if not letter in alphabet:
alphabet += letter
self.alphabet = alphabet + " "
self.generateKeys()
def generateKeys(self):
keys = []
for _ in range(20):
key = []
for _ in range(random.randint(10, 30)):
key.append(random.randrange(len(self.alphabet)))
keys.append(key)
self.keys = keys
def generatePlainText(self):
plainText = ""
for _ in range(100):
plainText += random.choice(self.parts)
plainText += " "
return plainText.strip()
def encrypt(self, plainText):
cipherText = [*plainText]
for i,j in enumerate(cipherText):
for key in self.keys:
cipherText[i] = self.alphabet[(self.alphabet.index(j) + key[i % len(key)]) % len(self.alphabet)]
return ''.join(cipherText)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/crypto/shrek/src/main.py | ctfs/pingCTF/2023/crypto/shrek/src/main.py | import os
from shrek import Shrek
shrek = Shrek()
FLAG = os.environ.get("FLAG", "ping{FAKE}")
for i in range(10):
plainText = shrek.generatePlainText()
print(f'Ciphertext: {shrek.encrypt(plainText)}')
guess = input('Can you guess plaintext?: ')
if guess == plainText:
print(f'Congratulations, your reward: {FLAG}')
else:
print('Try harder!')
print('noob')
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/crypto/lame_lame_loser/main.py | ctfs/pingCTF/2023/crypto/lame_lame_loser/main.py | from hashlib import sha256
from math import gcd
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from secret import FLAG, x, y, a, b
out = open('out.txt', 'w')
assert FLAG.startswith('ping{')
assert FLAG.endswith('}')
assert x*a + y*b == 0
assert a > 0
assert b > 0
assert x.bit_length() >= 1023
assert y.bit_length() >= 1023
assert a.bit_length() == 512
assert b.bit_length() == 512
assert gcd(a, b) == 1
aes = AES.new(sha256(f'{a}||{b}'.encode()).digest(), AES.MODE_CBC, iv=bytes(16))
pt = pad(FLAG.encode(), 16)
ct = aes.encrypt(pt)
print(f'{x = }', file=out)
print(f'{y = }', file=out)
print(f'{ct = }', file=out)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/web/double_secret/src/db.py | ctfs/pingCTF/2023/web/double_secret/src/db.py | import mysql.connector
db = mysql.connector.connect(
host="db",
user="root",
password="password",
db="chall"
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/web/double_secret/src/setup_db.py | ctfs/pingCTF/2023/web/double_secret/src/setup_db.py |
import mysql.connector
from secrets import token_hex
import os
secret = token_hex(12)
mydb = mysql.connector.connect(
host="db",
user="root",
password="password",
)
mycursor = mydb.cursor()
mycursor.execute("CREATE DATABASE chall")
mycursor.execute("USE chall")
mycursor.execute("CREATE TABLE secret (secret TEXT)")
mycursor.execute("INSERT INTO secret (secret) VALUES ( %s )", [secret])
mycursor.execute("CREATE TABLE users (id INT NOT NULL AUTO_INCREMENT, name TEXT, password TEXT, isAdmin BIT, PRIMARY KEY (id), UNIQUE (name(32)))")
mycursor.execute("INSERT INTO users (name, password, isAdmin) VALUES (%s, %s, %s)", ['admin', token_hex(8), True])
mydb.commit()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/web/double_secret/src/secret.py | ctfs/pingCTF/2023/web/double_secret/src/secret.py | import os
from db import db
cursor = db.cursor()
cursor.execute("SELECT secret from secret")
firstSecret = cursor.fetchone()[0]
secondSecret = os.getenv('SECRET', 'TEST_SECRET')
secret = secondSecret + firstSecret
flag = os.getenv('FLAG', 'ping{FAKE}')
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2023/web/double_secret/src/app.py | ctfs/pingCTF/2023/web/double_secret/src/app.py | from flask import Flask, session, render_template, request, redirect, make_response
from secret import secret, flag, firstSecret, secondSecret
from db import db
import os
from hashlib import sha1
from flask_httpauth import HTTPBasicAuth
app = Flask(__name__)
## INSTANCER CODE
auth = HTTPBasicAuth()
@auth.get_password
def get_password(username):
if username == os.getenv('INSTANCER_USERNAME'):
return os.getenv('INSTANCER_PASSWORD')
return None
## END OF INSTANCER CODE
app.secret_key = secret
def createSession(user):
session["loggedIn"] = True
session["user"] = {}
session["user"]["id"] = user[0]
session["user"]["name"] = user[1]
session["user"]["isAdmin"] = user[2] is True
def signFile(data):
data = data + bytes([session["user"]["id"]])
signature = sha1(bytes(str(firstSecret), "utf-8") + data).digest()
signature = sha1(bytes(str(secondSecret), "utf-8") + signature).digest()
return data + signature
def verifySignature(data):
signedData = data[:-20]
fileSignature = data[-20:]
userId = signedData[-1]
calculatedSignature = sha1(bytes(str(firstSecret), "utf-8") + signedData).digest()
calculatedSignature = sha1(bytes(str(secondSecret), "utf-8") + calculatedSignature).digest()
if fileSignature == calculatedSignature:
return userId
else:
raise "Invalid Signature"
@app.route("/flag")
@auth.login_required # < INSTANCER CODE
def flagEndpoint():
if "loggedIn" in session and session["user"]["isAdmin"]:
return flag
else:
return "Only admin has access to flag !"
@app.route("/")
@auth.login_required # < INSTANCER CODE
def index():
if "loggedIn" in session:
return redirect("home")
return render_template("index.html")
@app.route("/home")
@auth.login_required # < INSTANCER CODE
def home():
return render_template("home.html", user=session["user"])
@app.route("/register", methods=['GET', 'POST'])
@auth.login_required # < INSTANCER CODE
def register():
if request.method == "POST":
if type(request.form["username"]) != str or type(request.form["password"]) != str:
return render_template("register.html")
try:
cursor = db.cursor()
results = cursor.execute(f'''
INSERT INTO users (name, password, isAdmin) VALUES ( '{request.form["username"]}', '{request.form["password"]}', 0);
SELECT id, name, isAdmin FROM users ORDER BY id DESC LIMIT 1;
''',
multi=True)
user = ()
for cur in results:
user = cur.fetchone()
db.commit()
createSession(user)
except Exception as a:
return render_template("register.html", message="User already registered")
return redirect("/home")
return render_template("register.html")
@app.route("/login", methods=['GET', 'POST'])
@auth.login_required # < INSTANCER CODE
def login():
if request.method == "POST":
if type(request.form["username"]) != str or type(request.form["password"]) != str:
return render_template("login.html")
cursor = db.cursor()
cursor.execute('SELECT id, name, isAdmin FROM users WHERE name = %(username)s AND password = %(password)s',
{
"username": request.form["username"],
"password": request.form["password"]
}
)
users = cursor.fetchall()
if len(users) > 0:
createSession(users[0])
return redirect("/home")
else:
return render_template("login.html", message="Wrong username or password")
return render_template("login.html")
@app.route("/sign", methods=['GET', 'POST'])
@auth.login_required # < INSTANCER CODE
def sign():
if not "loggedIn" in session:
return redirect("/")
if request.method == 'POST':
if 'file' not in request.files:
return render_template("sign.html", message="No file")
file = request.files['file']
data = file.read()
response = make_response(signFile(data))
response.headers.set('Content-Type', 'application/octet-stream')
response.headers.set('Content-Disposition', 'attachment', filename=request.files['file'].name)
return response
return render_template("sign.html", user=session["user"])
@app.route("/verify", methods=['GET', 'POST'])
@auth.login_required # < INSTANCER CODE
def verify():
if request.method == 'POST':
if 'file' not in request.files:
return render_template("verify.html", message="No file")
try:
file = request.files['file']
data = file.read()
userId = verifySignature(data)
cursor = db.cursor()
cursor.execute(f"SELECT name from users where id = {userId}")
username = cursor.fetchone()[0]
return render_template("verify.html", message="Valid signature, file signed by: %s" % username)
except:
return render_template("verify.html", message="Invalid signature!")
return render_template("verify.html")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2025/pwn/tick_tock/secure_server.py | ctfs/pingCTF/2025/pwn/tick_tock/secure_server.py | from flask import Flask, request
import subprocess as sp
app = Flask(__name__)
@app.route('/check', methods=['get'])
def check():
flag = request.args.get('flag')
if not flag:
return "No flag given"
# if not flag.isalnum() or "{" in flag or "}" in flag:
for c in flag:
if not c.isalnum() and c not in "{}_":
return "Flag should be alphanumeric except for {}_"
if len(flag) > 60:
return "Flag too long"
r = sp.run(f'valgrind --tool=callgrind --callgrind-out-file=/dev/null ./main {flag}', shell=True, stderr=sp.PIPE, stdout=sp.PIPE)
stderr = r.stderr.decode()
stdout = r.stdout.decode()
ins_num = -1
for line in stderr.split("\n"):
if "Collected" in line:
ins_num = int(line.split(" ")[3])
break
ret = ""
if "Incorrect" in stdout:
ret += "Incorrect flag\n"
elif "Correct" in stdout:
ret += "Correct flag!!!\n"
else:
ret += "Something went wrong\n"
print(f"Flag: {flag} Instructions: {ins_num}")
ret = f"{stdout} <br> Time taken: {ins_num}ms"
if ins_num == -1:
return "Something went wrong"
return ret
if __name__ == '__main__':
app.run(port=5000) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2025/pwn/tick_tock/gunicorn_config.py | ctfs/pingCTF/2025/pwn/tick_tock/gunicorn_config.py | import os
workers = 8
threads = 4
bind ="0.0.0.0:8080"
forwarded_allow_ips = "*"
secure_scheme_headers = {
"X-Forwarded-Proto": "https"
} | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2022/pwn/storage_room/storage_room/_import.py | ctfs/pingCTF/2022/pwn/storage_room/storage_room/_import.py | from flask import Flask, request, redirect, session, render_template, g
import re
import secrets
import sqlite3
import pickle
import pickletools
from db import db, append_buffer, get_buffer, is_printable, clear_buffer, register, login, set_buffer, is_using_special_buffer
from messages import *
from base64 import b64encode
from PrivateBufferClass import PrivateBufferClass
MAX_NEW_BUFFER_SIZE = 0XDD
DEFAULT_BUFFER_SIZE = 0o24
def is_safe(unsafe):
return re.match(r"^[a-z0-9]+$", unsafe, re.I)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2022/pwn/storage_room/storage_room/db.py | ctfs/pingCTF/2022/pwn/storage_room/storage_room/db.py | import string
from _import import g, sqlite3, pickle, pickletools
import messages
from app import app
MAX_BUFFER_SIZE = 0xffff
def db():
db = getattr(g, '_database', None)
if db is None:
db = g._database = sqlite3.connect('/tmp/db2.sqlite3')
db.row_factory = sqlite3.Row
return db
def process_buffer(current_buffer, buffer, isSpecialBuffer):
if not isSpecialBuffer:
new_buffer = current_buffer + buffer
if len(new_buffer) > MAX_BUFFER_SIZE:
return new_buffer[MAX_BUFFER_SIZE:]
else:
return new_buffer
else:
specialBuffer = pickle.loads(current_buffer)
specialBuffer.add(buffer)
return pickle.dumps(specialBuffer, protocol=5)
@app.teardown_appcontext
def close_connection(exception):
db = getattr(g, '_database', None)
if db is not None:
db.close()
def append_buffer(username, buffer, isSpecialBuffer):
try:
cursor = db().cursor()
query = f"SELECT buffer FROM users WHERE username = '{username}'"
res = cursor.execute(query).fetchone()
if res:
current_buffer = res['buffer']
try:
# Ensure bytes
current_buffer = current_buffer.encode()
buffer = buffer.encode()
except:
pass
buffer = process_buffer(current_buffer, buffer, isSpecialBuffer)
set_buffer(username, buffer)
return True
else:
return False
except Exception as e:
print(e)
return False
def set_buffer(username, buffer):
cursor = db().cursor()
query = f"UPDATE users SET buffer = ? WHERE username = '{username}'"
cursor.execute(query, (buffer,))
db().commit()
def get_buffer(username):
try:
cursor = db().cursor()
query = f"SELECT buffer FROM users WHERE username = '{username}'"
res = cursor.execute(query).fetchone()
if res:
buffer = res['buffer']
try:
buffer = buffer.encode()
except:
pass
return (buffer, is_safe_buffer(buffer))
else:
return (messages.are_you_logged, False)
except:
return messages.invalid_buffer
def is_using_special_buffer(username):
buffer = get_buffer(username)
return buffer[1]
def is_safe_buffer(buffer):
return buffer[:2] == b'\x80\x05' and not pickle.REDUCE in get_buffer_opcodes(buffer)
def clear_buffer(username):
buffer = get_buffer(username)
if buffer[1]:
userBuffer = pickle.loads(buffer[0])
userBuffer.clear()
buffer = pickle.dumps(userBuffer, protocol=5)
set_buffer(username, buffer)
else:
set_buffer(username, b'Welcome to your buffer! (Again...)')
def is_printable(s):
try:
return all(chr(c) in string.printable for c in s)
except:
return False
def get_buffer_opcodes(buffer):
try:
opcodes = []
for _opcode_information, _value, opcode in pickletools.genops(buffer):
opcodes.append(opcode)
return opcodes
except:
return []
def register(username, password):
cursor = db().cursor()
query = f"INSERT INTO users (username, password) VALUES ('{username}', '{password}')"
cursor.execute(query)
db().commit()
def login(username):
cursor = db().cursor()
query = f"SELECT password FROM users WHERE username = '{username}'"
return cursor.execute(query).fetchone()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2022/pwn/storage_room/storage_room/messages.py | ctfs/pingCTF/2022/pwn/storage_room/storage_room/messages.py | class messages:
bad_charactes = "Please respect the regex ^[a-z0-9]+$ case insensitive in any fields, as we don't trust noone here."
bad_password = "Bad password"
registered = "You have been registered as :u"
logged = "You were logged in as :u"
not_logged = "You are not logged in!"
logged_out = "You are logged out"
buffer_to_big = "Your file is too big!"
buffer_appended = "Your file has been appended to the buffer"
buffer_cleared = "Your buffer has been cleared"
buffer_append_error = "An error occured while appending your file to the buffer"
buffer_clear_error = "An error occured while clearing your buffer"
invalid_buffer = "Invalid buffer! Hacker detected!"
are_you_logged = "Are you sure you are logged in?"
special_buffer_already_used = "You are already using special buffer."
using_special_buffer = "You are using now special buffer."
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2022/pwn/storage_room/storage_room/PrivateBufferClass.py | ctfs/pingCTF/2022/pwn/storage_room/storage_room/PrivateBufferClass.py | class PrivateBufferClass:
def __init__(self, size):
self.__buffer = [None] * size
self.__bufferSize = size
self.__bufferIndex = 0
def add(self, data):
if type(data) == str or type(data) == bytes:
for i in range(len(data)):
self.__buffer[self.__bufferIndex] = data[i]
self.__bufferIndex += 1
if self.__bufferIndex >= self.__bufferSize:
self.__bufferIndex = 0
if self.__bufferIndex >= self.__bufferSize:
self.__bufferIndex = 0
def get(self):
return self.__buffer
def clear(self):
self.__buffer = [None] * self.__bufferSize
self.__bufferIndex = 0
def __len__(self):
return self.__bufferSize
def position(self):
return self.__bufferIndex
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2022/pwn/storage_room/storage_room/app.py | ctfs/pingCTF/2022/pwn/storage_room/storage_room/app.py | from _import import *
app = Flask(__name__)
app.secret_key = secrets.token_hex(0o77)
# Chain and buffer
@app.get('/files')
def files():
if 'username' in session:
return render_template('files.html', logged_in=True)
else:
return render_template('index.html', message=messages.not_logged, logged_in=False)
@app.post("/files")
def do_files():
if not 'username' in session:
return render_template('index.html', message=messages.not_logged, logged_in=False)
file = request.files.get('file')
contents = file.read()
if len(contents) > MAX_NEW_BUFFER_SIZE:
return render_template('files.html', message=messages.buffer_to_big, logged_in=True)
else:
isSuccess = append_buffer(session['username'], contents, 'using_special_buffer' in session and session['using_special_buffer'] == True)
if isSuccess:
return render_template('files.html', message=messages.buffer_appended, logged_in=True)
else:
return render_template('files.html', message=messages.buffer_append_error, logged_in=True)
@app.get('/chain')
def chain():
if not 'username' in session:
return render_template('index.html', message=messages.not_logged, logged_in=False)
buffer = get_buffer(session['username'])
if buffer[1]:
privateUserBuffer = pickle.loads(buffer[0])
buffer_content = str(privateUserBuffer.get())
return render_template('chain.html', logged_in=True, buffer=f"{buffer_content}, Length: {len(privateUserBuffer)}, Index: {privateUserBuffer.position()}")
else:
buffer_content = ""
if is_printable(buffer[0]):
buffer_content = buffer[0].decode()
else:
buffer_content = b64encode(buffer[0]).decode()
return render_template('chain.html', logged_in=True, buffer=buffer_content)
@app.post("/clear")
def do_clear():
if 'username' in session:
try:
clear_buffer(session['username'])
return messages.buffer_cleared
except:
return messages.buffer_clear_error
else:
return messages.not_logged
@app.post("/special-buffer")
def do_special_buffer():
if not 'username' in session:
return messages.not_logged
if 'using_special_buffer' in session and session['using_special_buffer']:
return messages.special_buffer_already_used
clear_buffer(session['username'])
userPrivateBuffer = PrivateBufferClass(DEFAULT_BUFFER_SIZE)
session['using_special_buffer'] = True
buffer = pickle.dumps(userPrivateBuffer, protocol=5)
set_buffer(session['username'], buffer)
return messages.using_special_buffer
# Authentication
@app.get("/authentication")
def authentication():
return render_template('authentication.html')
@app.post("/authentication")
def do_authenticate():
username = request.form.get('username', '')
password = request.form.get('password', '')
if not is_safe(username) or not is_safe(password):
return render_template('index.html', message=messages.bad_charactes)
res = login(username)
if res:
if res['password'] == password:
session['username'] = username
session['using_special_buffer'] = is_using_special_buffer(username)
return render_template('index.html', message=messages.logged.replace(':u', username), logged_in=True)
else:
return render_template('index.html', message=messages.bad_password)
else:
register(username, password)
session['username'] = username
return render_template('index.html', message=messages.registered.replace(':u', username), logged_in=True)
# Home
@app.get("/")
def home():
if 'username' in session:
return render_template('index.html', logged_in=True)
else:
return render_template('index.html', logged_in=False)
@app.get("/logout")
def logout():
session.pop('username', None)
return render_template('index.html', message=messages.logged_out, logged_in=False)
@app.before_first_request
def server_start():
cursor = db().cursor()
cursor.executescript("DROP TABLE IF EXISTS users")
db().commit()
cursor = db().cursor()
cursor.executescript('''
CREATE TABLE "users" (
"id" INTEGER PRIMARY KEY AUTOINCREMENT,
"username" TEXT,
"password" TEXT,
"buffer" BLOB DEFAULT "Welcome to your buffer!"
);
''')
db().commit()
if __name__ == '__main__':
app.run(host='0.0.0.0', port=3000, debug=False)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2022/rev/crypto/app.py | ctfs/pingCTF/2022/rev/crypto/app.py | from binascii import hexlify
printable = [chr(i) for i in range(0, 0xff)]
FLAG = open("flag.txt").readline().strip()
class Flawless:
rounds = []
def __init__(self, *rs):
self.alphabet = printable
self.rounds[:0] = rs[0]
self.l = len(rs[0])
def move(self):
for i in range(len(self.alphabet)):
self.alphabet[i] = chr((ord(self.rounds[self.current % self.l]) ^ ord(self.alphabet[i])) % 0xff)
self.current += 1
def move_left(self):
first = self.alphabet[0]
self.alphabet = self.alphabet[1:]
self.alphabet.append(first)
def move_right(self):
last = self.alphabet[-1]
self.alphabet = self.alphabet[:-1]
self.alphabet.insert(0, last)
def press(self, c):
if self.P > 0 and self.I > 0 and self.N > 0 and self.G > 0:
self.move_left()
self.reset_ping()
elif ord(c) % 4 == 0:
self.move()
elif ord(c) % 5 == 0:
self.move_right()
i = printable.index(c)
return self.alphabet[i]
def encipher(self, text):
self.current = 0
self.reset_ping()
ciphertext = ""
for c in text:
if c.upper() == 'P':
self.P += 1
elif c.upper() == 'I':
self.I += 1
elif c.upper() == 'N':
self.N += 1
elif c.upper() == 'G':
self.G += 1
ciphertext += self.press(c)
return hexlify(ciphertext.encode()).decode()
def reset_ping(self):
self.P = 0
self.I = 0
self.N = 0
self.G = 0
very_secret_cipher_text = "Nunc at lorem mauris. Cras eu egestas diam. Sed tincidunt augue sit amet mauris accumsan bibendum. Aliquam eget dapibus massa, vitae dictum lectus. Aliquam volutpat, metus sit amet efficitur pellentesque, ipsum nibh gravida elit, non gravida magna quam vel nulla. Maecenas vestibulum ultrices lectus, eu sodales magna blandit nec. Proin sit amet urna viverra, aliquet enim vel, eleifend sapien. Sed placerat efficitur ipsum ac rhoncus. Phasellus tempor rhoncus mollis. Phasellus dapibus ultricies aliquam. Vestibulum tempor nulla quis dictum tristique. Quisque luctus ligula ac feugiat commodo. Morbi commodo viverra nunc. Morbi faucibus arcu nisl, in scelerisque lorem vulputate id. Nulla iaculis sagittis ipsum, aliquet placerat lorem cursus ac. Fusce faucibus sapien a vestibulum finibus. Nunc commodo ullamcorper nunc, ac ullamcorper orci mattis sit amet. In faucibus enim eu pellentesque congue. Interdum et malesuada fames ac ante ipsum primis in faucibus. Curabitur malesuada dui lorem. Nunc varius velit in tellus gravida, mollis porttitor dolor tristique. Interdum et malesuada fames ac ante ipsum primis in faucibus. Aliquam libero felis, ullamcorper non est nec, malesuada ultrices odio. Donec sagittis efficitur diam, non gravida lorem. Fusce bibendum mi ut libero malesuada, eu laoreet tellus dictum. Vivamus sollicitudin sed neque at rutrum. Curabitur tempus rhoncus quam eu efficitur. Aliquam maximus magna augue, at lacinia lectus vestibulum sed. Donec semper consectetur lorem. Vestibulum in sodales massa. Aenean vitae ultricies metus, sit amet vestibulum mauris. Integer orci nisi, pulvinar sit amet dui eu, fermentum lobortis nunc. Nulla luctus at lectus ac vestibulum. Nulla at ipsum tristique, tristique est eget, pharetra lectus. Morbi urna lacus."
generator = Flawless(FLAG)
enciphered = generator.encipher(very_secret_cipher_text)
print(enciphered) # out.txt
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/pingCTF/2022/crypto/dialog/app.py | ctfs/pingCTF/2022/crypto/dialog/app.py | import base64
FLAG = open("flag.txt").readline().strip()
class DialogEncryption:
def __init__(self, key):
self.key = key
def encrypt(self, message):
encoded = ""
for i in range(len(message)):
key_c = self.key[i % len(self.key)][::-1]
encoded_c = chr((ord(message[i]) + ord(key_c)) % 256)
encoded += encoded_c
return base64.b64encode(encoded.encode()).decode()
def decrypt(self, message):
decoded = ""
message = base64.b64decode(message).decode()
for i in range(len(message)):
key_c = self.key[i % len(self.key)][::-1]
decoded_c = chr((256 + ord(message[i]) - ord(key_c)) % 256)
decoded += decoded_c
return decoded
key = FLAG
dialog = DialogEncryption(key)
message = "Hi Alice, I'm Bob. I'm sending you a secret message. I hope you can decrypt it."
encrypted = dialog.encrypt(message)
print(encrypted)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2024/misc/miku_ai/checker.py | ctfs/vsCTF/2024/misc/miku_ai/checker.py | '''
Miku AI is designed to support both high-quality audio and stunning visualizations.
To test its stability, you will be prompted with a random string and asked to upload an MP3.
Server has several checks to ensure that the AI is working as expected.
'''
import io
import os
import random
import time
import matplotlib.pyplot as plt
import numpy as np
import torchaudio
import transformers
from azure.cognitiveservices.vision.computervision import ComputerVisionClient
from azure.cognitiveservices.vision.computervision.models import OperationStatusCodes
from msrest.authentication import CognitiveServicesCredentials
from PIL import Image, ImageDraw, ImageFont
from pydub import AudioSegment
from scipy.io import wavfile
from transformers import pipeline
transformers.logging.set_verbosity_error()
font = ImageFont.truetype("Arial.ttf", size=60)
def generate_challenge() -> tuple[str, bytes]:
'''
Generates each challenge.
'''
text = ''.join(random.choices("ABCDEFGHIJKLMNOPQRSTUVWXYZ", k=12))
img = Image.new("RGBA", [i + 40 for i in font.getmask(text).size])
draw = ImageDraw.Draw(img)
draw_point = (0, 0)
colors = [(134,206,203,255), (19,122,127,255)] # miku
draw.multiline_text(draw_point, text, font=font, fill=random.choice(colors))
text_window = img.getbbox()
img = img.crop(text_window)
res = io.BytesIO()
img.save(res, format="PNG")
return text, res.getvalue()
def mp3_to_wav(mp3: bytes, flatten=False) -> io.BytesIO:
audio = AudioSegment.from_file(io.BytesIO(mp3), format="mp3")
if flatten:
audio = audio.set_channels(1)
wav_io = io.BytesIO()
audio.export(wav_io, format="wav")
return wav_io
def check1(mp3: bytes) -> bool:
'''
Since it's an AI app, ChatGPT usage is a must
https://chatgpt.com/share/e22ae484-6dc0-4cdf-8cab-89b7e0e49033
'''
_, data = wavfile.read(mp3_to_wav(mp3))
fft_data = np.fft.fft(data)
return 500 <= np.mean(np.abs(fft_data)) <= 1500
def check2(mp3: bytes) -> bool:
'''
Just an easy check to make sure it's like Miku voice...
PS. Original intention was speech_to_text(mp3)==generate_challenge() but I'm running out of time
'''
pipe = pipeline("audio-classification", model="alefiury/wav2vec2-large-xlsr-53-gender-recognition-librispeech")
audio, rate = torchaudio.load(mp3_to_wav(mp3))
transform = torchaudio.transforms.Resample(rate, 16000)
audio = transform(audio).numpy().reshape(-1)
prediction = pipe(audio)
prob = prediction[0]['score'] if prediction[0]['label'] == 'female' else prediction[1]['score']
return prob > 0.9727
def check3(mp3: bytes, res: str) -> bool:
'''
SuperBaldoGenni — Yesterday at 12:12 PM
is there any osint or stego
JoshO — Yesterday at 12:12 PM
yes stego
'''
sample_rate, data = wavfile.read(mp3_to_wav(mp3, True))
plt.axis('off')
plt.specgram(data, Fs=sample_rate, NFFT=512)
buf = io.BytesIO()
plt.gcf().set_size_inches(2*plt.gcf().get_size_inches()[0], 0.5*plt.gcf().get_size_inches()[1])
plt.savefig(buf, format='png', bbox_inches='tight')
buf.seek(0)
# Authenticates Azure credentials and creates a client.
subscription_key = os.environ["VISION_KEY"]
endpoint = os.environ["VISION_ENDPOINT"]
computervision_client = ComputerVisionClient(endpoint, CognitiveServicesCredentials(subscription_key))
# Start OCR
read_image = io.BufferedReader(buf)
read_response = computervision_client.read_in_stream(read_image, raw=True)
read_operation_location = read_response.headers["Operation-Location"]
operation_id = read_operation_location.split("/")[-1]
# Call the "GET" API and wait for the retrieval of the results
while True:
read_result = computervision_client.get_read_result(operation_id)
if read_result.status.lower() not in ['notstarted', 'running']:
break
time.sleep(2)
text_retrieved = ''
if read_result.status == OperationStatusCodes.succeeded:
for text_result in read_result.analyze_result.read_results:
for line in text_result.lines:
text_retrieved += line.text
return text_retrieved.strip() == res
def check(mp3: bytes, res: str) -> tuple[bool, str]:
try:
if not check1(mp3):
return False, "Check 1 failed"
if not check2(mp3):
return False, "Check 2 failed"
if not check3(mp3, res):
return False, "Check 3 failed"
return True, "All checks passed"
except Exception as e:
print(e)
return False, f"An error occurred: {e}"
if __name__ == "__main__":
text, res = generate_challenge()
print(f"Generated challenge: {text}")
mp3 = open("./miku.mp3", "rb").read()
print(check(mp3, text)) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2023/misc/not_a_last_minute_pyjail/server.py | ctfs/vsCTF/2023/misc/not_a_last_minute_pyjail/server.py | #!/usr/local/bin/python
# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
# Flag is in a file called "flag" in cwd.
#
# Quote from Dockerfile:
# FROM ubuntu:22.04
# RUN apt-get update && apt-get install -y python3
#
if __name__ != "__main__":
1/0 # Not a module
import ast
import sys
import os
def verify_secure(m):
for x in ast.walk(m):
match type(x):
case (ast.Lambda | ast.alias | ast.Assign | ast.Add | ast.Subscript | ast.Dict | ast.Store | ast.arg | ast.Pow | ast.Expr | ast.Div | ast.BinOp | ast.Sub | ast.Name | ast.Mult | ast.Module | ast.Load | ast.Constant | ast.Import | ast.ClassDef | ast.arguments | ast.UnaryOp | ast.USub):
continue
case _:
print(f"ERROR: Banned statement {x}")
return False
return True
abspath = os.path.abspath(__file__)
dname = os.path.dirname(abspath)
os.chdir(dname)
print("-- Please enter code (last line must contain only --END, will be split by --CHUNK)")
source_code = ""
while True:
line = input() + "\n"
if line.startswith("--END"):
break
source_code += line
if '@' in source_code or '.' in source_code or '(' in source_code or ')' in source_code or '#' in source_code:
print("ERROR: @.()# are banned")
exit(1)
chunks = source_code.split("--CHUNK\n")
for chunk in chunks:
tree = compile(source_code, "input.py", 'exec', flags=ast.PyCF_ONLY_AST)
if not verify_secure(tree):
exit(1)
for chunk in chunks: # Safe to execute!
print("-- Executing safe code:")
print(chunk)
exec(chunk) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2023/misc/OtterSec_Is_Cat/server.py | ctfs/vsCTF/2023/misc/OtterSec_Is_Cat/server.py | """
Model is trained by modifying https://github.com/elbow-jason/keras-examples/blob/master/mnist_cnn.py.
This challenge is using [Cifar10](https://www.cs.toronto.edu/~kriz/cifar.html) dataset.
"""
print("System is starting...Might take a while :)")
import os
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3" # disable tensorflow warnings
import keras
import tempfile
import sys
import numpy as np
import base64
from skimage import io
print(
"""
&@%
#@@@@@@@@@*
#@@@@@@@ %@@@@@@@@,
.@@@@@@@@@@@@ .@@@@@@@@@@@*
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&.@@@@@@@@@*
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.,@@@@@@@@@@@@,
%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#*,/&@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ %(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&(*,#@@@@&@@@@%@&(
@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@ ,@@& @@*
.@@@@@@@@@@@@@@@@@@@@@@@@. @@, %%/ *@@@@@@@@@(
/@@@@@@@@@@@@@@@@@@@@@@% .@% @@@* (@@@@@@(
(@@@@@@@@@@@@@@@@@@@@@# @& @/ &@@@@%
.@@@@@@@@@@@@@@@@@@@@@ @@ /@ @@@@@
@@@@@@@@@@@@@@@@@@@@& @@ @ .@@@@&
@@@@@@@@@@@@@@@@@@@@ @@ @ @@@@@
(@@@@@@@@@@@@@@@@@@@% @@ /# @@@@@&
*@@@@@@@@@@@@@@@@@@@@ /@% @ (@@@@@@
@@@@@@@@@@@@@@@@@@@@@ (@% %@/ %@@@@@@@&
.@@@@@@@@@@@@@@@@@@@@@@/ .,,//,%@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@&&%%%&@@@@@@@@@@@@@@@@@@@@@/
*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@,
&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@,
*#&@@@@@@&#*
"""
)
try:
print("Send me your fixed model: ")
data = base64.b64decode(input().strip())
temp = tempfile.NamedTemporaryFile(suffix=".h5")
temp.write(data)
model = keras.models.load_model(temp.name)
except Exception as e:
print("Load Model Error!")
sys.exit(1)
"""
Sanity check all 10 classes to see if the model can still classify them correctly.
Label ClassName
===================
0 airplane
1 automobile
2 bird
3 cat
4 deer
5 dog
6 frog
7 horse
8 ship
9 truck
"""
file_names = ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
length = 32
try:
for i in range(len(file_names)):
image = io.imread(f"./images/{file_names[i]}.jpg")
target = np.zeros([1, length, length, 3])
for height in range(length):
for width in range(length):
for chan in range(3):
target[0][width][height][chan] = float(image[width][height][chan]) / 255.0
labelled_class = np.argmax(model.predict(target))
assert labelled_class == i, "You have destroyed the model!"
image = io.imread("./images/ottersec-logo.jpg")
target = np.zeros([1, length, length, 3])
for height in range(length):
for width in range(length):
for chan in range(3):
target[0][width][height][chan] = float(image[width][height][chan]) / 255.0
labelled_class = np.argmax(model.predict(target))
if labelled_class == 3:
print("OtterCat! vsctf{REDACTED}")
else:
print("OtterSec is NOT A CAT in your model!")
except Exception as e:
print("Sanity Check Error: ", e)
sys.exit(1)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2023/misc/Babyfunge/chall.py | ctfs/vsCTF/2023/misc/Babyfunge/chall.py | from interpreter import befunge
""" Befunge grid:
[Line 1 input here]
[Line 2 input here]
[Line 3 input here]
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
vsctf{??????????????????????????????}
"""
unneeded_commands = "pg&~" # idk why anyone would need these
FLAG = "vsctf{??????????????????????????????}" # real flag will be the same length
line_size = len(FLAG)
# get the input code
payload = ""
for i in range(3):
this_line = input(f"Line {i+1}: ")
if len(this_line) > line_size:
print("Jeez, you don't need all that space!")
quit()
payload += f'{this_line:<{line_size}}\n' # fill the line
# make sure your code is optimal!
num_of_commands = len(payload.replace(" ", "").replace("\n", ""))
any_unneeded_commands = any(command in unneeded_commands for command in payload)
if any_unneeded_commands or num_of_commands > 7:
print("You don't need all that overhead!")
quit()
try:
befunge(f'{payload}{"@"*line_size}\n{FLAG}')
except Exception:
pass
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2023/misc/Babyfunge/interpreter.py | ctfs/vsCTF/2023/misc/Babyfunge/interpreter.py | """
CREDIT: https://github.com/java-abhinav07/Befunge93_Interpreter
"""
import random
class Stack:
def __init__(self):
self.items = []
def is_empty(self):
return self.items == []
def push(self, data):
self.items.append(data)
def pop(self):
if not self.is_empty():
return self.items.pop()
return 0
def peek(self):
if not self.is_empty():
return self.items[-1]
def get_stack(self):
return self.items
def duplicate(self):
if not self.is_empty():
self.push(self.items[-1])
else:
self.push(0)
def swap(self):
if not self.is_empty():
if len(self.items) > 1:
num_0 = self.pop()
num_1 = self.pop()
self.push(num_0)
self.push(num_1)
elif len(self.items) == 1:
num = self.pop()
self.push(num)
self.push(0)
def math_op(a, b, current):
operations = {
'+': a + b,
'-': b - a,
'/': b // a if a != 0 else 0,
'%': b % a if a != 0 else 0,
'*': a * b
}
return operations[current]
def befunge(code, max_moves=100):
code = code.split('\n')
directions = {">": (0, 1), "<": (0, -1), "v": (1, 0), "^": (-1, 0)}
math = ['+', '-', '/', "*", "%"]
logical = ["`", "!"]
conditional = ["_", "|"]
strmode = False
length = len(code)
width = len(code[0])
current = code[0][0]
coordinates = [0, 0]
move = (0, 1)
Stk = Stack()
moves = 0 # please don't break my interpreter T-T
while moves <= max_moves and (current != '@' or strmode):
if strmode:
if current == '"':
strmode = False
else:
Stk.push(ord(current))
else:
if current.isdigit():
Stk.push(int(current))
elif current in math:
Stk.push(math_op(Stk.pop(), Stk.pop(), current))
elif current in logical:
if current == '!':
Stk.push(int(Stk.pop == 0))
elif current == '`':
num_0 = Stk.pop()
num_1 = Stk.pop()
Stk.push(int(num_1 > num_0))
elif current in conditional:
if current == '_':
val = Stk.pop()
if val == 0:
move = (0, 1)
else:
move = (0, -1)
elif current == '|':
val = Stk.pop()
if val == 0:
move = (-1, 0)
else:
move = (1, 0)
elif current in directions:
move = directions.get(current)
elif current == '?':
move = random.choice([(0, 1), (1, 0), (-1, 0), (0, -1)])
elif current == ':':
Stk.duplicate()
elif current == '$':
Stk.pop()
elif current == '.':
num = Stk.pop()
if num:
print(num, end="")
elif current == ',':
letter = Stk.pop()
if letter:
print(chr(letter), end="")
elif current == '#':
move = (2 * move[0], 2 * move[1])
elif current == '"':
strmode = True
elif current == "\\":
Stk.swap()
elif current == 'g':
xc = Stk.pop()
yc = Stk.pop()
Stk.push(chr(code[yc][xc]))
elif current == 'p':
xc = Stk.pop()
yc = Stk.pop()
vc = Stk.pop()
tobepushed = chr(vc)
code[xc][yc] = tobepushed
# move in a given direction
coordinates[0] = coordinates[0] + move[0]
coordinates[1] = coordinates[1] + move[1]
# rationalize coordinates
if coordinates[1] > width:
coordinates[1] = coordinates[1] % width
coordinates[0] = coordinates[0] + (coordinates[1] // width)
if coordinates[0] > length:
coordinates[0] = coordinates[0] % length
if coordinates[0] > length:
coordinates[0] = coordinates[0] % length
coordinates[1] = coordinates[1] + (coordinates[0] // length)
if coordinates[0] > width:
coordinates[0] = coordinates[0] % width
# set pointer
current = code[coordinates[0]][coordinates[1]]
moves += 1
print()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2023/crypto/Inexpensive/chall2.py | ctfs/vsCTF/2023/crypto/Inexpensive/chall2.py | from sage.all import *
from flag import flag
from Crypto.Util.Padding import pad
from Crypto.Cipher import AES
from random import SystemRandom
random = SystemRandom()
# Secp256k1
p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
a = 0
b = 7
E = EllipticCurve(GF(p), [a, b])
G = E.gens()[0]
order = E.order()
Fn = GF(order)
d = random.randint(1, order)
hd = hex(d)[2:]
if len(hd) % 2 == 1:
hd = '0' + hd
key = bytes.fromhex(hd)
iv = random.randbytes(16)
cipher = AES.new(key, AES.MODE_CBC, iv=iv)
flag = flag.encode()
flag = pad(flag, 16)
c = cipher.encrypt(flag)
print(f"iv = '{iv.hex()}'")
print(f"c = '{c.hex()}'")
def gen_nonce(): return 2**128*(d % (2**128)) + (d >> 128)
nonce = gen_nonce()
msg = random.randbytes(32)
z = int.from_bytes(msg, 'big')
# sign
public = d*G
r = Fn((nonce*G).xy()[0])
s = Fn(nonce)**(-1) * (z + r*d)
print(f"public = {public.xy()}")
print(f"{s = }")
print(f"{r = }")
print(f"msg = '{msg.hex()}'")
inv_s = pow(int(s), -1, order)
u1 = int(z*int(inv_s)) % order
u2 = int(r*int(inv_s)) % order
P = u1*G + u2*public
P = P.xy()[0]
assert int(P) == int(r), "Signature is invalid??!??!?!?!??!?!?!" | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2023/crypto/Inexpensive/flag.py | ctfs/vsCTF/2023/crypto/Inexpensive/flag.py | flag='FAKEFLAG' | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2023/crypto/Redundancy/chall1.py | ctfs/vsCTF/2023/crypto/Redundancy/chall1.py | from flag import flag
from Crypto.Util.number import getPrime as gP
e1, e2 = 5*2, 5*3
assert len(flag) < 16
flag = "Wow good job the flag is (omg hype hype): vsctf{"+flag+"}"
p = gP(1024)
q = gP(1024)
n = p * q
m = int.from_bytes(flag.encode(), 'big')
c1 = pow(m, e1, n)
c2 = pow(m, e2, n)
print(f"n = {n}")
print(f"c1 = {c1}")
print(f"c2 = {c2}")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2023/crypto/Redundancy/flag.py | ctfs/vsCTF/2023/crypto/Redundancy/flag.py | flag='FAKEFLAG' | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2023/crypto/Share++/server.py | ctfs/vsCTF/2023/crypto/Share++/server.py | #!/usr/bin/env python3
from Crypto.Util.number import isPrime, getRandomRange, bytes_to_long
from typing import List
import os, signal
class SecretSharing:
def __init__(self, p: int, n: int, secret: int):
self.p = p
self.n = n
self.poly = [secret] + [getRandomRange(0, self.p + 1) for _ in range(n - 1)]
def evaluate(self, x: int) -> int:
return (
sum([self.poly[i] * pow(x, i, self.p) for i in range(len(self.poly))])
% self.p
)
def get_shares(self) -> List[int]:
return [self.evaluate(i + 1) for i in range(self.n)]
if __name__ == "__main__":
signal.alarm(30)
secret = bytes_to_long(os.urandom(32))
while True:
p = int(input("p = "))
n = int(input("n = "))
if isPrime(p) and int(13.37) < n < p:
shares = SecretSharing(p, n, secret).get_shares()
print("shares =", shares[:-1])
else:
break
if int(input("secret = ")) == secret:
print(open("flag.txt", "r").read().strip())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2022/crypto/Recovery/PassChecker2000.py | ctfs/vsCTF/2022/crypto/Recovery/PassChecker2000.py | # I coded this so that I wouldn't have to use a database!
from random import randint
from base64 import b64encode
def validate(password: str) -> bool:
if len(password) != 49:
return False
key = ['vs'.join(str(randint(7, 9)) for _ in range(ord(i))) + 'vs' for i in password[::-2]]
gate = [118, 140, 231, 176, 205, 480, 308, 872, 702, 820, 1034, 1176, 1339, 1232, 1605, 1792, 782, 810, 1197, 880,
924, 1694, 2185, 2208, 2775]
if [randint(a, b[0]) for a, b in enumerate(zip(gate, key), 1) if len(b[1]) != 3 * (b[0] + 7 * a) // a]:
return False
hammer = {str(a): password[a] + password[a + len(password) // 2] for a in range(1, len(password) // 2, 2)}
block = b'c3MxLnRkMy57XzUuaE83LjVfOS5faDExLkxfMTMuR0gxNS5fTDE3LjNfMTkuMzEyMS5pMzIz'
if b64encode(b'.'.join([((b + a).encode()) for a, b in hammer.items()])) != block:
return False
return True
if __name__ == "__main__":
passwd = input('Please validate your ID using your password\n> ')
if validate(passwd):
print('Access Granted: You now have gained access to the View Source Flag Vault!')
else:
print('Access Denied :(') | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2022/crypto/SecureGradingSystem/system.py | ctfs/vsCTF/2022/crypto/SecureGradingSystem/system.py | import string
import sys
import ecdsa
import hashlib
import random
from time import time
from base64 import b64encode
from Crypto.Util.number import bytes_to_long, long_to_bytes, getPrime, size
from secret import FLAG, get_report_content
'''
Grading system documentation (for internal use ONLY)
1. The school's grader team consists of 3 tutors and a professor.
2. To submit the final report, student first needs to pass Proof of Work to show they are not robots.
3. The student will sign their report (in text format) with their name and send it to the professor.
Professor will verify the signature and make sure the student is THE real student.
4. The student will then send 3 copies of their report to each of the tutors for marking.
Finally student will receive their scoring.
5. REDACTED
6. Combining these public-key cryptosystems mentioned above, no way the system will have any vulnerability...
Secure data transmission for the win! NO CHEATING IS ALLOWED IN OUR SCHOOL!!!
'''
# Utils
BANNER = '''
__ __ _______ __ __ __ _ ___ __ __ _______ ______ _______ ___ _______ __ __
| | | || | | | | || | | || | | | | || || _ | | || | | || | | |
| |_| || _____| | | | || |_| || | | |_| || ___|| | || | _____|| | |_ _|| |_| |
| || |_____ | |_| || || | | || |___ | |_||_ | |_____ | | | | | |
| ||_____ | | || _ || | | || ___|| __ ||_____ || | | | |_ _|
| | _____| | | || | | || | | | | |___ | | | | _____| || | | | | |
|___| |_______| |_______||_| |__||___| |___| |_______||___| |_||_______||___| |___| |___|
'''
STUDENT_NAME = "jayden_vs"
ALLOWED_CHARS = string.ascii_letters + string.digits
def randbytes(n): return bytes([random.randint(0,255) for i in range(n)])
def randomize_report(report):
for _ in range(8):
rand_bytes = randbytes(8)
rand_loc = random.randrange(0, len(report) * 3 // 4)
report = report[:rand_loc] + rand_bytes + report[rand_loc:]
return report
# Classes
class ProofOfWorkSolver:
def __init__(self, prefix_length=8):
self.prefix_length = prefix_length
def generate(self):
prefix = ''.join(random.choices(ALLOWED_CHARS, k=self.prefix_length))
self.nonce = ''.join(random.choices(ALLOWED_CHARS, k=16))
return self.nonce, hashlib.sha256((prefix + self.nonce).encode('utf-8')).hexdigest()
def verify(self, prefix, answer) -> bool:
h = hashlib.sha256((prefix + self.nonce).encode('utf-8')).hexdigest()
return h == answer
class Signature:
def __init__(self, r, s):
self.r = r
self.s = s
def print_sig(self):
print(f"Signature: ({self.r}, {self.s})")
class Ecdsa:
def __init__(self, curve=ecdsa.curves.SECP256k1):
self.curve = curve
self.G = curve.generator
self.n = self.G.order()
self.d = random.randrange(1, self.n)
self.Q = self.d * self.G
self.recovery = None
def sign(self, message: bytes, hashfunc=hashlib.sha256, resign=False) -> Signature:
H = int(hashfunc(message).hexdigest(), 16)
r, s = 0, 0
while r == 0 or s == 0:
k = random.randrange(1, self.n) if not resign else self.recovery
self.recovery = k
R = k * self.G
r = R.x() % self.n
s = ((H + r * self.d) * pow(k, -1, self.n)) % self.n
return Signature(r=r, s=s)
def verify(self, message: bytes, signature: Signature, hashfunc=hashlib.sha256) -> bool:
H = int(hashfunc(message).hexdigest(), 16)
r, s = signature.r, signature.s
sinv = pow(s, -1, self.n)
u1, u2 = (H * sinv) % self.n, (r * sinv) % self.n
R = u1 * self.G + u2 * self.Q
return R.x() % self.n == r
class Rsa:
def __init__(self, bit_len=2048):
self.p = getPrime(bit_len // 2)
self.q = getPrime(bit_len // 2)
self.N = self.p * self.q
self.e = 3
print(f"N = {self.N}")
def encrypt(self, message: bytes):
return b64encode(long_to_bytes(pow(bytes_to_long(message), self.e, self.N)))
def decrypt(self, ciphertext: bytes):
d = pow(self.e, -1, (self.p-1) * (self.q-1))
return b64encode(long_to_bytes(pow(bytes_to_long(ciphertext), d, self.N)))
if __name__ == '__main__':
print(BANNER)
print("[+] System startup...")
print(f"[!] Welcome to the super secure grading system, {STUDENT_NAME}.\n")
powchal = ProofOfWorkSolver(prefix_length = 4)
nonce, answer = powchal.generate()
print(f'''Please solve the following challenge to show you are not a robot...\n
sha256(???? + {nonce}) == {answer}\n''')
prefix = input("Your answer: ")
if not powchal.verify(prefix, answer):
sys.exit('Goodbye, robot!')
print("\n[+] Verification successful.\n")
report = get_report_content()
assert report is not None
report = randomize_report(report)
report_signed = STUDENT_NAME.encode('utf-8') + report
print("[+] Verifying with Professor...")
my_ecdsa = Ecdsa(ecdsa.curves.NIST384p)
sig1 = my_ecdsa.sign(report_signed[:len(report_signed) // 2])
sig1.print_sig()
assert my_ecdsa.verify(report_signed[:len(report_signed) // 2], sig1)
sig2 = my_ecdsa.sign(report_signed[len(report_signed) // 2:], hashlib.sha256, True)
sig2.print_sig()
assert my_ecdsa.verify(report_signed[len(report_signed) // 2:], sig2)
print("\n[+] Verification successful.\n")
print("[+] Distributing reports to tutors...")
for i in range(1, 4):
print(f"[-] Tutor {i}:")
curr = Rsa(size(bytes_to_long(report)) + 64)
print(f"Ciphertext = {curr.encrypt(report).decode('utf-8')}\n")
print("[+] Distribution successful.\n")
print("[+] I don't think you can forge it but hey, if you can really do so I will reward you the flag.")
try:
T = time()
final_key = int(input("My secret key when communicating with professor: ").strip())
if final_key == my_ecdsa.d:
elapsed = 1000.0 * (time() - T)
if elapsed >= 10000:
print("[x] If you spend too much time the professor will know you are cheating!")
else:
print("[-] My system is broken :(")
print(f"[-] Here is the flag: {FLAG}")
else:
print("[x] Seems I'm right, it is super secure!")
except:
sys.exit(f"[x] Bad hacking attempt!") | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2022/crypto/ArtFinal/enhancer.py | ctfs/vsCTF/2022/crypto/ArtFinal/enhancer.py | # Teacher, please give me an A
import random
from PIL import Image
boring = Image.open('Art_Final_2022.png', 'r').convert('RGBA')
boring_pix = boring.load()
spicy = Image.new('RGBA', boring.size)
spicy_pix = spicy.load()
# Add SPICE
for i in range(boring.size[0] * boring.size[1]):
x = i % boring.size[0]
y = i // boring.size[0]
rgba = tuple(random.randbytes(4))
spicy_pix[x, y] = tuple([bore ^ spice for bore, spice in zip(boring_pix[x, y], rgba)])
# This final is HOT
spicy.save('ENHANCED_Final_2022.png')
# oh shoot, i forgot there needs to be a flag ._.
from Crypto import Random
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from base64 import b64encode
key = bytes(random.sample(random.randbytes(16), 16))
iv = Random.new().read(AES.block_size)
enc = AES.new(key, AES.MODE_CBC, iv)
flag = b64encode(iv + enc.encrypt(pad(b'[REDACTED]', AES.block_size))).decode()
print(flag) # Tl5nK8L2KYZRCJCqLF7TbgKLgy1vIkH+KIAJv5/ILFoC+llemcmoLmCQYkiOrJ/orOOV+lwX+cVh+pwE5mtx6w==
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2022/crypto/BabyRSA/chall.py | ctfs/vsCTF/2022/crypto/BabyRSA/chall.py | from Crypto.PublicKey import RSA
from Crypto.Util.number import *
from secret import e
with open("flag.txt",'r') as f:
flag = f.read().strip()
p = getPrime(128)
q = getPrime(128)
while p % e != 1:
p = getPrime(128)
while q % e != 1:
q = getPrime(128)
n = p * q
m = bytes_to_long(flag.encode())
c = pow(m, e, n)
print(f"Ciphertext: {hex(c)}")
with open("pubkey.pem",'w') as f:
pk = RSA.construct([n, e])
f.write(pk.exportKey('PEM').decode('utf-8'))
# Ciphertext: 0x459cc234f24a2fb115ff10e272130048d996f5b562964ee6138442a4429af847 | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2022/crypto/StrongestRSA/chall.py | ctfs/vsCTF/2022/crypto/StrongestRSA/chall.py | from Crypto.Util.number import getStrongPrime, bytes_to_long
from sympy import prevprime, factorial
from math import gcd
import random
from secret import FLAG
e = 0x10001
def getStrongestPrime(nbits):
while True:
p = getStrongPrime(nbits)
delta = random.randint(0x1337, 0x1337 + 0x1337)
pp = p - delta
ppp = prevprime(factorial(pp) % p)
if gcd(ppp-1, e) == 1:
return p, ppp
NBITS = 1024
p0, p = getStrongestPrime(NBITS)
q0, q = getStrongestPrime(NBITS)
N = p * q
m = bytes_to_long(FLAG.encode())
c = pow(m, e, N)
print(f"p0 = {p0}\nq0 = {q0}")
print(f"N = {N}\ne = {e}\nc = {c}") | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/vsCTF/2022/crypto/NISTFinalistRevisited/ascon.py | ctfs/vsCTF/2022/crypto/NISTFinalistRevisited/ascon.py | #!/usr/bin/env python3
"""
Implementation of Ascon hash function http://ascon.iaik.tugraz.at/
Round-Reduced Ascon-Hash adapted from https://github.com/meichlseder/pyascon/blob/master/ascon.py
"""
import json
FLAG = "vsctf{REDACTED}"
def ascon_xof(message):
a = 2
b = 2
rate = 8 # bytes
hashlength = 8
# Initialization
tagspec = int_to_bytes(0, 4)
S = bytes_to_state(to_bytes([0, rate * 8, a, a-b]) + tagspec + zero_bytes(32))
ascon_permutation(S, a)
# Message Processing (Absorbing)
m_padding = to_bytes([0x80]) + zero_bytes(rate - (len(message) % rate) - 1)
m_padded = message + m_padding
# first s-1 blocks
for block in range(0, len(m_padded) - rate, rate):
S[0] ^= bytes_to_int(m_padded[block:block+8]) # rate=8
ascon_permutation(S, b)
# last block
block = len(m_padded) - rate
S[0] ^= bytes_to_int(m_padded[block:block+8]) # rate=8
# Finalization (Squeezing)
H = b""
ascon_permutation(S, a)
while len(H) < hashlength:
H += int_to_bytes(S[0], 8) # rate=8
ascon_permutation(S, b)
return H[:hashlength]
def ascon_permutation(S, rounds=1):
for r in range(12-rounds, 12):
# --- add round constants ---
S[2] ^= (0xf0 - r*0x10 + r*0x1)
# --- substitution layer ---
S[0] ^= S[4]
S[4] ^= S[3]
S[2] ^= S[1]
T = [(S[i] ^ 0xFFFFFFFFFFFFFFFF) & S[(i+1)%5] for i in range(5)]
for i in range(5):
S[i] ^= T[(i+1)%5]
S[1] ^= S[0]
S[0] ^= S[4]
S[3] ^= S[2]
S[2] ^= 0XFFFFFFFFFFFFFFFF
# --- linear diffusion layer ---
S[0] ^= rotr(S[0], 19) ^ rotr(S[0], 28)
S[1] ^= rotr(S[1], 61) ^ rotr(S[1], 39)
S[2] ^= rotr(S[2], 1) ^ rotr(S[2], 6)
S[3] ^= rotr(S[3], 10) ^ rotr(S[3], 17)
S[4] ^= rotr(S[4], 7) ^ rotr(S[4], 41)
def zero_bytes(n):
return n * b"\x00"
def to_bytes(l): # where l is a list or bytearray or bytes
return bytes(bytearray(l))
def bytes_to_int(bytes):
return sum([bi << ((len(bytes) - 1 - i)*8) for i, bi in enumerate(to_bytes(bytes))])
def bytes_to_state(bytes):
return [bytes_to_int(bytes[8*w:8*(w+1)]) for w in range(5)]
def int_to_bytes(integer, nbytes):
return to_bytes([(integer >> ((nbytes - 1 - i) * 8)) % 256 for i in range(nbytes)])
def rotr(val, r):
return (val >> r) | ((val & (1<<r)-1) << (64-r))
def bytes_to_hex(b):
return b.hex()
def print_info(data):
maxlen = max([len(text) for (text, val) in data])
for text, val in data:
print("{text}:{align} 0x{val} ({length} bytes)".format(text=text, align=((maxlen - len(text)) * " "), val=bytes_to_hex(val), length=len(val)))
def collision(m1: bytes, m2: bytes) -> bool:
return ascon_xof(m1) == ascon_xof(m2)
if __name__ == "__main__":
print("12 rounds of Ascon is surely collision resistant. What about 2-round Ascon?")
print("If you can find two collisions for me, I will give you the flag!\n")
try:
stage1 = input("1. Please send two hex encoded messages m1, m2 formatted in JSON:\n").strip()
stage1_inp = json.loads(stage1)
if "m1" not in stage1_inp or "m2" not in stage1_inp:
print("Your input is missing one or more of the required fields. Please try again.")
exit(1)
m1 = bytes.fromhex(stage1_inp["m1"])
m2 = bytes.fromhex(stage1_inp["m2"])
if m1 == m2:
print("Don't try to cheese it :(")
exit(1)
if b"admin" in m1 or b"admin" in m2:
print("Too early to be an admin!")
exit(1)
if not collision(m1, m2):
print("Attempt failed! Two distinct messages have distinct hashes!")
exit(1)
else:
print("Nice, collision found!\n")
stage2 = input("2. Please send another two hex encoded messages m1, m2 formatted in JSON:\n").strip()
stage2_inp = json.loads(stage2)
if "m1" not in stage2_inp or "m2" not in stage2_inp:
print("Your input is missing one or more of the required fields. Please try again.")
exit(1)
m1 = bytes.fromhex(stage2_inp["m1"])
m2 = bytes.fromhex(stage2_inp["m2"])
if m1 == m2:
print("Don't try to cheese it :(")
exit(1)
if b"admin" not in m1 or b"admin" not in m2:
print("You need to be admin to get the flag!")
exit(1)
if not collision(m1, m2):
print("Attempt failed! Two distinct messages have distinct hashes!")
exit(1)
else:
print(f"Nice, collision found again! Here is your flag: {FLAG}")
except Exception as e:
print("Exception raised: ", e)
exit(1) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/rev/lambda_lambda/chall.py | ctfs/angstromCTF/2021/rev/lambda_lambda/chall.py | print((lambda LAMBDa: lambda LAMbDA: lambda LAMBda: lambda LAMbda: (lambda Lambda: ((lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))(lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))))(lambda Lambda: lambda lAMBDA: lambda lamBDA: (lambda lAmbda: lambda lAMbda: (lAMBDA if not lAmbda else Lambda(lAMBDA*256+(lambda lAMBDA: lAMBDA(lambda LAMBDA: LAMBDA+1)(0))((lambda LAMBDa: lambda LAMbDA: LAMBDa(lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMbDA))(LAMBda)((lambda LAMBDA: (lambda LAMBDa: lambda LAMbDA: LAMBDa(lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMbDA))((lambda LAMBDa: lambda LAMbDA: lambda lAMBDA: LAMBDa(LAMbDA(lAMBDA)))((lambda Lambda: ((lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))(lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))))(lambda Lambda: lambda LAMBDa: lambda LAMbDA: (lambda LAMBDa: lambda LAMbDA: (lambda LAMBDa: LAMBDa(lambda lAmBdA: lambda LAMBDa: lambda LAMbDA: LAMbDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa))((lambda LAMBDa: lambda LAMbDA: LAMbDA(lambda lAMBDA: lambda Lambda: lambda LAMBDA: lAMBDA(lambda LAmbda: lambda lambdah: lambdah(LAmbda(Lambda)))(lambda lAmBdA: LAMBDA)(lambda LAMBDA: LAMBDA))(LAMBDa))((lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMBDa))(LAMbDA)))(LAMBDa)(LAMbDA)(lambda lAmBdA: LAMBDa)(lambda lAmBdA: Lambda((lambda LAMBDa: lambda LAMbDA: LAMbDA(lambda lAMBDA: lambda Lambda: lambda LAMBDA: lAMBDA(lambda LAmbda: lambda lambdah: lambdah(LAmbda(Lambda)))(lambda lAmBdA: LAMBDA)(lambda LAMBDA: LAMBDA))(LAMBDa))(LAMBDa)(LAMbDA))(LAMbDA))(lambda LAMBDa: lambda LAMbDA: LAMbDA))(LAMBDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMbDA))))))))))))))))))(lambda LAMBDa: lambda LAMbDA: LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMbDA))))))))))))))))))(((lambda Lambda: ((lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))(lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))))(lambda Lambda: lambda LAMBDa: lambda LAMbDA: (lambda LAMBDa: lambda LAMbDA: (lambda LAMBDa: LAMBDa(lambda lAmBdA: lambda LAMBDa: lambda LAMbDA: LAMbDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa))((lambda LAMBDa: lambda LAMbDA: LAMbDA(lambda lAMBDA: lambda Lambda: lambda LAMBDA: lAMBDA(lambda LAmbda: lambda lambdah: lambdah(LAmbda(Lambda)))(lambda lAmBdA: LAMBDA)(lambda LAMBDA: LAMBDA))(LAMBDa))((lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMBDa))(LAMbDA)))(LAMBDa)(LAMbDA)(lambda lAmBdA: lambda LAMBDa: lambda LAMbDA: LAMbDA)(lambda lAmBdA: (lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(Lambda((lambda LAMBDa: lambda LAMbDA: LAMbDA(lambda lAMBDA: lambda Lambda: lambda LAMBDA: lAMBDA(lambda LAmbda: lambda lambdah: lambdah(LAmbda(Lambda)))(lambda lAmBdA: LAMBDA)(lambda LAMBDA: LAMBDA))(LAMBDa))(LAMBDa)(LAMbDA))(LAMbDA)))(lambda LAMBDa: lambda LAMbDA: LAMbDA)))(LAMBDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMBDa(LAMbDA)))))))))))))))))))((lambda LAMBDa: lambda LAMbDA: (lambda laMBDA: lambda laMbda: (((lambda Lambda: ((lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))(lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda))))))(lambda Lambda: lambda lAMBDA: lambda LAMBDA: lambda LAMbda: lambda lamBDA: (lambda LAMBDa: lambda LAMbDA: LAMBDa(lambda LAMBDa: lambda LAMbDA: LAMBDa)(LAMbDA))(laMBDA(LAMBDA))(laMBDA(LAMbda))(lambda lAmBdA: laMBDA(LAMBDA)((lambda LAMBDa: lambda LAMbDA: LAMBDa(lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMbDA))(lAMBDA)(laMbda(LAMbda)((lambda LAMBDa: lambda LAMbDA: LAMbDA(LAMBDa))(lambda LAMBDa: lambda LAMbDA: LAMBDa(LAMBDa(LAMbDA)))(lamBDA))))((lambda LAMBDa: lambda LAMbDA: LAMBDa(lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMbDA))(lAMBDA)(laMbda(LAMBDA)((lambda LAMBDa: lambda LAMbDA: LAMbDA(LAMBDa))(lambda LAMBDa: lambda LAMbDA: LAMBDa(LAMBDa(LAMbDA)))(lamBDA)))))(lambda lAmBdA: Lambda((lambda LAMBDa: lambda LAMbDA: LAMBDa(lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMbDA))(lAMBDA)(laMbda((lambda LAMBDa: lambda LAMbDA: LAMbDA(LAMBDa))(lambda LAMBDa: lambda LAMbDA: LAMBDa(LAMBDa(LAMbDA)))(lamBDA))((lambda LAMBDA: lambda LAMbda: (lambda LAMBDa: lambda LAMbDA: LAMBDa(lambda LAMBDa: lambda LAMbDA: LAMBDa)(LAMbDA))((lambda LAMBDa: lambda LAMbDA: LAMBDa(LAMbDA)(lambda LAMBDa: lambda LAMbDA: LAMbDA))(laMBDA(LAMBDA))((lambda LAMBDa: LAMBDa(lambda LAMBDa: lambda LAMbDA: LAMbDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa))(laMBDA(LAMbda))))((lambda LAMBDa: lambda LAMbDA: LAMBDa(LAMbDA)(lambda LAMBDa: lambda LAMbDA: LAMbDA))(laMBDA(LAMbda))((lambda LAMBDa: LAMBDa(lambda LAMBDa: lambda LAMbDA: LAMbDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa))(laMBDA(LAMBDA))))(lambda LAMBDA: LAMBDA)(lambda LAMBDa: lambda LAMbDA: LAMbDA))(((lambda Lambda: ((lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))(lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))))(lambda Lambda: lambda LAMBDa: lambda LAMbDA: (lambda LAMBDa: lambda LAMbDA: (lambda LAMBDa: LAMBDa(lambda lAmBdA: lambda LAMBDa: lambda LAMbDA: LAMbDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa))((lambda LAMBDa: lambda LAMbDA: LAMbDA(lambda lAMBDA: lambda Lambda: lambda LAMBDA: lAMBDA(lambda LAmbda: lambda lambdah: lambdah(LAmbda(Lambda)))(lambda lAmBdA: LAMBDA)(lambda LAMBDA: LAMBDA))(LAMBDa))((lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMBDa))(LAMbDA)))(LAMBDa)(LAMbDA)(lambda lAmBdA: LAMBDa)(lambda lAmBdA: Lambda((lambda LAMBDa: lambda LAMbDA: LAMbDA(lambda lAMBDA: lambda Lambda: lambda LAMBDA: lAMBDA(lambda LAmbda: lambda lambdah: lambdah(LAmbda(Lambda)))(lambda lAmBdA: LAMBDA)(lambda LAMBDA: LAMBDA))(LAMBDa))(LAMBDa)(LAMbDA))(LAMbDA))(lambda LAMBDa: lambda LAMbDA: LAMbDA)))(LAMBDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa(LAMBDa(LAMbDA))))(((lambda Lambda: ((lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))(lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))))(lambda Lambda: lambda LAMBDa: lambda LAMbDA: (lambda LAMBDa: lambda LAMbDA: (lambda LAMBDa: LAMBDa(lambda lAmBdA: lambda LAMBDa: lambda LAMbDA: LAMbDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa))((lambda LAMBDa: lambda LAMbDA: LAMbDA(lambda lAMBDA: lambda Lambda: lambda LAMBDA: lAMBDA(lambda LAmbda: lambda lambdah: lambdah(LAmbda(Lambda)))(lambda lAmBdA: LAMBDA)(lambda LAMBDA: LAMBDA))(LAMBDa))((lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMBDa))(LAMbDA)))(LAMBDa)(LAMbDA)(lambda lAmBdA: LAMBDa)(lambda lAmBdA: Lambda((lambda LAMBDa: lambda LAMbDA: LAMbDA(lambda lAMBDA: lambda Lambda: lambda LAMBDA: lAMBDA(lambda LAmbda: lambda lambdah: lambdah(LAmbda(Lambda)))(lambda lAmBdA: LAMBDA)(lambda LAMBDA: LAMBDA))(LAMBDa))(LAMBDa)(LAMbDA))(LAMbDA))(lambda LAMBDa: lambda LAMbDA: LAMbDA)))(LAMbda)(lambda LAMBDa: lambda LAMbDA: LAMBDa(LAMBDa(LAMbDA)))))))(((lambda Lambda: ((lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))(lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))))(lambda Lambda: lambda LAMBDa: lambda LAMbDA: (lambda LAMBDa: lambda LAMbDA: (lambda LAMBDa: LAMBDa(lambda lAmBdA: lambda LAMBDa: lambda LAMbDA: LAMbDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa))((lambda LAMBDa: lambda LAMbDA: LAMbDA(lambda lAMBDA: lambda Lambda: lambda LAMBDA: lAMBDA(lambda LAmbda: lambda lambdah: lambdah(LAmbda(Lambda)))(lambda lAmBdA: LAMBDA)(lambda LAMBDA: LAMBDA))(LAMBDa))((lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMBDa))(LAMbDA)))(LAMBDa)(LAMbDA)(lambda lAmBdA: lambda LAMBDa: lambda LAMbDA: LAMbDA)(lambda lAmBdA: (lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(Lambda((lambda LAMBDa: lambda LAMbDA: LAMbDA(lambda lAMBDA: lambda Lambda: lambda LAMBDA: lAMBDA(lambda LAmbda: lambda lambdah: lambdah(LAmbda(Lambda)))(lambda lAmBdA: LAMBDA)(lambda LAMBDA: LAMBDA))(LAMBDa))(LAMBDa)(LAMbDA))(LAMbDA)))(lambda LAMBDa: lambda LAMbDA: LAMbDA)))(LAMBDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa(LAMBDa(LAMbDA))))(((lambda Lambda: ((lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))(lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))))(lambda Lambda: lambda LAMBDa: lambda LAMbDA: (lambda LAMBDa: lambda LAMbDA: (lambda LAMBDa: LAMBDa(lambda lAmBdA: lambda LAMBDa: lambda LAMbDA: LAMbDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa))((lambda LAMBDa: lambda LAMbDA: LAMbDA(lambda lAMBDA: lambda Lambda: lambda LAMBDA: lAMBDA(lambda LAmbda: lambda lambdah: lambdah(LAmbda(Lambda)))(lambda lAmBdA: LAMBDA)(lambda LAMBDA: LAMBDA))(LAMBDa))((lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMBDa))(LAMbDA)))(LAMBDa)(LAMbDA)(lambda lAmBdA: lambda LAMBDa: lambda LAMbDA: LAMbDA)(lambda lAmBdA: (lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(Lambda((lambda LAMBDa: lambda LAMbDA: LAMbDA(lambda lAMBDA: lambda Lambda: lambda LAMBDA: lAMBDA(lambda LAmbda: lambda lambdah: lambdah(LAmbda(Lambda)))(lambda lAmBdA: LAMBDA)(lambda LAMBDA: LAMBDA))(LAMBDa))(LAMBDa)(LAMbDA))(LAMbDA)))(lambda LAMBDa: lambda LAMbDA: LAMbDA)))(LAMbda)(lambda LAMBDa: lambda LAMbDA: LAMBDa(LAMBDa(LAMbDA))))((lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(lamBDA)))(lambda LAMBDa: lambda LAMbDA: LAMbDA)))(lambda LAMBDa: lambda LAMbDA: LAMbDA)(LAMBDa)(LAMbDA)(lambda LAMBDa: lambda LAMbDA: LAMbDA))(lambda LAMBDa: LAMBDa(lambda lAmBdA: lambda LAMBDa: lambda LAMbDA: LAMbDA)(lambda LAMBDa: lambda LAMbDA: LAMBDa))(lambda LAMBDa: lambda LAMbDA: lambda lAMBDA: LAMBDa(LAMbDA(lAMBDA))))(LAMbda(ord(lAmbda)))(LAMbda(ord(lAMbda)))))))((lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(lamBDA))))(LAMBDa.read(1))(LAMbDA.read(1)))(0)(lambda LAMBDa: lambda LAMbDA: LAMbDA))(open('./flag.txt'))(open(__file__))((lambda LaMbDa: ((lambda Lambda: ((lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))(lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda))))))(lambda Lambda: lambda LAMBDA: (lambda laMBDA: (LAMBDA if not laMBDA else Lambda((lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMBDA))))(LaMbDa.read(1000)))(lambda LAMBDa: lambda LAMbDA: LAMbDA))(open(__file__)))(lambda lAMBDA: ((lambda Lambda: ((lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda)))(lambda LAMBDA: Lambda(lambda LAMbda: LAMBDA(LAMBDA)(LAMbda))))))(lambda Lambda: lambda LAMBDA: (LAMBDA if (lambda lAMBDA: lAMBDA(lambda LAMBDA: LAMBDA+1)(0))(LAMBDA)==lAMBDA else Lambda((lambda lAMBDA: lambda LAMBDa: lambda LAMbDA: LAMBDa(lAMBDA(LAMBDa)(LAMbDA)))(LAMBDA))))(lambda LAMBDA: LAMBDA)))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/crypto/Relatively_Simple_Algorithm/rsa.py | ctfs/angstromCTF/2021/crypto/Relatively_Simple_Algorithm/rsa.py | from Crypto.Util.number import getStrongPrime
f = [REDACTED]
m = int.from_bytes(f,'big')
p = getStrongPrime(512)
q = getStrongPrime(512)
n = p*q
e = 65537
d = pow(e,-1,(p-1)*(q-1))
c = pow(m,e,n)
print("n =",n)
print("p =",p)
print("q =",q)
print("e =",e)
print("c =",c) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/crypto/Im_so_Random/chall.py | ctfs/angstromCTF/2021/crypto/Im_so_Random/chall.py | import time
import random
import os
class Generator():
DIGITS = 8
def __init__(self, seed):
self.seed = seed
assert(len(str(self.seed)) == self.DIGITS)
def getNum(self):
self.seed = int(str(self.seed**2).rjust(self.DIGITS*2, "0")[self.DIGITS//2:self.DIGITS + self.DIGITS//2])
return self.seed
r1 = Generator(random.randint(10000000, 99999999))
r2 = Generator(random.randint(10000000, 99999999))
query_counter = 0
while True:
query = input("Would you like to get a random output [r], or guess the next random number [g]? ")
if query.lower() not in ["r", "g"]:
print("Invalid input.")
break
else:
if query.lower() == "r" and query_counter < 3:
print(r1.getNum() * r2.getNum())
query_counter += 1;
elif query_counter >= 3 and query.lower() == "r":
print("You don't get more random numbers!")
else:
for i in range(2):
guess = int(input("What is your guess to the next value generated? "))
if guess != r1.getNum() * r2.getNum():
print("Incorrect!")
exit()
with open("flag", "r") as f:
fleg = f.read()
print("Congrats! Here's your flag: ")
print(fleg)
exit() | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/crypto/Substitution/chall.py | ctfs/angstromCTF/2021/crypto/Substitution/chall.py | #!/usr/bin/python
from functools import reduce
with open("flag", "r") as f:
key = [ord(x) for x in f.read().strip()]
def substitute(value):
return (reduce(lambda x, y: x*value+y, key))%691
print("Enter a number and it will be returned with our super secret synthetic substitution technique")
while True:
try:
value = input("> ")
if value == 'quit':
quit()
value = int(value)
enc = substitute(value)
print(">> ", end="")
print(enc)
except ValueError:
print("Invalid input. ")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/crypto/Keysar_v2/chall.py | ctfs/angstromCTF/2021/crypto/Keysar_v2/chall.py | import string
with open("key.txt", "r") as f:
shift = int(f.readline())
key = f.readline()
with open("flag.txt", "r") as f:
flag = f.read()
stdalph = string.ascii_lowercase
rkey = ""
for i in key:
if i not in rkey:
rkey += i
for i in stdalph:
if i not in rkey:
rkey += i
rkey = rkey[-shift:] + rkey[:-shift]
enc = ""
for a in flag:
if a in stdalph:
enc += rkey[stdalph.index(a)]
else:
enc += a
print(enc) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/crypto/Cache_Money/cachemoney.py | ctfs/angstromCTF/2021/crypto/Cache_Money/cachemoney.py | import itertools
from time import perf_counter_ns as timer
from time import monotonic_ns as timestamp
class Rijndael:
sbox = bytes.fromhex(
"637c777bf26b6fc53001672bfed7ab76ca82c97dfa5947f0add4a2af9ca472c0b7fd9326363ff7cc34a5e5f171d8311504c723c31896059a071280e2eb27b27509832c1a1b6e5aa0523bd6b329e32f8453d100ed20fcb15b6acbbe394a4c58cfd0efaafb434d338545f9027f503c9fa851a3408f929d38f5bcb6da2110fff3d2cd0c13ec5f974417c4a77e3d645d197360814fdc222a908846eeb814de5e0bdbe0323a0a4906245cc2d3ac629195e479e7c8376d8dd54ea96c56f4ea657aae08ba78252e1ca6b4c6e8dd741f4bbd8b8a703eb5664803f60e613557b986c11d9ee1f8981169d98e949b1e87e9ce5528df8ca1890dbfe6426841992d0fb054bb16"
)
sboxinv = bytes.fromhex(
"52096ad53036a538bf40a39e81f3d7fb7ce339829b2fff87348e4344c4dee9cb547b9432a6c2233dee4c950b42fac34e082ea16628d924b2765ba2496d8bd12572f8f66486689816d4a45ccc5d65b6926c704850fdedb9da5e154657a78d9d8490d8ab008cbcd30af7e45805b8b34506d02c1e8fca3f0f02c1afbd0301138a6b3a9111414f67dcea97f2cfcef0b4e67396ac7422e7ad3585e2f937e81c75df6e47f11a711d29c5896fb7620eaa18be1bfc563e4bc6d279209adbc0fe78cd5af41fdda8338807c731b11210592780ec5f60517fa919b54a0d2de57a9f93c99cefa0e03b4dae2af5b0c8ebbb3c83539961172b047eba77d626e169146355210c7d"
)
def __init__(self, key):
self.cache = {}
self.key = tuple(key)
keylen = len(key)
if keylen == 16:
self.rounds = 10
elif keylen == 24:
self.rounds = 12
elif keylen == 32:
self.rounds = 14
else:
raise ValueError("bad key length")
rcon = [(0, 0, 0, 0), (1, 0, 0, 0)]
for i in range(10):
rcon.append(self.Multiply((2, 2, 2, 2), rcon[-1]))
N = keylen // 4
w = []
for i in range(4 * (self.rounds + 1)):
if i < N:
w.append(self.key[4 * i :][:4])
elif i % N == 0:
w.append(
self.Add(
w[-N], self.Add(self.SubWord(self.RotWord(w[-1])), rcon[i // N])
)
)
elif N > 6 and i % N == 4:
w.append(self.Add(w[-N], self.SubWord(w[-1])))
else:
w.append(self.Add(w[-N], w[-1]))
self.roundkeys = tuple(w)
def instance_method_cache(f):
# lru_cache uses the same cache for every instance which kinda sucks
# so i made my own cache implementation
def wrapper(self, *args):
key = (f.__name__, *args)
try:
return self.cache[key][0]
except TypeError:
# deal with unhashable arguments
return f(self, *args)
except KeyError:
# remove the least recently used element
# dont want the cache blowing up
while len(self.cache.keys()) >= 300:
mintimestamp = timestamp()
keys = list(self.cache.keys())
lowest = -1
for i in range(len(keys)):
if self.cache[keys[i]][1] < mintimestamp:
mintimestamp = self.cache[keys[i]][1]
lowest = i
else:
continue
del self.cache[keys[lowest]]
ret = f(self, *args)
self.cache[key] = (ret, timestamp())
return ret
return wrapper
@instance_method_cache
def encrypt(self, m):
try:
return b"".join(
self.encrypt_block(m[i:][:16]) for i in range(0, len(m), 16)
)
except:
return b"Error"
@instance_method_cache
def decrypt(self, m):
try:
return b"".join(
self.decrypt_block(m[i:][:16]) for i in range(0, len(m), 16)
)
except:
return b"Error"
@instance_method_cache
def encrypt_block(self, block):
m = tuple(tuple(block[4 * i :][:4]) for i in range(4))
m = self.Add(self.roundkeys[:4], m)
for i in range(1, self.rounds):
m = tuple(self.SubWord(l) for l in m)
m = self.ShiftRows(m)
m = self.MixColumns(m)
m = self.Add(self.roundkeys[4 * i :][:4], m)
m = tuple(self.SubWord(l) for l in m)
m = self.ShiftRows(m)
m = self.Add(self.roundkeys[-4:], m)
return bytes(itertools.chain.from_iterable(m))
@instance_method_cache
def decrypt_block(self, block):
m = tuple(tuple(block[4 * i :][:4]) for i in range(4))
m = self.Add(m, self.roundkeys[-4:])
m = self.ShiftRowsInv(m)
m = tuple(self.SubWordInv(l) for l in m)
for i in range(self.rounds - 1, 0, -1):
m = self.Add(m, self.roundkeys[4 * i :][:4])
m = self.MixColumnsInv(m)
m = self.ShiftRowsInv(m)
m = tuple(self.SubWordInv(l) for l in m)
m = self.Add(m, self.roundkeys[:4])
return bytes(itertools.chain.from_iterable(m))
@instance_method_cache
def Add(self, x1, x2):
try:
return tuple(self.Add(i, j) for i, j in zip(x1, x2))
except TypeError:
return (x1 ^ x2) & 0xFF
@instance_method_cache
def Double(self, x):
return self.Add(x << 1, 0x11B >> (0x80 ^ x & 0x80))
@instance_method_cache
def Multiply(self, a, b):
try:
return tuple(self.Multiply(i, j) for i, j in zip(a, b))
except:
r = 0
while a:
r = self.Add(r, b >> ((~a & 1) << 3))
b = self.Double(b)
a >>= 1
return r
@instance_method_cache
def RotWord(self, l):
return l[1:] + l[:1]
@instance_method_cache
def RotWordInv(self, l):
return l[-1:] + l[:-1]
@instance_method_cache
def SubWord(self, l):
return tuple(self.sbox[i] for i in l)
@instance_method_cache
def SubWordInv(self, l):
return tuple(self.sboxinv[i] for i in l)
@instance_method_cache
def ShiftRows(self, m):
return (
(m[0][0], m[1][1], m[2][2], m[3][3]),
(m[1][0], m[2][1], m[3][2], m[0][3]),
(m[2][0], m[3][1], m[0][2], m[1][3]),
(m[3][0], m[0][1], m[1][2], m[2][3]),
)
@instance_method_cache
def ShiftRowsInv(self, m):
return (
(m[0][0], m[3][1], m[2][2], m[1][3]),
(m[1][0], m[0][1], m[3][2], m[2][3]),
(m[2][0], m[1][1], m[0][2], m[3][3]),
(m[3][0], m[2][1], m[1][2], m[0][3]),
)
@instance_method_cache
def MixColumns(self, m):
return tuple(
tuple(
self.Add(
self.Add(self.Multiply(2, m[i][j % 4]), m[i][(j + 3) % 4]),
self.Add(m[i][(j + 2) % 4], self.Multiply(3, m[i][(j + 1) % 4])),
)
for j in range(4)
)
for i in range(4)
)
@instance_method_cache
def MixColumnsInv(self, m):
return tuple(
tuple(
self.Add(
self.Add(
self.Multiply(14, m[i][j % 4]),
self.Multiply(9, m[i][(j + 3) % 4]),
),
self.Add(
self.Multiply(13, m[i][(j + 2) % 4]),
self.Multiply(11, m[i][(j + 1) % 4]),
),
)
for j in range(4)
)
for i in range(4)
)
from os import urandom
from flask import Flask, request, render_template, jsonify
import logging
log = logging.getLogger("werkzeug")
log.setLevel(logging.ERROR)
app = Flask(__name__)
flag = tuple(open("flag", "rb").read())
if len(flag) % 16 != 0:
flag = flag + (0,) * (16 - (len(flag) % 16))
key = open("key", "rb").read()
assert len(key) == 32
cipher = Rijndael(key)
flagenc = cipher.encrypt(flag).hex()
@app.route("/")
def home():
return render_template("index.html", flagenc=flagenc)
@app.route("/api/enc", methods=["POST"])
def encrypt():
m = tuple(request.json["a"])
if len(m) % 16 != 0:
m = m + (0,) * (16 - (len(m) % 16))
if request.json["secret"] not in ["secret128", "secret192", "secret256"]:
k = tuple(request.json["k"])
else:
k = key[
: {"secret128": 16, "secret192": 24, "secret256": 32}[
request.json["secret"]
]
]
try:
cipher = Rijndael(k)
except ValueError:
return jsonify({"result": "Invalid key", "time": 0})
start = timer()
enc = cipher.encrypt(m)
end = timer()
del cipher
return jsonify({"result": enc.hex(), "time": end - start})
@app.route("/api/dec", methods=["POST"])
def decrypt():
m = tuple(request.json["a"])
if len(m) % 16 != 0:
m = m + (0,) * (16 - (len(m) % 16))
if request.json["secret"] not in ["secret128", "secret192", "secret256"]:
k = tuple(request.json["k"])
else:
k = key[
: {"secret128": 32, "secret192": 48, "secret256": 64}[
request.json["secret"]
]
]
try:
cipher = Rijndael(k)
except ValueError:
return jsonify({"result": "Invalid key", "time": 0})
start = timer()
enc = cipher.decrypt(m)
end = timer()
del cipher
for i in range(0, len(flag), 16):
if flag[i : i + 16] in enc:
enc = enc.replace(flag[i : i + 16], b"")
return jsonify({"result": enc.hex(), "time": end - start})
app.run("0.0.0.0", 5000)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/crypto/Home_Rolled_Crypto/chall.py | ctfs/angstromCTF/2021/crypto/Home_Rolled_Crypto/chall.py | #!/usr/bin/python
import binascii
from random import choice
class Cipher:
BLOCK_SIZE = 16
ROUNDS = 3
def __init__(self, key):
assert(len(key) == self.BLOCK_SIZE*self.ROUNDS)
self.key = key
def __block_encrypt(self, block):
enc = int.from_bytes(block, "big")
for i in range(self.ROUNDS):
k = int.from_bytes(self.key[i*self.BLOCK_SIZE:(i+1)*self.BLOCK_SIZE], "big")
enc &= k
enc ^= k
return hex(enc)[2:].rjust(self.BLOCK_SIZE*2, "0")
def __pad(self, msg):
if len(msg) % self.BLOCK_SIZE != 0:
return msg + (bytes([0]) * (self.BLOCK_SIZE - (len(msg) % self.BLOCK_SIZE)))
else:
return msg
def encrypt(self, msg):
m = self.__pad(msg)
e = ""
for i in range(0, len(m), self.BLOCK_SIZE):
e += self.__block_encrypt(m[i:i+self.BLOCK_SIZE])
return e.encode()
key = binascii.unhexlify("".join([choice(list("abcdef0123456789")) for a in range(Cipher.BLOCK_SIZE*Cipher.ROUNDS*2)]))
with open("flag", "rb") as f:
flag = f.read()
cipher = Cipher(key)
while True:
a = input("Would you like to encrypt [1], or try encrypting [2]? ")
if a == "1":
p = input("What would you like to encrypt: ")
try:
print(cipher.encrypt(binascii.unhexlify(p)).decode())
except:
print("Invalid input. ")
elif a == "2":
for i in range(10):
p = "".join([choice(list("abcdef0123456789")) for a in range(64)])
print("Encrypt this:", p)
e = cipher.encrypt(binascii.unhexlify(p)).decode()
c = input()
if e != c:
print("L")
exit()
print("W")
print(flag.decode())
elif a.lower() == "quit":
print("Bye")
exit()
else:
print("Invalid input. ")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/crypto/Follow_the_Currents/source.py | ctfs/angstromCTF/2021/crypto/Follow_the_Currents/source.py | import os
import zlib
def keystream():
key = os.urandom(2)
index = 0
while 1:
index+=1
if index >= len(key):
key += zlib.crc32(key).to_bytes(4,'big')
yield key[index]
ciphertext = []
with open("plain","rb") as f:
plain = f.read()
assert b"actf{" in plain
k = keystream()
for i in plain:
ciphertext.append(i ^ next(k))
with open("enc","wb") as g:
g.write(bytes(ciphertext)) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/crypto/Oracle_of_Blair/server.py | ctfs/angstromCTF/2021/crypto/Oracle_of_Blair/server.py | from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
import os
key = os.urandom(32)
flag = open("flag","rb").read()
while 1:
try:
i = bytes.fromhex(input("give input: "))
if not i:
break
except:
break
iv = os.urandom(16)
inp = i.replace(b"{}", flag)
if len(inp) % 16:
inp = pad(inp, 16)
print(
AES.new(key, AES.MODE_CBC, iv=iv).decrypt(inp).hex()
) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/crypto/Circle_of_Trust/gen.py | ctfs/angstromCTF/2021/crypto/Circle_of_Trust/gen.py | import random
import secrets
import math
from decimal import Decimal, getcontext
from Crypto.Cipher import AES
BOUND = 2 ** 128
MULT = 10 ** 10
getcontext().prec = 50
def nums(a):
b = Decimal(random.randint(-a * MULT, a * MULT)) / MULT
c = (a ** 2 - b ** 2).sqrt()
if random.randrange(2):
c *= -1
return (b, c)
with open("flag", "r") as f:
flag = f.read().strip().encode("utf8")
diff = len(flag) % 16
if diff:
flag += b"\x00" * (16 - diff)
keynum = secrets.randbits(128)
ivnum = secrets.randbits(128)
key = int.to_bytes(keynum, 16, "big")
iv = int.to_bytes(ivnum, 16, "big")
x = Decimal(random.randint(1, BOUND * MULT)) / MULT
for _ in range(3):
(a, b) = nums(x)
print(f"({keynum + a}, {ivnum + b})")
cipher = AES.new(key, AES.MODE_CBC, iv=iv)
enc = cipher.encrypt(flag)
print(enc.hex())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/web/Ekans/db.py | ctfs/angstromCTF/2021/web/Ekans/db.py | import pickle
import base64
import io
import os
POKEMON = {id: (os.environ.get('FLAG', 'flag{TEST}') if id == 1337 else 'EKANS') for id in range(2000)}
USERS = {'guest': 'guest', 'PokeMaster3000': os.environ.get('ADMIN_PASSWORD', '<secret>')}
ADMINS = ['PokeMaster3000']
class User:
admin = False
def __init__(self, username='guest', password='guest'):
self.username = username
self.password = password
if username in ADMINS: self.admin = True
def is_admin(self): return self.authenticated() and self.admin
def authenticated(self): return self.password == USERS.get(self.username)
class SafeUnpickler(pickle.Unpickler):
def find_class(self, module, name):
if module == "db" and name == "User": return User
raise pickle.UnpicklingError(f"HACKING DETECTED")
load_user = lambda request: SafeUnpickler(io.BytesIO(base64.b64decode(request.cookies['user'].encode('utf-8')))).load()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/web/Ekans/ekans.py | ctfs/angstromCTF/2021/web/Ekans/ekans.py | from flask import Flask, request, redirect, make_response
import importlib
import pickle
import base64
app = Flask(__name__)
header = """<title>POKEDEX</title>
<style>
* { font-family: sans-serif }
ul {
padding: 0;
display: flex;
flex-wrap: wrap;
list-style: none;
justify-content: center;
}
li {
height: 5em;
width: 5em;
text-align: center;
line-height: 5em;
background-image: url(https://cdn.bulbagarden.net/upload/thumb/b/b3/Vermilion_Forest_Ekans.png/250px-Vermilion_Forest_Ekans.png);
background-size: cover;
background-repeat: no-repeat;
background-position: center;
margin: 1em;
border: 2px solid black;
}
html {
background: url(https://wallpaperaccess.com/full/45634.png);
background-size: cover;
background-position: center;
background-attachment: fixed;
}
body {
text-align: center;
}
h1 {
text-align: center;
margin-top: 1em;
}
form {
text-align: center;
}
</style>"""
@app.route('/', methods=['GET', 'POST'])
def pokedex():
db = importlib.util.find_spec('db').loader.load_module('db')
if request.method == "POST":
response = make_response(redirect('/'))
response.set_cookie('user', base64.b64encode(pickle.dumps(db.User(request.form.get('username'), request.form.get('password')))))
return response
if 'user' not in request.cookies:
return header+'<h1>Log in to access your pokedex: </h1><form method="POST"><input type="text" name="username" placeholder="Username"> <input type="text" name="password" placeholder="Password"> <button>Log In</button></form>'
if db.load_user(request).is_admin(): return header+'<h1>ADMINISTRATOR PANEL</h1><img src="https://thumbs.gfycat.com/CarefulConcreteAsianwaterbuffalo-max-1mb.gif">'
if not db.load_user(request).authenticated(): return header+'<h1>INVALID CREDENTIALS</h1><img src="https://thumbs.gfycat.com/DefiantTanImago-small.gif">'
return header+'<h1>POKEDEX</h1><ul><li>'+'<li>'.join(p[1] for p in db.POKEMON.items() if p[0] != 1337 or db.load_user(request).is_admin())+'</ul>'
if __name__ == '__main__': app.run(threaded=True)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/web/Spoofy/app.py | ctfs/angstromCTF/2021/web/Spoofy/app.py | from flask import Flask, Response, request
import os
from typing import List
FLAG: str = os.environ.get("FLAG") or "flag{fake_flag}"
with open(__file__, "r") as f:
SOURCE: str = f.read()
app: Flask = Flask(__name__)
def text_response(body: str, status: int = 200, **kwargs) -> Response:
return Response(body, mimetype="text/plain", status=status, **kwargs)
@app.route("/source")
def send_source() -> Response:
return text_response(SOURCE)
@app.route("/")
def main_page() -> Response:
if "X-Forwarded-For" in request.headers:
# https://stackoverflow.com/q/18264304/
# Some people say first ip in list, some people say last
# I don't know who to believe
# So just believe both
ips: List[str] = request.headers["X-Forwarded-For"].split(", ")
if not ips:
return text_response("How is it even possible to have 0 IPs???", 400)
if ips[0] != ips[-1]:
return text_response(
"First and last IPs disagree so I'm just going to not serve this request.",
400,
)
ip: str = ips[0]
if ip != "1.3.3.7":
return text_response("I don't trust you >:(", 401)
return text_response("Hello 1337 haxx0r, here's the flag! " + FLAG)
else:
return text_response("Please run the server through a proxy.", 400)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/web/Reaction.py/server.py | ctfs/angstromCTF/2021/web/Reaction.py/server.py | from flask import escape, session, request, Flask, redirect
from collections import Counter
import uuid
import string
from functools import wraps
from threading import Lock
import subprocess
import json
import requests
# exceptions bad results good
OK = 1
ERR = 2
SAFECHARS = set(string.ascii_letters + string.digits + "_")
# templating engines are for chumps
STYLESHEET = """
body {
background-color: black;
}
* {
font-family: monospace;
color: white;
font-size: 18px;
}
form {
display: flex;
flex-direction: column;
justify-content: center;
align-items: center;
width: 100%;
}
input {
width: 50%;
background: none;
border-width: 0 0 1px 0;
border-color: white;
border-style: solid;
margin-bottom: 10px;
}
input::placeholder {
color: #9e9e9e;
}
input[type=submit] {
width: 20%;
border-width: 1px;
cursor: pointer;
}
p {
text-align: center;
}
.error {
color: #f44336;
}
a {
color: #4dd0e1;
}
""".strip()
PAGE_TEMPLATE = f"""
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Reaction.py demo</title>
<style>{STYLESHEET}</style>
</head>
<body>$$BODY$$<script src="https://www.google.com/recaptcha/api.js" async defer></script></body>
</html>
""".strip()
LOGIN_PAGE = PAGE_TEMPLATE.replace(
"$$BODY$$",
"""
<form action="/login" method="POST">
$$ERROR$$
<a href="/register">Register instead</a>
<input type="text" name="username" placeholder="username">
<input type="password" name="pw" placeholder="password">
<input type="submit" value="login">
</form>
""".strip(),
)
REGISTER_PAGE = PAGE_TEMPLATE.replace(
"$$BODY$$",
"""
<form action="/register" method="POST">
$$ERROR$$
<a href="/login">Login instead</a>
<input type="text" name="username" placeholder="username">
<input type="password" name="pw" placeholder="password">
<input type="submit" value="login">
</form>
""".strip(),
)
with open("secret.txt", "r") as f:
admin_password = f.read().strip()
with open("flag.txt", "r") as f:
flag = f.read().strip()
with open("captcha.json", "r") as f:
captcha = json.load(f)
accounts = {
"admin": {
"username": "admin",
"pw": admin_password,
"bucket": [f"<p>{escape(flag)}</p>"],
"mutex": Lock(),
}
}
def add_component(name, cfg, bucket):
if not name or not cfg:
return (ERR, "Missing parameters")
if len(bucket) >= 2:
return (ERR, "Bucket too large (our servers aren't very good :((((()")
if len(cfg) > 250:
return (ERR, "Config too large (our servers aren't very good :((((()")
if name == "welcome":
if len(bucket) > 0:
return (ERR, "Welcomes can only go at the start")
bucket.append(
"""
<form action="/newcomp" method="POST">
<input type="text" name="name" placeholder="component name">
<input type="text" name="cfg" placeholder="component config">
<input type="submit" value="create component">
</form>
<form action="/reset" method="POST">
<p>warning: resetting components gets rid of this form for some reason</p>
<input type="submit" value="reset components">
</form>
<form action="/contest" method="POST">
<div class="g-recaptcha" data-sitekey="{}"></div>
<input type="submit" value="submit site to contest">
</form>
<p>Welcome <strong>{}</strong>!</p>
""".format(
captcha.get("sitekey"), escape(cfg)
).strip()
)
elif name == "char_count":
bucket.append(
"<p>{}</p>".format(
escape(
f"<strong>{len(cfg)}</strong> characters and <strong>{len(cfg.split())}</strong> words"
)
)
)
elif name == "text":
bucket.append("<p>{}</p>".format(escape(cfg)))
elif name == "freq":
counts = Counter(cfg)
(char, freq) = max(counts.items(), key=lambda x: x[1])
bucket.append(
"<p>All letters: {}<br>Most frequent: '{}'x{}</p>".format(
"".join(counts), char, freq
)
)
else:
return (ERR, "Invalid component name")
return (OK, bucket)
def register(username, pw):
if not username or not pw:
return (ERR, "Missing parameters")
if len(username) > 15 or any(x not in SAFECHARS for x in username):
return (ERR, "Bad username")
if username in accounts:
return (ERR, "User already exists")
(t, v) = add_component("welcome", username, [])
if t == ERR:
return (ERR, v)
accounts[username] = {
"username": username,
"pw": pw, # please don't use your actual password
"bucket": v,
"mutex": Lock(),
}
return (OK, username)
def login(username, pw):
if not username or not pw:
return (ERR, "Missing parameters")
if username not in accounts:
return (ERR, "Username and password don't match")
if pw != accounts[username]["pw"]:
return (ERR, "Username and password don't match")
return (OK, username)
def reset(user):
del user["bucket"][:]
return (OK, ())
app = Flask(__name__)
app.secret_key = uuid.uuid4().hex
def mustlogin(route):
@wraps(route)
def ret():
if request.cookies.get("secret") == admin_password:
fakeuser = request.args.get("fakeuser")
if fakeuser:
return route(user=accounts[fakeuser])
if "username" not in session or session["username"] not in accounts:
return redirect("/login", code=302)
return route(user=accounts[session["username"]])
return ret
@app.route("/", methods=["GET"])
@mustlogin
def home(user):
return PAGE_TEMPLATE.replace("$$BODY$$", "".join(user["bucket"]))
@app.route("/login", methods=["GET"])
def login_page():
return LOGIN_PAGE.replace("$$ERROR$$", "")
@app.route("/login", methods=["POST"])
def login_post():
(t, v) = login(request.form.get("username"), request.form.get("pw"))
if t == ERR:
return (LOGIN_PAGE.replace("$$ERROR$$", f"""<p class="error">{v}</p>"""), 400)
session["username"] = v
return redirect("/", code=302)
@app.route("/register", methods=["GET"])
def register_page():
return REGISTER_PAGE.replace("$$ERROR$$", "")
@app.route("/register", methods=["POST"])
def register_post():
(t, v) = register(request.form.get("username"), request.form.get("pw"))
if t == ERR:
return (
REGISTER_PAGE.replace("$$ERROR$$", f"""<p class="error">{v}</p>"""),
400,
)
session["username"] = v
return redirect("/", code=302)
@app.route("/reset", methods=["POST"])
@mustlogin
def reset_post(user):
if user["username"] == "admin":
return ("Cannot reset admin", 400)
(t, v) = reset(user)
if t == ERR:
return (
PAGE_TEMPLATE.replace("$$BODY$$", f"""<p class="error">{v}</p>"""),
400,
)
return redirect("/", code=302)
@app.route("/newcomp", methods=["POST"])
@mustlogin
def new_component_post(user):
with user["mutex"]:
(t, v) = add_component(
request.form.get("name"), request.form.get("cfg"), user["bucket"]
)
if t == ERR:
return (
PAGE_TEMPLATE.replace("$$BODY$$", f"""<p class="error">{v}</p>"""),
400,
)
return redirect("/", code=302)
@app.route("/contest", methods=["POST"])
@mustlogin
def contest_submission(user):
captcha_response = request.form.get("g-recaptcha-response")
if not captcha_response:
return ("Please complete the CAPTCHA", 400)
secretkey = captcha.get("secretkey")
if secretkey:
r = requests.post(
"https://www.google.com/recaptcha/api/siteverify",
data={"secret": secretkey, "response": captcha_response},
).json()
if not r["success"]:
return ("Invalid CAPTCHA", 400)
subprocess.run(
["node", "visit.js", user["username"]],
# stdout=subprocess.DEVNULL,
# stderr=subprocess.DEVNULL,
stdin=subprocess.DEVNULL,
)
return PAGE_TEMPLATE.replace(
"$$BODY$$",
"""<p>The admin should have reviewed your submission. <a href="/">Back to homepage</a></p>""",
)
if __name__ == "__main__":
app.run(port=8080, debug=False, host="0.0.0.0", threaded=True)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2021/web/Jar/jar.py | ctfs/angstromCTF/2021/web/Jar/jar.py | from flask import Flask, send_file, request, make_response, redirect
import random
import os
app = Flask(__name__)
import pickle
import base64
flag = os.environ.get('FLAG', 'actf{FAKE_FLAG}')
@app.route('/pickle.jpg')
def bg():
return send_file('pickle.jpg')
@app.route('/')
def jar():
contents = request.cookies.get('contents')
if contents: items = pickle.loads(base64.b64decode(contents))
else: items = []
return '<form method="post" action="/add" style="text-align: center; width: 100%"><input type="text" name="item" placeholder="Item"><button>Add Item</button><img style="width: 100%; height: 100%" src="/pickle.jpg">' + \
''.join(f'<div style="background-color: white; font-size: 3em; position: absolute; top: {random.random()*100}%; left: {random.random()*100}%;">{item}</div>' for item in items)
@app.route('/add', methods=['POST'])
def add():
contents = request.cookies.get('contents')
if contents: items = pickle.loads(base64.b64decode(contents))
else: items = []
items.append(request.form['item'])
response = make_response(redirect('/'))
response.set_cookie('contents', base64.b64encode(pickle.dumps(items)))
return response
app.run(threaded=True, host="0.0.0.0")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2018/crypto/Very_ez_cipher/feistel.py | ctfs/angstromCTF/2018/crypto/Very_ez_cipher/feistel.py | #!/usr/bin/python3
#key = 0xXXXXXXXXXXXXX
size = len(bin(key)[2:])
def F(left, right, key):
newR = (((right^key)>>3) + (((right^key)&7)<<(size//2-3))) ^ 0x3ffffff
return (right, left^newR)
def encrypt(block, key):
key0 = key>>size//2
key1 = key & int('1'*(size//2),2)
L = block>>size//2
R = block & int('1'*(size//2),2)
for i in range(128):
L,R = F(L,R,key0)
L,R = F(L,R,key1)
return (L<<size//2)+R
while True:
pt = int(input("Enter a block of plaintext (as hex, at most 13 chars) that you would like to encrypt: ")[:9],16)
ct = encrypt(pt,key)
print("Here is the ciphertext:", (hex(ct)[2:]).zfill(size//4))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2018/crypto/Randomized_Cipher/great_cipher.py | ctfs/angstromCTF/2018/crypto/Randomized_Cipher/great_cipher.py | #!/usr/bin/python3
#key = b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
import random
def genPBox():
output = list(range(32))
while output == list(range(32)):
random.shuffle(output)
return output
def genSBox():
output = []
poss = list(range(16))
while poss == list(range(16)):
random.shuffle(poss)
for i in range(4):
output.append([0 for i in range(4)])
for j in range(4):
output[i][j] = poss[i*4+j]
return output
def P(block, permute):
binary = bin(int.from_bytes(block, byteorder="big"))[2:].zfill(32)
output = [0 for i in range(32)]
for i in range(32):
output[permute[i]] = binary[i]
return int("".join(output),2).to_bytes(4, byteorder="big")
def S(block, sub):
blockHex = bytes.hex(block).zfill(8)
output = ""
for i in range(8):
binary = bin(int(blockHex[i],16))[2:].zfill(4)
outer = int(binary[0] + binary[3],2)
inner = int(binary[1] + binary[2],2)
output += hex(sub[i][outer][inner])[2:]
return bytes.fromhex(output)
def mix(block,key):
end = b""
for i in range(len(block)):
end += (block[i]^key[i]).to_bytes(1, byteorder="big")
return end
def Eround(block,key,pBox,sBox):
output = mix(block,key)
output = S(output,sBox)
output = P(output,pBox)
return output
def encrypt(block,keys,rounds,pBox,sBox):
current = block
for i in range(rounds-1):
current = Eround(current,keys[i],pBox,sBox)
current = mix(current,keys[-1]) #so that last round can"t be reversed
return current
def oracle(key, inText, rounds, mode, pBox=None, sBox=None):
#not a very good padding scheme
while len(inText) % 4 != 0:
inText += b"\x00"
if len(key) != 4*rounds: return False
keys = [key[i:i+4] for i in range(0,len(key),4)]
if pBox == None: pBox = genPBox()
print("The permutation box is: ",pBox)
if sBox == None:
sBox = []
for i in range(8):
sBox.append(genSBox())
print("Substitution box ",i, " is: " , sBox[i])
output = b""
for i in range(0,len(inText),2):
output += encrypt(inText[i:i+4],keys,rounds,pBox,sBox)
return bytes.hex(output)
def main():
while True:
pt = input("Please enter the hex-encode string you would like to be encrypted: ")
if len(pt)%2 == 1:
pt = '0'+pt
pt = bytes.fromhex(pt)
ct = oracle(key,pt,8,'encrypt')
print("Here is the hex-encoded cipher text: " + ct)
main()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/angstromCTF/2018/crypto/ofb/encrypt.py | ctfs/angstromCTF/2018/crypto/ofb/encrypt.py | import struct
def lcg(m, a, c, x):
return (a*x + c) % m
m = pow(2, 32)
with open('lcg') as f:
a = int(f.readline())
c = int(f.readline())
x = int(f.readline())
d = open('flag.png').read()
d += '\x00' * (-len(d) % 4)
d = [d[i:i+4] for i in range(0, len(d), 4)]
e = ''
for i in range(len(d)):
e += struct.pack('>I', x ^ struct.unpack('>I', d[i])[0])
x = lcg(m, a, c, x)
with open('flag.png.enc', 'w') as f:
f.write(e)
f.close() | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.