arsenic 알쓰닉?

3D CAD 1차시: Fusion 360 간단한 기초 동작

arsenic-dev — Thu, 14 May 2026 07:15:28 +0900

경희대학교 중앙동아리 쿠러그의 3D CAD 강의를 기반으로 정리한 글입니다.

Fusion 360이란?

치수 기반의 3D CAD 프로그램으로

기구, 기계, 건축 등 설계 및 실제 제품 제작에 적합한 프로그램이다.

※ blender: 그래픽 작업을 위한 3D 프로그램으로 캐릭터, 애니메이션, 조형물 등 비정형 형상 모델링에 적합한 프로그램이다.

0. 환경 설정

Pan, Zoom, Orbit shortcuts는 특별히 사용하는 3D tool이 있는 게 아니라면, Tinkercad로 설정하는 걸 추천한다.

※ Reverse zoom direction 체크 이유: 마우스 휠 위로 올릴 때 확대, 아래로 하면 축소 등 우리가 기본적으로 아는 방식으로 사용하기 위함이다.

1. 스케치 생성

2. 화면 조작

3. 스케치 인터페이스

선 그리기 상태에서 delete를 누르면 선 그리기 도구가 해제되는데,

이때 구속을 원하는 선을 누른 후 D를 누르면 구속 설정이 가능하다.

또한, 구속된 선을 delete로 해제하면 점을 잡고 자유자재로 길이 조절이 가능하다. (구속 설정을 한 경우, 임의로 길이 조절 불가)

4. 사각형 도구

사각형의 경우 3점 사각형, 2점 사각형 등이 선택 가능하다.

사각형 외에 다른 도형도 이와 같이 옵션이 다양하다.

5. 요소 선택

도형 위치를 다른 곳으로 옮기고 싶은 경우엔,

드래그 or ctrl 을 통해 도형에 포함된 선을 모두 잡고 도형에 포함된 점 하나를 누른 상태로 이동하면 된다.

실습 과제

1. 직사각형 구속 조건 설정

2. 각도 구속

두 직선 사이의 각도 구속 조건을 넣고 싶을 때는 두 직선을 선택후 D를 누르면 된다.

참고자료

1. 오토데스크 교육용 플랜: 계정 생성 및 자격 확인 (자격 확인되면 1년간 사용 가능, 자격 유지되는 한 갱신 가능)

https://www.youtube.com/watch?v=zRhjGPa9uj8

2. 오토데스크 교육용 플랜: 제품 받기

https://www.youtube.com/watch?v=grAb6w6XK6o

Chapter 9: Heaps, Priority Queues, and Graphs

arsenic-dev — Sun, 14 Dec 2025 14:53:01 +0900

경희대학교 박제만 교수님의 자료구조 수업을 기반으로 정리한 글입니다.

Heap

A heap is a binary tree that satisfies these special SHAPE and ORDER properties:

Shape: Heaps' shape must be a complete binary tree. (위쪽, 왼쪽부터 채움)
Order: Parents value > Child values (MAX heap)

▶ Heap Example

Largest (Smallest) Value in a Heap -> root

BST와 Heap은 비슷한 듯 다르니, 구분할 수 있어야 한다.

Heap: 부모 >= 자식
BST: 왼쪽 서브트리 < 노드 < 오른쪽 서브트리

※ MAX heap <-> MIN heap

▶ Array Representation of Heaps

complete binary tree -> array! (minimized empty space)
위에서 아래로, 왼쪽에서 오른쪽으로 번호를 붙임

array이기에 linked structure로 구현한 것에 비해 확장성이 떨어진다.

Heap Operations

Insert a New Node

▶ Logical Level - insertItem(65)

1. Insert the new element in the next bottome leftmost place -> shape 만족
2. Fix the heap property by calling ReheapUp -> order 만
- If heap property is violated (chile> parent) -> Swap nodes

▶ reheapUp() - Implementation Level

root: root의 idx
boottom_id: 현재 비교하는 값의 idx

Why Do We Need a Heap?

find max (or min) in root -> O(1)
e.g., priority queue

※ 메모리 공간 heap 과는 아무런 상관이 없다. (just 이름만 같음)

※ priority_dequeue()

template<class ItemType>
bool QueueType<ItemType>::priority_dequeue(ItemType& ret) { // 원형큐의 경우 에러 발생 시 -> % maxQueue 했는지 확인
    if(isEmpty()){
        cout << "[ERROR] Queue is Empty. Dequeue Failed." << endl;
        return false;
    }
    
    int i = front;
    int min_index = (front + 1) % maxQueue; // front는 reserved_space이기에 + 1 해야 첫 번째 값임
    do {
        i = (i + 1) % maxQueue;
        if (data[min_index].priority > data[i].priority) {
            min_index = i;
        }
    } while (i != rear);

    ret = data[min_index];

    i = min_index;
    while (i != rear) {
        data[i] = data[(i + 1) % maxQueue];
        i = (i + 1) % maxQueue;
    }

    rear = (rear - 1 + maxQueue) % maxQueue; // 음수될 위험 방지
    
    return true;
}

Priority Queue

A priority queue is an ADT with the property that only the highest-priority element can be accessed at any time.

e.g., CPU task queue
- For tasks that require immediate processing (important interrupts) we can assign higher priorities.

▶ Priority Queue using a Array

time complexity to find a task with the highest priority: O(N)

Can we make it better?

Yes, use Heap!

▶ Priority Queue using a Heap

time complexity to find a task with the highest priority: O(1)

Get (remove) a Largest Value

▶ Logical Level

1. Copy the bottom rightmost item to the root
2. Delete the bottom rightmost node
3. Fix the heap property by calling ReheapDown
- Swap nodes if child > parent
- Compare with the lager child node (MAX heap)

▶ reheapDown() - Implementation Level

▶ PQType Definition

▶ HeapType Definition

items: 힙이 아이템을 보관하는 array
num_items: 아이템의 개수

▶ Constructor

▶ destructor & clear()

▶ enqueue()

▶ dequeue()

Big-O comparison

BST는 높이가 랜덤하지만, heap은 완전 이진 트리로 높이가 log N 으로 고정이기에 위와 같은 결과가 나오는 것이다.

heap의 enqueue는 reheapUp, dequeue는 reheapDown임

그리고 Sorted list의 경우는 array/linked structure, 오름차순/내림차순, 이렇게 4가지 경우의 수가 나올 수 있다.

enqueue: 모두 O(N)
dequeue
- array: 오름차순의 경우 O(1), 내림차순의 경우 O(N)
- linked structure: 오름차순의 경우 O(N), 내림차순의 경우 O(1)

이때, enqueue는 특정 item의 위치를 찾아 삽입하는 것이지만, dequeue는 맨 앞(max)의 값을 찾을 필요 없이 제거하니 주의한다.

또한, array의 경우 제거하거나 삽입할 때 한 칸씩 앞으로 당기거나 뒤로 미는 행위를 해야되니 주의해야 한다.

linked structure로 heap 구현 -> 시간복잡도 및 코드 알아야 함!!

Graph

▶ Graph

A data structure that consists of a set of nodes (vertices) and a set of edges that relate the nodes to each other.

THe set of edges describes relationships among the vertices.

Formal Definition

A graph G is defined as floolows:

G = (V, E)
- V(G): 한 개 이상의 유한한 개수의 노드 집합
- E(G): a sef of edges (pairs of veritces)

▶ Undirected Graph

the edges in a graph have no direction

▶ Directed Graph

the edges in a graph have direction

Directed Graph에서 E(G)를 정의할 때는 vertices의 순서가 중요하니 주의하여야 한다.

출발 -> 도착

▶ Tree

Trees are special cases of graphs.

Acyclic structure: 자기로부터 시작해서 다른 점을 돌아 자기 자신에게 돌아오는 것이 불가능

Terms

Adjacent nodes: 인접한 노드 (edge로 연결된 노드)
Path: 특정 노드로부터 다른 특정한 노드까지 이동할 때 지나가는 노드들의 순서
Complete graph: a graph in which every vertex is directly connected to every other vertex

▶ Complete Directed Graph

모든 노드들끼리 직접적으로 연결되어 있어야 함

What is the number of edges in a complete directed graph with N vertices?

N * (N-1)
nP2: 시작 정점 N가지 * 도착 정점은 자기 자신을 뺀 N-1가지

-> 공간 복잡도: O(N^2)

※ Big-O는 Upper Bound의 개념으로, 가장 최악의 상황을 감안했을 때의 estimate를 표현해준다. 그리고 이를 시간에 적용하면 시간 복잡도 혹은 메모리를 얼마나 사용하는지를 나타내기 위해 메모리에 적용하면 공간(space) 복잡도가 되는 것이다. 즉, "Big-O = 시간 복잡도"는 아니니 주의하여야 한다.

▶ Complete Undirected Graph

모든 노드들끼리 직접적으로 연결되어 있어야 함

What is the number of edges in a complete undirected graph with N vertices?

N * (N-1) / 2
nC2

-> 공간 복잡도: O(N^2)

▶ Weighted Graph

each edge carries a value

graph는 네트워크나 인공지능을 나타내어 분석하는 데에 효과적인 자료구조이다.

▶ Adjacency Matrix

0: edge 존재 X

We can use two matrices to represent a graph (컴퓨터가 이해하기 쉽게 나타냄)

A 1D array: to represent vertices
A 2D array (adjacency matrix): to represent the edges

▶ Adjacency List

We can also use a linked list (and on array) to represent a graph

A 1D array: to represent vertices
A linked list (adjacency list): to represent the edges

▶ Adjacency Matrix vs. List

E: edge
V: vertex

▶ GraphType Definition

mark: DFS, BFS 할 때 방문 여부를 담는 배열 -> 방문하면 true, 아직 방문 안 했으면 false

▶ Constructor

edge: 더블 포인터 (int 포인터를 가리키는 포인터) -> 2차원 배열
- edges는 int가 아닌 int*들의 배열 -> edges[i]가 i번째 행을 가리키는 포인터 (adjacency matrix)
- 행 할당: edges = new int* [maxVertices];
- 열 할당: for문 -> edges[i] = new int[maxVertices];

▶ Destructor

▶ addVertex()

새 정점을 vertices의 맨 끝에 넣음
새 정점과 "기존 정점들" 사이 간선 초기화

▶ addEdge()

▶ getVertexIndex()

▶ getWeight()

edges 이차원 배열이 adjacency matrix임

Graph Searching

두 노드를 연결하는 path를 찾는 것을 의미
Methods: Depth-First-Search (DFS) or Breadth-First-Search (BFS)

Depth-First Searching (DFS)

What is the idae behind DFS?

Visit all in a branch to its deepest point before moving up
Travel as far as you can down a path

DFS can be implemented efficiently using a stack.

Depth-first Searching (DFS)

▶ DFS uses STACK

1. Pop from Stack
2. Visit the popped coordinate (node)
3. Push the adjacent coordinates (nodes)
4. Repeat 1-3

-> 경로가 있구나! 판단

만약 경로가 없을 경우엔, end를 pop 하지 못했는데 어느 순간 스택이 비어버리게 된다.

-> 경로가 없구나! 판단

Why STACK?

⭐ 스택의 원리가 직전의 상태를 기억해 주는 역할을 하기 때문이다.

▶ DepthFirstSearch()

초기화
DFS
- pop the node
- endVertex에 도달하면 return true
- eddVertex에 도달하지 못했으면 push adjacents

▶ getAdjacents()

⭐ 경로의 합을 구하는 것과, 최단 경로 (weight) 구하는 것과, 경로 출력하는 함수도 만들어 볼 것!

Breadth-First Searching (BFS)

What is the idae behind BFS?

Visit all nodes on one level before going to the next level
Look at all possible paths at the same depth before you go at a deeper level

BFS can be implemented efficiently using a queue.

Breadth-First Searching (BFS)

▶ BFS uses QUEUE

1. Dequeue from Queue
2. Visit the dequeued coordinate (node)
3. Enqueue the adjacent coordinates (nodes)
4. Repeat 1-3

-> 경로가 있구나! 판단

만약 경로가 없을 경우엔, end를 dequeue 하지 못했는데 어느 순간 큐가 비어버리게 된다.

-> 경로가 없구나! 판단

Why QUEUE?

⭐ 찾아낸 경로가 효율적일 가능성이 BFS보다 높지만, 경로를 찾아내는 과정 자체는 비효율적이다. (DFS와 반대!)

▶ breadthFirstSearch()

⭐ 경로의 합을 구하는 것 해보기!!! (int 반환)

⭐ DFS, BFS 장단점 고민해볼 것!!

Shortest Path Problem

특정한 정점을 출발해서 다른 정점들로 갈 수 있는 최단 경로들의 값을 구해주는 방식

참고자료

https://arsenic-dev.tistory.com/68

Programming Exercise: Lab #3

경희대학교 박제만 교수님의 자료구조 수업을 기반으로 정리한 글입니다.Exercise #1ProblemsImplement rotateFirstItem() in Circular Queue with Reserved space.This function "ROTATES" the first item of the queue.▶ Both are OKAY (in

arsenic-dev.tistory.com

9-1. 소프트웨어 퍼징의 개념과 기술

arsenic-dev — Sun, 14 Dec 2025 03:25:24 +0900

경희대학교 장대희 교수님의 소프트웨어보안 수업을 기반으로 정리한 글입니다.

1. 기본 개념

Bug

소프트웨어 개발자의 실수

Software "Bug" e.g., 버퍼오버플로우

퍼징은 기본적으로 버그를 자동으로 찾고 싶은 것을 말한다.

이때 말하는 버그는 런타임 버그이다.

버그는 컴파일 버그와 런타임 버그가 있는데, 컴파일 버그는 소스 코드 작성 시 문법같은 거 틀렸을 때 발생하는 버그로, 애당초 이 버그로 인해 프로그램이 만들어지지도 않기에 문제가 되지 않음
런타임 버그: 소프트웨어 사용하는 시점에서 문제가 되는 버그

또한, 버그는 메모리 버그, 로직 버그 등 종류가 다양한데, 퍼저가 타겟하여 찾고자 하는 버그는 메모리 버그이다. (e.g. ,BOF)

물론, 고도화된 연구를 통해 로직 버그도 퍼징하는 게 존재하긴 함

버그의 발견이 흥미로운 이유 -> 해커들이 사고 팜

단순히 소프트웨어의 오작동을 유발하는 버그도 있지만, 해킹을 유발할 수 있는 구멍을 열어주는 버그도 있다.

때문에, 이런 파급력이 높은 버그를 막기 위해 퍼징이라는 기술을 통해 자동으로 버그를 찾고자 하는 것이다.

Fuzzing Basics

Input

퍼징 대상 프로그램에게 주는 입력 (Data) -> 해커가 조작할 수 있는 입력인 것이 중요

해커가 줄 법한 입력을 메모리에 넣고 복잡한 일을 하는 소프트웨어가 가장 퍼징을 하기 좋은 소프트웨어임

Corpus

Fuzzing에 사용되는 Input의 집합을 칭함

퍼징의 기본단계

프로그램이 crash 날 때까지 반복

1. Input 생성

어떻게 하면 "좋은 Input"을 생성할 수 있을까?

Dumb Fuzzing: 순수하게 Random Data 생성
Smart/Hybrid fuzzing: Random + @ 를 이용해서 버그 발견 확률을 증대

2. 프로그램 실행

어떻게 하면 "빠르게" 실행할까?

3. 결과 관찰

어떻게 하면 "Bug"를 놓치지 않을까?"

Fuzzing 분류

1. Black Box Fuzzing

프로그램 내부를 전혀 모른 채 입력값만 무작위로 계속 넣어보는 방식 (그래서 블랙박스 -> 아무것도 모른다!)

2. White Box Fuzzing

소스 코드와 내부 로직을 모두 알고 이를 기반으로 입력을 생성하는 방식

3. Gray Box Fuzzing

Black, White의 중간 방식으로 가장 많이 사용하는 방식이다.

: Instrumentation 기반 -> Coverage 측정

인스트루멘테이션: 실행 중 어떤 코드가 지나갔는지 기록하려고 프로그램에 계측(로그/표식) 코드를 심는 것
커버리지: 특정 입력을 넣었을 때 프로그램의 코드가 얼마나/어디까지 실행됐는지를 나타내는 지표

Input 생성에 기반한 분류

Generative vs Mutational

1. Generative Fuzzing

Input을 바닥부터 생성
- 프로그램의 input specification을 알아야 함
- Fuzzer가 empty set에서부터 input들을 생성함
장점
- Initial Corpus가 필요하지 않음 (샘플 필요 없다는 의미)
- 모든 경우를 균일하게 테스트 해갈 수 있음
단점
- mutation보다 input의 효율이 떨어짐: 놓치는 경우들이 많음

2. Mutational Fuzzing

Input을 정상적인 Sample로부터 Mutation(조금씩 변형 -> 돌연변이 input)
장점
- 일반적으로 Bug Trigger 효과가 뛰어남
- Input Specification에 대한 완전한 정보가 없어도 되므로 Generative 보다 구현이 쉬움
단점
- Initial Corpus의 수집 과정이 필요함
- Initial Corpus의 범주를 크게 벗어난 테스팅이 어려움

Address Sanitizer

구글에서 퍼징을 위해 만든 도구이다.

C언어에서 배열의 인덱스는 0번부터 시작하기에 100개의 element를 선언한 배열의 마지막 인덱스는 99이다.

하지만 100번을 참조했으니 건드리면 안 되는 남의 메모리 위치, 즉 버퍼를 넘어서 참조했기에 버그이다.

이때 문제인 것이, 명백한 버그임에도 이 버그를 가지고 있는 소프트웨어를 한 두 번 실행해가지고는 아무 일도 일어나지 않는다.

왜냐하면 페이징 때문이다.

CPU가 메모리에 접근할 때, 접근 순간마다 즉시 오류를 발생시키는 것이 아니라 페이지(Page)라는 단위를 기준으로 접근 권한을 검사한다. 메모리는 보통 4KB의 페이지로 나뉘어 있으며, 각 페이지마다 “읽기 가능”, “쓰기 가능”, “실행 가능”과 같은 권한이 설정된다.

따라서 배열의 99번째 요소에 정상적으로 읽기 또는 쓰기가 가능했다면, 그 바로 옆인 100번째 요소도 같은 페이지에 속해 있을 가능성이 높아 CPU는 이를 즉시 잘못된 접근으로 판단하지 않는다.

-> 때문에, 아무리 퍼징을 해도 버그가 안 잡히는데, 이를 해결하기 위한 도구가 address sanitizer[쎄니타이절]이다.

address sanitizer의 원리는 프로그램의 소스 코드가 바이너리로 컴파일 될 때 약간의 변형을 가하여 소프트웨어의 로직을 건들지는 않지만 메모리 접근시마다 무슨 검사를 하는 추가 로직을 집어 넣는다. (instrument)

버퍼 영역 벗어난 접근이다라는 판단이 서면 그 즉시 프로그램 중단

어드레스 새니타이저(AddressSanitizer)가 적용된 프로그램을 만들기 위해서는 소스 코드부터 다시 빌드해야 한다.

즉, 기존 실행 파일에 붙이는 것이 아니라 퍼징 전용으로 새롭게 컴파일하는 것이다.

이렇게 빌드된 프로그램은 실행 중 허용되지 않은 메모리 접근이 발생하면 지연 없이 즉시 오류를 감지한다.

오류가 발생하면 AddressSanitizer 관련 메시지가 출력되며, 어떤 종류의 메모리 오류인지, 어디에서 왜 문제가 발생했는지에 대한 상세한 로그와 스택 트레이스를 함께 제공한다.

-> 훨씬 효율적이고, 많은 버거들을 놓치지 않고 잘 잡아낼 수 있음

Corpus Pruning?

saturation: 포화

code coverage를 크게 하는 인풋이 좋은 인풋 -> bug trigger 할 확률 높은 인풋 -> 빨간색 제거!

이때, 어떤 걸 지우는 게 좋을지 판단하는 것을 coverage라는 개념을 통해 하게 된다.

coverage가 작은 녀석들을 지우는 게 기본 원리 or 중복 커버리지 갖는 인풋 지움

2. Coverage 기반 퍼징

퍼징에 유전 알고리즘을 적용

Coverage?

basic block, edge: 어셈블리의 레벨

즉, 커버리지는 프로그램이 실행된 정도를 표현하는 기준이다.

4개 중 주황색으로 표시된 3개의 블럭은 최소 한 번 이사 실행 흐름이 온 블럭이고, 하얀 블럭은 한 번도 실행된 적이 없음을 뜻함 -> block coverage는 75%

edge: 블록 간에 이동할 수 있는 라인 (자료구조에서 노드를 연결하는 엣지)

block보다 edge가 더 세밀하게 측량 가능하다.

-> 실제 현업에서 엣지 커버리지를 거의 기본으로 활용

그리고 block와 edge는 어셈블리만 가지고 표현이 되는 정보이기에 분석하는 소프트웨어의 소스 코드가 없이, 바이너리만 가지고도 다 얻을 수 있지만, line 같은 경우는 소스 코드가 몇 번째 줄까지 실행 됐느냐를 나타내기에 소스 코드가 없으면 알 수 없다.

-> line coverage로 퍼징을 하는 일은 거의 X, 대부분이 block, edge O

유전 알고리즘

퍼저 도구에서의 c의 main과 같은 함수

퍼저는 실행 경로(커버리지)를 보고 조건을 하나씩 통과하는 입력만 살아남게 하면서,

결국 크래시를 일으키는 입력(HI!)을 찾아낸다.

-> 1/(26*3) 경우로 찾을 수 있음 (선형, 지수에 비해 훨씬 빠른 시간 안에 해결)

만약, 커버리지 측정 안 하고 걍 랜덤으로 돌리면 1/26^3 경우로 찾을 수 있음 (지수)

AFL (American Fuzzy Lop)

초기 AFL 퍼저의 경우, 타겟 소프트웨어와 퍼저 소프트웨어가 독립적이었음

libFuzzer

초기부터, 퍼징 당하는 소프트웨어와 퍼징하는 소프트웨어가 독립적이지 않은 1개의 소프트웨어였음(In-Process), 산업계에서 실제로 많이 사용

3. Structured Input Fuzzing

연구 방향: 소스 코드를 트리 자료 구조로 변환하고, 이 자료 구조를 mutation 하는 식으로 퍼징함

4. Hybrid Fuzzing

퍼징에 분석 추가!

Data Flow Sanitizer: DFSan

데이터 -> 변수 영향 예측

특정 조건 만족되는 분기문 타려면 어떤 인풋? (방정식 푸는 기법)

5. Anti-Fuzzing

내 실수를 찾지 마라! -> 버그 못 찾게 함

6. Distributed Fuzzing

자동화 잘 되어 있다!

7-2. BoF Exploit 2

arsenic-dev — Sun, 14 Dec 2025 00:20:49 +0900

경희대학교 장대희 교수님의 소프트웨어보안 수업을 기반으로 정리한 글입니다.

보호 기법 3가지 (보호 옵션)

1. ASLR

Address Space Layout Randomization의 약자로, 실행 파일과 관련된 공유 라이브러리, 스택, 힙이 매핑되는 메모리 영역의 주소를 랜덤으로 배치하는 것을 말한다. ('영역' 단위로 랜덤화, e.g., stack, heap, libc)

ASLR이 활성화되어 있으면 7-1의 실습 2 처럼 점프할 주소를 직접 입력하는 행위는 불가능하다.

주소 leak을 통해 점프할 주소를 알아와야 하는 번거로움 발생
리눅스 설치시 자동으로 켜지는 보호 기법
브루트 포싱을 한다고 하더라도 같은 프로세스 안에서 계속해서 브루트 포싱을 하는 게 쉽지가 않음

cp: 복사 명령어

11~15행: main, secret 함수의 주소가 뭔지, 그리고 지금 할당한 버퍼의 주소가 뭔지에 대한 printf 함

이때 스택 주소는 랜덤화 되는데 함수 주소는 랜덤화가 안 되는 이유는,

aslr이 랜덤화 하는 단위는 '영역'이기 때문이다.

ASLR은 메모리 영역을 랜덤 위치에 배치하지만,

non-PIE 실행 파일의 코드 영역은 절대 주소로 고정되어 있어

ASLR만으로는 함수 주소를 랜덤화할 수 없다.

PIE를 사용해야 코드 영역도 ASLR의 대상이 된다.

2. NX

No-Execute bit의 약자로, 실행 가능한 메모리 영역이 아닌 스택, 힙과 같은 영역에서 코드가 실행되는 것을 막는 보호 기법이다.

"-z execstack" 옵션을 빼고 빌드 -> nx 활성화

NX bit가 활성화되어 있으면, 스택에 쉘코드를 업로드하여 실행시키는 행위는 불가능하다.

3. PIE [파이]

Position-Independent Executable의 약자로, 바이너리가 로딩될 때 main, secret 함수와 같은 각가지 주소들이 랜덤한 주소에 매핑되는 기법으로 바이너리를 실행할 때마다 바이너리의 주소가 랜덤화되게 한다.

스택의 RET 주소에 함수 주소를 직접 확인하고 넣는 것이 불가능해진다.

함수 주소를 알 수 있을 때 동적으로 삽입할 수 있는 기술 필요

추가로, -fno-stack-protector 이 옵션이 스택 카다리 관련 옵션이다.

BoF 실습

ASLR 활성화: 스택의 주소가 매번 변화하는 상황
NX bit 활성화: 스택에서 코드 실행이 불가능한 상황
PIE: 활성화: 매번 적재되는 함수의 주소가 달라지는 상황

즉, 스택에서 쉘코드 실행이나 임의 주소로 점프를 해서 무언가를 실행하는 게 불가능한 상황

get_shell() 함수를 호출할 수 있으면 시스템 쉘 획득 가능

바이너리 분석

함수 심볼 분석

readelf -> 함수 훑어보기

main, vuln, get_shell 함수가 존재하는 것을 확인 가능

pwndbg를 사용해 bof_sample2 분석

main 함수 분석

main 함수 내에서는 간단하게 vuln 함수를 호출하는 것을 확인 가능

main 함수는 vuln 함수 호출 외에 하는 게 없고, vuln이 핵심

secret 문제에서는 PIE가 비활성화되어 있어

disass에서 확인한 함수 주소가 실제 실행 주소와 동일했기 때문에

해당 주소로 직접 점프가 가능했다.

그러나 본 문제에서는 PIE가 활성화되어 있어

disass에서 확인되는 주소는 실제 실행 주소가 아닌 ELF 내부 오프셋이며,

프로그램 실행 시 base 주소가 결정되므로

주소 leak 없이는 해당 함수로 직접 점프할 수 없다.

주소 leak e.g., printf("%p", get_shell)

명령어 설명

$(명령): 괄호 안 명령을 먼저 실행 후, 그 출력 결과를 문자열로 바꿈
<<<: 문자열을 stdin으로 넣음

-> 일단, 기본적으로 main 함수의 스택이 얼만큼 벌어져 있는지, 내가 입력하고자 하는 그 버퍼로부터 rbp+8 이라는 return address가 얼만큼 떨어져 있는지를 디버깅을 통해 알아내야 한다.

그리고 get_shell의 주소가 매번 바뀌기에, 프로그램을 실행할 때마다 그 주소를 가지고 와서 passing을 통해 동적으로 페이로드를 작성할 수 있는 기술 스택이 있어야 한다.

-> 프로그램이 실행될 때 get_shell()의 주소를 알려주니, 그 정보를 이용해 코드를 작성해 get_shell()을 실행하고자 함

위아래 변수 추가시, payload 다시 계산 하는 연습

void vuln(){
  int x;          // 4바이트
  char buf[0x40]; // 64바이트
  long y;         // 8바이트 (x86-64에서 long=8)
  gets(buf);
}

buf만 있을 경우엔

buf = rbp-0x40
ret = rbp+8
거리 = 0x40 + 8 = 0x48

그런데 위 코드처럼 위아래로 변수를 추가하면 오프셋 값이 변경되어야 한다.

높은 주소
[rbp+8]   : return address   <-- 우리가 덮고 싶은 곳
[rbp+0]   : saved rbp
--------------------------------
[rbp-0x8] : (padding or y의 일부 위치일 수도)
[rbp-0x10]: y (8 bytes)
[rbp-0x14]: padding (정렬 맞추기)
[rbp-0x18]: x (4 bytes) + padding
[rbp-0x58] ~ [rbp-0x19]: buf[0x40] (64 bytes)
낮은 주소

위 배치에서 buf 시작이 rbp-0x58이면 거리 = 0x58 + 8 = 0x60

전체 흐름

1. 프로그램이 출력하는 주소를 받아서 (addr)
2. 그 주소를 정수로 파싱하고
3. offset만큼 채운 뒤
4. ret에 addr을 덮어 쓴 payload를 보내고
5. 쉘이 뜨면 interactive()로 직접 조작

b: 문자열을 바이너리로 받겠다는 의미

recvuntill(b"addr:"): "addr" 문자열이 나올 때까지 기다리겠다는 의미

recvline(): 한 줄 읽고,

decode(): 문자열로 변환하고,

strip(): 앞뒤 공백 자르고

-> line에 저장

쉘 획득 -> 서버 장악

7-1. BoF Exploit 1

arsenic-dev — Sat, 13 Dec 2025 18:50:58 +0900

경희대학교 장대희 교수님의 소프트웨어보안 수업을 기반으로 정리한 글입니다.

BoF (Buffer Overflow)

사용자의 입력 값에 대한 길일 검증을 하지 않아, 프로그래머가 할당한 크기의 버퍼보다 큰 데이터를 입력받아 메모리의 다른 영역을 오염시키는 취약점이다.

버퍼: 문자열을 입력받거나 특정 스택에서 공간을 할당 받는 곳

※ 버퍼는 임시 저장 곤간이고, 스택은 그 버퍼가 놓일 수 있는 여러 장소 중 하나이다.

1. 실습 준비

예제 코드 작성

vi bof_sample.c

gets 함수는 사용자의 입력 값에 대한 길이 제한이 없기에, 사용자는 프로그래머가 지정한 buf의 사이즈인 16 바이트를 넘어, 더 큰 입력을 입력할 수 있게 된다.

-> 스택에 할당된 16 바이트를 넘어서 return address까지 바꾸거나, 또는 그 이상의 행위를 할 수 있는 취약점

secret() 함수

main 함수에서 호출되지 않는 함수 -> stack buffer overflow를 이용해 강제 실행 가능
이 함수를 강제로 호출하는 것이 '실습 1'의 목표

※ vi 사용법

i (입력 시작)
exc (입력 탈출)
shift -> :wq (w: wrtie 저장 / q: 탈출 종료 0 -> vi 탈출 종료)

소스 코드 컴파일

: 초급 실습을 위해 모든 보호 기법 제거하여 컴파일

첫 번째 명령어 설명

gcc: C 컴파일러
bof_sample: 출력 파일 이름 (-o: output)
bof_sample.c: 컴파일 할 소스 코드 (방금 작성한 예제 코드)
-fno-stack-protector: 스택 보호 기법인 Stack Canary 비활성화
- canary: stack BOF 탐지 위해, 반환 주소 앞에 삽입되는 무결성 검사 값으로, canary 값이 변하면 BOF 발생으로 판단하여 프로그램을 즉시 종료함
-z execstack: 스택에 실행 권한 부여 (기본적으론 컴파일 시 실행 권한 부여 X)
-no-pie: PIE 비활성화 -> 실행 파일의 코드 주소가 고정되게 함

두 번째 명령어 설명

ASLR을 비활성화하는 옵션

※ PIE: Position Independent Executable의 약자로, 실행 파일을 위치 독립적으로 로드될 수 있게 만들어, ASLR이 적용될 때 실행 파일 코드도 매 실행마다 다른 주소에 배치될 수 있게 하는 기능이다.

ASLR: 공유 라이브러리의 위치를 랜덤화하여 ROP(Return Oriented Programming) 공격을 방지하기 위한 기술이다.
ROP: 정상적으로 존재하는 어셈블리 Return 조각들을 연결하여 악성 코드의 조합으로 만들어 실행한다.

컴파일 옵션 설명

⭐ 2. 실습 1: BOF를 이용하여 호출되지 않는 함수를 호출

Return Address 덮어 쓰기에 대한 이해

1. 소스 코드를 모른다는 가정하에 어떤 함수가 존재하는지 탐색

-s: symbol table 출력 옵션

디버그 모드로 컴파일을 하거나 심볼을 살려놓고 컴파일을 하게 되면 위와 같이 심볼들이 존재함
어떤 함수들이 존재하는지 미리 확인 가능
secret function이 존재하는 것을 확인할 수 있음

2. pwndbg를 사용해 bof_sample 분석 - main 함수 분석

디버거로 프로그램 실행 -> 메모리 확인 가능

disass main: main 함수의 assembly 코드 확인 가능

어셈블리 코드 설명

1. main 함수 진입
- push rbp: 이전 함수의 rbp 값을 스택에 저장(백업) -> 나중에 함수 끝나고 원래대로 되돌리기 위함
- mov rbp, rsp: 현재 스택 포인터 rsp를 프레임 포인터 rbp로 고정 -> 현재 함수의 기준점을 rbp로 잡음
- sub rsp, 0x10: 스택에 16바이트만큼 공간 확보
2. 첫 번째 printf 함수 호출 준비/호출
- lea rax, [rip+0xe8b]: rip+0xe8b에 있는 문자열의 주소를 rax에 넣음
- mov rdi, rax: printf의 첫 번째 인자 rdi에 주소값을 넣음 -> printf(0x40202e) 준비 완료
- mov eax, 0x0: eax를 0으로 맞춤 (관례)
- call 0x401070 <printf@plt>: printf 호출 (@plt는 실제 libc의 printf로 연결해주는 점프 테이블 PLT 경유 호출)
3. gets 함수 호출 준비/호출
- lea rax, [rbp-0x10]: 버퍼 시작 주소 rbp-0x10를 rax에 넣음 (확보한 16바이트 버퍼의 시작점)
- mov rdi, rax: gets의 첫 번째 인자 rdi에 버퍼 주소를 넣음 -> gets(buf) 준비 완료
- mov eax, 0x0: eax를 0으로 맞춤 (관례)
- call 0x401080 <gets@plt>: gets(buf) 실행
4. 두 번째 printf 함수 호출 준비/호출
- lea rax, [rbp-0x10]: 버퍼 주소를 rax에 로드
- mov rsi, rax: printf의 두 번째 인자 rsi에 버퍼 주소를 넣음
- lea rax, [rip+0xe6c]: 두 번째 printf에서 쓸 포맷 스트링 주소를 rax에 로드
- mov rdi, rax: printf 첫 번째 인자 rdi에 포맷 스트링 주소를 넣음
- mov eax, 0x0: eax를 0으로 맞춤 (관례)
- call 0x401070 <printf@plt>: printf(fmt, buf) 호출
5. 함수 종료 (리턴)
- mov eax, 0x0: main의 반환값을 0으로 설정 (return 0;)
- leave: mov rsp, rbp + pop rbp를 합친 축약 명령 -> 스택 프레임 정리 (로컬 공간 해제 + rbp 복원)
- ret: pop rip 축약 명령 -> 리턴 주소로 점프해서 함수 종료

스택에 할당된 공간은 0x10

-> gets 함수를 사용할 경우 입력에 대한 크기 검증을 하지 않아 스택이 덮어 써지게 됨 (BOF)

3. pwndbg를 사용해 bof_sample 분석 - 프로그램을 실행 시켜 스택보다 큰 입력을 주어 테스트

'A' 16개, 'B' 8개, 'C' 8개

스택보다 큰 값을 입력했을 때 SIGSEGV, Segmentation fault와 Invalid address ... 를 확인 가능

스택 BOF로 인해 rbp+8(Ret addr, 되돌아가야 할 주소)이 문자 'C'(0x42)로 덮어 써지면서 잘못된 주소로 인한 crash

※ rbp+8 == rip 인 것은, 'AAAAAAAAAAAAAAAABBBBBBBBCCCCCCCC'을 16바이트짜리 buf에 입력했을 때, B 8개는 rbp에, 그리고 C는 rip에 저장된 것을 보고 유추한 것이다.

rbp에 8개가 찬 후, 넘친 것은 rip에 저장 -> rbp는 8바이트이고, rbp 다음엔 rip가 오는구나!

-> 다른 함수를 호출하기 위한 아이디어

스택 BOF를 이용하여 return address(rip, 다음에 실행될 코드 주소)를 변조 시킬 수 있음
해당 행위를 위해서 main 함수 내의 스택의 상태를 알고 있어야 덮어 쓸 수 있음
secret 함수의 주소를 알고 있어야 함 -> 이 함수 주소를 강제로 rbp+8, 즉 return address에 넣어 강제 호출 가능

rbp, rsp 위치 동일

※ i r $rsp: info register $rsp

0x10만큼 stack에 할당받은 모습

rbp+8 즉, 0x7fffffffffffe108은 main 함수가 끝나고 돌아갈 주소가 담겨 있는 스택의 주소이다. (pop 하며 위로가며 읽음)

c: continue

rbp가 0x7fffffffffffe100 이므고, rax에는 0x7fffffffffffe0f0, 즉 현재 스택의 위치가 담긴다.

그래서 인자로는 스택의 첫 시작 주소를 넘겨주겠다는 의미이다.

$rbp+8: ret 주소 / $rsp: 스택 꼭대기 주소

-> 24개의 문자를 넣고, 그 다음에 원하는 주소를 넣게 되면 그 주소로 덮어 쓸 수 있다.

e0f0 ~ e108까지를 24개의 문자로 채움
그 다음이 ret 주소 부분

$rsp 보다는 인자로 사용한 $rbp-0x10을 사용하는 것이 더 정확함 (rsp는 변수가 하나일 때만 사용 가능)

리틀엔디안 -> 00 00 00 00 00 40 11 76

b* main+81: leave 명령어 실행 전 break

-ne: n은 맨 끝에 줄바꿈 \n을 붙이지 말라는 의미이고, e는 이스케이프 문자로 출력하라는 의미이다.

이때, PIE가 켜져 있으면 시크릿 주소가 매번 바뀌기에 위와 같은 방법 적용이 어렵다. (시크릿 주소로 점프 어려움)

참고로, secret 함수 호출이 끝나고 되돌아가려고 rbp를 보면 aaaaaaaa로 깨져 있기에, 프로그램이 죽는다. (crash)

3. 실습 2: 64비트 환경에서 Shell Code 실행

보호기법이 적용되지 않은 스택에 쉘코드를 어떻게 올리고 실행할 수 있는지

실제 공격자는 Shell Code를 스택에 적재하여 shell을 실행시키는 것을 목표로 함

스택 영역에서 실행 권한이 존재할 때
권한이 없다면 다른 기법을 사용해야 함

공격의 원리는 실습 1과 같으나, 어떻게 스택에 쉘코드를 적재하고 실행할지 고민 필요

0. 실습 준비

buf 크기:16바이트 -> 64바이트

1. 스택 영역의 실행 권한 확인

-l: loadable program headers(세그먼트) 목록을 출력하라는 옵션

Stack: Executable -> 스택에서 코드 실행시킬 수 있구나!

2. exploit 도구 pwntools 설치

3. shell code

buf address에는 이 주소를 사용해 돌아갈 주소를 지정하는 것인데, 돌아갈 주소의 경우 얻는 과정 생량 (사유: 넘 어렵)

-> 쉘 명령어 쓸 수 있게되면 성공!

특정 버퍼로 점프를 하게 되어 거기에 있는 쉘 코드를 실행하는 식이다.

이때 만약, alr이 켜져 있으면 계속 랜덤으로 되기에 원하는 주소로 점프하는 상황이 조금 어렵게 된다.

즉, aslr이 켜져 있을 때 정확한 위치로 점프하고 싶으면 다른 취약점이나 버퍼 오버플로우를 체이닝 하여 그 주소를 알아내야 하는 번거로움이 생긴다.

체이닝: 최종 공격에 필요한 정보/조건을 만들기 위해, 여러 취약점(또는 여러 단계의 페이로드)을 순서대로 연결해서 쓰는 것

8. Toyransome

arsenic-dev — Tue, 9 Dec 2025 01:16:42 +0900

경희대학교 장대희 교수님의 소프트웨어보안 수업을 기반으로 정리한 글입니다.

Ransomware 소개

Ransomware

Ransom(몸값)과 software(소프트웨어)의 합성어
시스템을 잠그거나 데이터를 암호화해 사용할 수 없도록 하고 이를 인질로 금전을 요구하는 악성 프로그램
신뢰할 수 없는 사이트, 스팸메일, 파일공유 사이트 등을 통해 유포됨
이렇게 특정한 경로로 피해자 PC에 접근을 한 후, 바이러스를 통해 피해자가 가지고 있는 파일들을 암호화 함

※ 실습과 달리, 현대의 암호화는 키 없이 복호화가 불가능하다.

랜섬웨어는 위와 같이 고유한 확장자와 함께 감염된 시스템 드라이브의 파일을 암호화한다. 암호화되면서 파일이 손상되어 정상적으로 실행하거나 읽을 수 없게 되고, 해커는 복호화 키에 대해 거액의 돈을 요구한다.

간단한 복호화 로직

xor 복호화

xor 연산은 비트 단위의 연산으로, 두 개의 비트를 비교하여 서로 다를 때 '1', 같을 때 '0'을 반환한다.

A = 1010, B = 1100 (이진수)
C = A ^ B = 1010 ^ 1100 = 0110 (암호화 과정, key = B)
A = C ^ B = A ^ B ^ B = A ^ 0 = A (복호화 과정, key = B)

-> xor 연산은 대칭적이며 같은 키를 이용하여 암호화와 복호화를 모두 수행할 수 있음

다중 암호화와 복호화

암호화를 여러 단계로 적용하였을 때, 복호화 과정은 암호화 한 순서의 역순으로 해독해야 한다.

※ xor 암호화는 순서 바꿔도 상관 없다.

실습

실습 목적

암호화되어 있는 파일 복호화
바이너리 파일을 분석하여 복호화 로직 구하여 평문 flag 획득

문제 접근 방식

toryransome2를 제외하고는 소스코드가 없음
따라서 리버스 엔지니어링을 통해 바이너리를 분석 후 flag 획득

1. toyransome2

문제 설명

주어진 소스코드 파일을 분석하여 암호화된 파일을 복호화하는 문제

파일 구성

flag.enc: 암호화된 flag 파일
toyransome2: 암호화 바이너리 파일
toyransome2.txt: 암호화 바이너리 파일의 소스코드 (C 언어)

ll -A: ls long all

target_file에 암호화 할 파일을 넣으면 됨

예시로 fake_flag.txt 파일을 만들어 암호화 한 모습

toyransome2.txt

toyransome2 바이너리에 타겟 파일을 넣으면 이 타겟 파일이 암호화되는 그런 로직이다.

타겟 파일을 읽어와 버퍼에 저장을 하고, key로 xor 암호화

※ 아스키 'A' = 0x41 = 0100 0001

먼저, fread 함수를 통해 buf에 타겟 파일을 담는다.

이때, fread의 반환 값은 읽은 바이트 수이기 때문에, r에는 파일의 길이가 담긴다.

r: flag_length

그리고 나서 flag_length만큼 for문이 돌면서 암호화를 진행한다.

※ main 함수의 인자

argc: 인자 개수
argv: 인자로 들어가는 내용
- e.g., argv[0] = "./toyransome2", argv[1] = "fake_flag.txt"

fp = fopen(strncat(argv[1], ".enc", 4), "wb+");

▶ argv[1] 뒤에 .enc를 붙여서 그 이름으로 바이너리(b) 파일을 새로 만들고(w) 읽기/쓰기 가능(+)하게 여는 코드

XOR로 암호화된 것을 복원하려면?

XOR로 암호화 된 것은 XOR로 복원하면 된다.

XOR 연산은 "A ^ B ^ B = A ^ 0 = A" 이렇게 상쇄되는 특징이 있기에, 이를 이용해 복호화하면 된다.

with open("flag.enc","rb") as f_ptr:
    flag_data =f_ptr.read()

flag_key="8C9031DB7A03F189"

flag_key=bytes.fromhex(flag_key)

plain_flag=b''

for i in range(len(flag_data)):
    plain_flag += bytes([flag_key[i%len(flag_key)]^flag_data[i]])

print(plain_flag)

16진수 표기에서 A~F 는 대소문자를 가리지 않으므로 복호화할 때 대문자로 써도 결과 바이트 값이 완전히 동일하게 나온다.

복호화 결과 1

혹은 한 번 더 xor, 즉 한 번 더 암호화 해주는 방식으로도 복호화가 가능하다.

복호화 결과 2

2. toyransome3

문제 설명

주어진 바이너리 파일을 분석하여 암호화된 파일을 복호화하는 문제

파일 구성

flag.enc: 암호화된 flag 파일
toyransome3: 암호화 바이너리 파일 (64bit ELF 파일 형식)

문제 풀이 팁

소스 코드 제공 X -> 리버스 엔지니어링을 통해 어셈블리 분석하는 기술 필요
IDA와 같은 리버싱 툴을 이용하여 어셈블리를 분석

int __fastcall main(int argc, const char **argv, const char **envp)
{
  char v3; // r12
  char v4; // r12
  char *v5; // rdx
  int i; // [rsp+10h] [rbp-1040h]
  int j; // [rsp+10h] [rbp-1040h]
  int v10; // [rsp+14h] [rbp-103Ch]
  int v11; // [rsp+14h] [rbp-103Ch]
  FILE *stream; // [rsp+18h] [rbp-1038h]
  FILE *streama; // [rsp+18h] [rbp-1038h]
  char ptr[16]; // [rsp+30h] [rbp-1020h] BYREF
  unsigned __int64 v15; // [rsp+1038h] [rbp-18h]

  v15 = __readfsqword(0x28u);
  if ( argc == 2 )
  {
    stream = fopen(argv[1], "rb");
    if ( stream )
    {
      v10 = fread(ptr, 1u, 0x1000u, stream);
      printf("%d bytes read\n", v10);
      for ( i = 0; i < v10; ++i )
      {
        v3 = ptr[i];
        ptr[i] = byte_204C[i % strlen(byte_204C)] ^ v3;
      }
      puts(ptr);
      for ( j = 0; j < v10; ++j )
      {
        v4 = ptr[j];
        ptr[j] = byte_2055[j % strlen(byte_2055)] ^ v4;
      }
      fclose(stream);
      v5 = (char *)argv[1];
      strcat(v5, ".enc");
      streama = fopen(v5, "wb+");
      v11 = fwrite(ptr, 1u, j, streama);
      printf("%d bytes encrypted\n", v11);
    }
    else
    {
      printf("can't open %s\n", argv[1]);
    }
  }
  else
  {
    puts("usage: ./toyransome3 [target_file]");
  }
  return __readfsqword(0x28u) ^ v15;
}

▶ IDA로 디컴파일 한 결과

toyransome3 vs toyransome4

toyransome2와 비교해 보면 가운데 for문만 다르다는 것을 알 수 있다.

toyransome2는 for문이 한 번 있고, toyransome3는 for문이 두 번 있어 암호화가 두 번 된 것이다.

key 값

첫 번째 XOR 연산의 key 값은 "8c9031db7a03f189"이고, 두 번째 XOR 연산의 key 값은 "c9330180f7"이다.

'1'의 아스키 코드 = 0x31
'z'의 아스키 코드 = 0x7a
'3'의 아스키 코드 = 0x33

다중 암호화의 경우 역순으로 해독해야 한다. 물론, xor의 특성상 교환 법칙이 성립하여 현재 코드에선 순서가 중요하지 않다.

toyransome2의 복호화 코드를 이용해 toyransome3의 복호화 코드를 짜면 다음과 같다.

with open("flag.enc","rb") as f_ptr:
    flag_data =f_ptr.read()

flag_key="c9330180f7"

flag_key=bytes.fromhex(flag_key)

plain_flag=b''

for i in range(len(flag_data)):
    plain_flag += bytes([flag_key[i%len(flag_key)]^flag_data[i]])

flag_key="8c9031db7a03f189"

flag_key=bytes.fromhex(flag_key)

for i in range(len(plain_flag)):
    plain_flag += bytes([flag_key[i%len(flag_key)]^plain_flag[i]])

print(plain_flag)

복호화 결과 1

xor 연산은 순서가 중요하지 않기에 다음과 같이 암호화를 그냥 한 번 더 하는 방식으로도 복호화가 가능하다.

복호화 결과 2

3. toyransome4

문제 설명

주어진 바이너리 파일을 분석하여 암호화된 파일을 복호화하는 문제

파일 구성

program.bin.enc: 암호화된 바이너리 파일 (Hint. 암호화 전 바이너리는 elf 파일)

IDA 상에서 바이너리를 열었을 때의 화면

⭐ 4. toyransome5

문제 설명

주어진 바이너리 파일을 분석하여 암호화된 파일을 복호화하는 문제

파일 구성

flag.enc: 암호화된 flag 파일
toyransome5: 암호화 바이너리 파일
- 안티리버싱이 적용되어 있어 어셈블리 언어로만 분석해야 함 (C 코드로 복원 불가)

문제 풀이 팁

IDA 분석 시도
- 함수 초반의 반복문으로 인해 스택 프레임이 커져서 IDA 헥스레이 기능 이용 불가능 (안티리버싱)
- 복호화된 코드가 아닌 어셈블리 분석 필요

※ 이렇게 안티리버싱과 같이 디컴파일 기능을 방해하는 이슈도 존재한다.

fopen, fread 그리고 fclose 사이 loc_1361과 loc_131F가 암호화하는 반복문임

핵심이 되는 basic block

instruction 설명

mov: 오른쪽에 있는 값을 왼쪽으로 넣음 (해당 코드에선 초기값 0)
cdqe: 32bits -> 64bits extension (알 필요 X)
movzx: 'fread'의 ptr이므로, ptr을 통해 파일 데이터를 0번부터 가져오는 것을 알 수 있음
add: 1을 더하는 것으로 보아, 반복문 한 번 끝날 때 마다 인덱스 하나가 증가할 때의 그 인덱스임을 알 수 있음 -> 네이밍

어셈블리 명령어를 해석하면 오른쪽으로 1비트만큼 시프트 한 값과 왼쪽으로 7번 시프트 한 값을 or 하는 게 로테이션 로직임을 알 수 있다. 결국, 이를 해석하면 총 8비트에서 맨 오른쪽 하위 비트가 젤 상위 비트로 올라오고 나머지 비트는 한 비트씩 밀리는, 로테이션식의 손실 없는 암호화 로직임을 알 수 있다.

그리고 그 값을 'dl' 레지스터를 이용해 다시 ptr로 넣는 것을 확인 할 수 있다.

어셈블리 명령어 정리

기본 데이터 이동 계열

mov – MOVe: 오른쪽 값(레지스터/메모리)을 왼쪽에 복사
movzx – MOV with Zero eXtend: 작은 크기 값을 큰 레지스터로 옮기면서 상위 비트를 0으로 채움
movsx – MOV with Sign eXtend: 작은 크기 값을 큰 레지스터로 옮기면서 부호비트를 유지해서 채움
cdqe – Convert Doubleword to Quadword Extended: EAX(32비트)를 RAX(64비트)로 부호 확장해서 변환 (32bit int → 64bit, 캐스팅(형 변환 느낌)

비트 연산/시프트 계열

sar – Shift Arithmetic Right: 오른쪽으로 n비트 쉬프트, 왼쪽 끝은 부호비트 그대로 유지 (나누기 2^n)
shl – SHift Left: 왼쪽으로 n비트 쉬프트, 오른쪽은 0으로 채움 (곱하기 2^n)
or – bitwise OR: 두 값의 비트를 OR 연산. 하나라도 1이면 1
xor – bitwise XOR (eXclusive OR): 두 비트가 다를 때만 1

산술/비교/분기 기본

add – ADD: 왼쪽 피연산자에 오른쪽 값을 더함
sub – SUBtract: 왼쪽 피연산자에서 오른쪽 값을 뺌
cmp – CoMPare: "왼쪽 - 오른쪽"을 계산해서 결과만 플래그에 기록하여 다음에 오는 점프의 조건을 결정
jmp – JuMP: 무조건 해당 라벨/주소로 점프
je / jne – Jump if Equal / Jump if Not Equal: 바로 전에 cmp한 결과가 같으면/다르면 점프
jg / jge – Jump if Greater / Jump if Greater or Equal: 비교 결과가 크다/크거나 같다이면 점프 (signed 기준)
jl / jle – Jump if Less / Jump if Less or Equal: 비교 결과가 작다/작거나 같다면 점프 (signed 기준)

※ RAX 계열 레지스터 크기별 이름

RAX: 전체 64비트
EAX: RAX의 하위 32비트
AX: RAX의 하위 16비트
AH: AX의 상위 8비트
AL: AX의 하위 8비트

복호화 코드는 다음과 같다.

with open("flag.enc", "rb") as f_ptr:
    enc_data = f_ptr.read()

plain = b''

for i in range(len(enc_data)):
    y = enc_data[i]       

    x = ((y << 1) & 0xFF) | (y >> 7) #0xFF과 & 하는 것은 하위 8비트만 남기고 나머지 비트는 전부 버리기 위함임

    plain += bytes([x])

print(plain)

오른쪽으로 쉬프트 연산을 해서 암호화 하였으면 왼쪽으로 쉬프트 연산을,

왼쪽으로 쉬프트 연산을 해서 암호화 하였으면 오른쪽으로 쉬프트 연산을 하여 복호화 한다.

복호화 결과

혹은, 순환형 구조이기 때문에 flag.enc를 7번 더 암호화하여 원래대로 돌려 놓는 식으로 복호화할 수도 있다.

'8비트 회전의 주기 = 8'을 이용한 복호화

레지스터 용도 정리

범용 레지스터: RAX/RBX/RCX/RDX/RSI/RDI/R8~R15

리턴값 및 시스템콜 번호 레지스터: RAX

RDI: destination index 레지스터 (1번째 인자)

RSI: source index 레지스터 (2번째 인자)

RBP: base pointer 레지스터 (현재 함수 스택 프레임 기준점)

RSP: stack pointer 레지스터 (스택의 최상단)

RIP: 프로그램 카운터 (현재 명령어 위치)

※ 현재는 64 bit 기준이기에 R~ 인 것이고, 32 bit 기준으로 하면 E~ 로 변경하면 된다.

5. toyransome6

문제 설명

주어진 바이너리 파일을 분석하여 암호화된 파일을 복호화하는 문제

파일 구성

flag.enc: 암호화된 flag 파일
toyransome6: 암호화 바이너리 파일

Hint. 핵심 basic block

instruction 설명

현재 인덱스를 eax로 가지고 옴 -> 해당 인덱스의 값을 edx에 담음
"eax - 1"을 통해 이전 인덱스를 eax로 가지고 옴 -> 이전 인덱스의 값을 eax에 담음
edx와 eax끼리 xor 연산을 함 -> 연산 결과를 edx에 저장
eax에 다시 현재 인덱스를 가지고 옴 -> 해당 값으로 현재 인덱스의 값을 업데이트 (암호화)

-> 암호화 로직: enc[n] = flag[n] ^ enc[n-1]

※ dl: edx의 하위 1바이트 (dl = edx & 0xFF)

여기까지 해석하면 현재 인덱스가 0일 때 이전 인덱스가 -1이 되어 OOB(Out Of Bound)가 발생한다는 것을 알 수 있다.

그래서 이 문제의 경우 핵심만 보는 것이 아닌 앞의 부분도 같이 봐야 한다.

이렇게 앞 부분을 확인해 보면 인덱스가 0이 아닌 1부터 시작하는 것을 알 수 있다.

그리고 인덱스 0의 경우엔 따로 암호화가 되어 있음을 확인할 수 있다.

enc[0] instruction 설명

인덱스를 0으로 초기화
[rbp+var_3E8034]에서 4바이트만큼 eax로 가지고 옴 -> eax 중 하위 1 바이트(al)만큼 key로 가지고 옴
0번째 인덱스의 값을 eax에 가지고 옴 -> key와 xor 연산을 함
xor 연산 결과를 eax에 저장 -> 해당 값으로 현재 인덱스의 값을 업데이트 (암호화)

-> enc[0] 암호화 로직: enc[0] = flag[0] ^ [rbp+var_3E8034]

그렇다면 [rbp+var_3E8034] 값은 어디서 왔을까?

[rbp+var_3E8034] 값은 edi에서 가져온 값으로, 이는 main 함수의 첫 번째 인자인 argc(인자 개수)를 의미이다.

즉, 첫 번째 인덱스의 flag를 암호화하는 key 값은 프로그램을 실행할 당시의 argc의 하위 1바이트가 된다.

실제로 제공된 flag.enc를 분석해보면 첫 바이트 복호화를 통해 이 값이 28(0x1c)임을 역으로 확인할 수 있으며, 이는 해당 flag.enc 파일을 만들 때 argc가 28이 되도록 여러 인자를 넣어 실행했음을 의미한다.

반대로 동일한 프로그램을 "./toyransome6 flag2.enc 1 2 3"처럼 실행하여 flag2.enc를 만들면 그 시점의 argc 값은 5이므로, 그 파일의 첫 번째 인덱스의 암호화 키는 0x05가 된다.

즉, 파일마다 xor 초기 키는 그 파일을 생성할 때의 argc에 의해 결정된다.

복호화의 경우엔, xor 연산의 특성상 "buf[i] ^ buf [i-1] ^ buf [i-1] = buf [i]" 이므로 이를 이용해 복호화 해주면 된다.

먼저, 0번째 인덱스의 값은 암호화 로직이 "enc[0] = flag[0] ^ 0x1c"이고,

그 외의 경우엔 암호화 로직이 "enc[n] = flag [n] ^ enc[n-1]" 임을 이용해 복호화 로직을 짜면 다음과 같다.

flag[0] = enc[0] ^ 0x1c = flag[0] ^ 0x1c ^ 0x1c = flag[0]
flag[1] = enc[1] ^ enc[0] = flag[1] ^ enc[0] ^ enc[0] = flag[1]
...
flag[n] = enc[n] ^ enc[n-1] = flag[n] ^ enc[n-1] ^ enc[n-1] = flag[n]

복호화 코드는 다음과 같다.

with open("flag.enc", "rb") as f:
    enc = f.read()

plain = b''

plain += bytes([enc[0] ^ 0x1c])

for i in range(1, len(enc)):
    plain += bytes([enc[i] ^ enc[i - 1]])

print(plain)

복호화 결과

※ IV: Initialization Vector의 약자로, 첫 번째 데이터 블록을 암호화할 때 사용되는 임의의 값이다.

6. toyransome7

문제 설명

주어진 바이너리 파일을 분석하여 암호화된 파일을 복호화하는 문제

파일 구성

program.bin.enc: 암호화된 flag를 출력하는 바이너리 파일
toyransome7: 암호화 바이너리 파일

Hint. 핵심 basic block

instruction 설명

mov: 인덱스 값을 eax에 저장
imul: eax * eax 연산 결과를 eax에 저장 (Integer Multiply) -> eax 제곱
add: eax + 31337 연산 결과를 eax에 저장
xor: eax ^ cafebabe 연산 결과를 eax에 저장

여기서 rax*4를 해주는데, 이는 index*4이며, index가 0부터 1 2 이렇게 있을 때 0 4 8 이렇게 저장한다는 의미이다.

즉, 4바이트로 패딩한 다음에 값이 저장되어, index가 0일 땐 0에, 1일 땐 4에 저장한다. (4바이트마다 1바이트씩 저장됨)

이 문제의 암호화 로직은 크게 두 가지 과정으로 이루어져 있다.

값을 연산하는 단계: 곱하기, 더하기, xor -> 새로운 값 생성
연산된 값을 메모리에 저장하는 단계: 계산한 결과를 4바이트 단위로 저장

복호화를 하려면 이 과정을 역연산 해야 한다.

저장된 4바이트 값을 가져오는 단계
값을 연산하는 단계: xor, 빼기, 루트 연산 -> 1바이트로 출력

복호화 코드는 다음과 같다.

import math

with open("program.bin.enc", "rb") as f:
    enc_data = f.read()

plain = b''

for i in range(0, len(enc_data), 4):
    chunk = enc_data[i:i+4]
    if len(chunk) < 4:
        break

    val = int.from_bytes(chunk, "little")

    val ^= 0xCAFEBABE
    val -= 0x31337
    orig = math.isqrt(val)

    plain += bytes([orig])

with open("program.bin", "wb") as f:
    f.write(plain)

복호화한 프로그램 실행 결과

IDA 버전에 따라 다음과 같이 블록이 나뉘어 질 수도 있다. (로직은 동일)

Hint 핵심 basic block: 1314, 1357

해당 문제는 사실 다음과 같은 형태로 구성이 되어있다.

output[i] = table[input[i]

table은 loc_1314에서 만들어지고, 이후 loc_1357에서 해당 테이블이 포인터 형태로 참조되어

crypted[i] = table[plain[i]]] 형태로 사용된다.

다만, table을 참조하는 방식이 입력 바이트를 그대로 치환 테이블에서 lookup 하는 단순 치환 방식 (substitution) 으로,

추가적인 비트연산이나 혼합 과정 없이 정적 1:1 매핑으로만 구성되어 있다.

그렇기에 복호화 과정이 table을 만드는 로직을 역으로 한 것과 완전히 동치이기에 위와 같이 풀어도 되는 것이다.

6. Reversing

arsenic-dev — Sat, 6 Dec 2025 14:51:13 +0900

경희대학교 장대희 교수님의 소프트웨어보안 수업을 기반으로 정리한 글입니다.

Reverse Engineering (Reversing, 역공학)

Reverse Engineering이란 이미 만들어진 시스템이나 장치에 대한 해체나 분석을 통해 구조, 기능, 디자인 등을 알아내는 과정이다.

즉, 완성품의 설계도 없이 구조와 동작 과정을 알아내는 모든 단계를 말한다.

e.g., 소스코드가 없는 바이너리 파일(컴파일 된 파일)에 대해 프로그램의 로직을 분석하고 이해함

소프트웨어 분야에서의 Reverse Engineering은 소스코드 없이, 컴파일 된 소프트웨어의 구조를 다양한 방법으로 분석하는 과정을 말하며, 메모리 덤프와 같은 바이너리 분석 결과를 바탕으로 동작 원리와 내부 구조를 파악한 후, 원래의 코드가 어떻게 작성되었는지 추론한다.

메모리 덤프:프로그램이나 시스템의 메모리 상태를 그대로 파일로 떠놓은 것으로, GDB 같은 디버거로 덤프 파일을 열 수 있음

이러한 리버싱을 통해 분석된 프로그램에서 소스코드를 추출하거나 이해할 수 있다.

※ 이진 코드를 복원하여 바이너리 로직을 파악하는 리버싱 툴 도구 중 대표적인 도구로 IDA가 있다.

IDA 사용 방법: 바이너리 파일을 드래그하여 IDA 창에 올리기

실습

문제 접근 방식

toyransome을 제외하고는 소스코드가 없음
따라서 리버스 엔지니어링을 통해 바이너리를 분석 후 flag를 획득
- Flag의 형태는 'flag{/*임의의 문자열*/}'
문제풀이 Tip: 바이너리의 이름이 힌트가 되는 경우가 있음

1. runme

위 코드를 보고 sub_140001030 함수를 printf, 혹은 puts와 같은 함수로 추정이 가능하다. 이때 140001030은 디컴파일러가 함수가 존재하는 메모리 주소를 이름으로서 붙인 것이고, 실제 함수 이름은 아닌 경우가 대부분이다.

해당 프로그램은 이름 그대로 자신을 실행만 하면 flag가 찍히는 로직을 가지고 있다.
마지막에 fgetchar는 왜 있을까? 'runme2' 바이너리를 보면 이해할 수 있다.

'runme.exe' 파일을 더블 클릭만 하면 윈도우 콘솔 창이 뜨면서 flag 메시지가 보이고, fgetchar 때문에 거기서 멈춘다.
즉, 마우스로 클릭만 해도 손쉽게 flag를 얻을 수 있다.

'runme.exe' 파일을 실행한 모습, 아무 문자나 입력 후 엔터치면 프로그램 종료

이때 디컴파일 된 코드란 원본 코드가 아닌 IDA가 추정하여 디컴파일한 코드이다.

디컴파일 하여 정확히 원본 소스 코드를 얻는 것은 수학적으로 불가능
똑같은 바이너리로 컴파 일 될 수 있는 원본 소스 코드의 경우의 수가 무한대이기 때문

그렇다면 왜 위에 함수는 printf가 아닌 sub_140001030으로 나오고, fgetchar는 함수 이름이 나올까?

sub_140001030도 내부로 들어가보면 해당 함수의 printf, 혹은 write와 같은 심볼을 발견할 확률이 높다. (static)

static vs danamic

danamic linking을 해서 API를 사용하는 바이너리의 경우에는 실행 시점에 실제 공유 라이브러리의 위치를 찾기 때문에 함수의 이름 정보가 바이너리에 존재해야 한다. 그래서 다이나믹 링킹으로 빌드된 바이너리들은 fgetchar()처럼 심볼 이름이 나타나고, 안 나타나더라도 몇 겹으로 랩핑되어 있는 것이지 뒤져보면 다 존재한다.

하지만 static 컴파일된 바이너리면 라이브러리에 심볼 이름 이런 게 있을 필요가 없고, 그냥 어셈블리 코드가 박혀있으면 되기 때문에 sub_140001030처럼 이름이 안 나타나는 경우가 대부분이다. 디버깅용 정보로서만 존재하고 디버깅 정보를 지우면 찾을 수 없는 경우가 꽤 많다.

그럼 실제 프로그램은 무슨 함수인지 어떻게 알까? 바로 시스템콜 번호를 통해서 파악!

※ IDA에서 디컴파일은 원래 유료 Hex-Rays 플러그인이 맡지만, IDA Freeware는 예외적으로 Hex-Rays를 가지고는 있지만, x86(인텔) 바이너리에 한해서만 디컴파일을 제공하고, 그 외 아키텍처 디컴파일은 유료 버전에서만 지원된다. (현재 버전 기준)

2. runme2

해당 프로그램은 'runme' 바이너리에 비해 fgetchar만 없을 뿐, 나머지는 전부 동일하다.

'runme2.exe' 파일을 마우스로 클릭만 하면 콘솔 창이 순간적으로 뜨며 flag가 찍히지만, 바로 return 0을 하며 종료되기에 사람의 눈으론 flag 확인이 불가능하다. 즉, 마우스와 같은 GUI 인터페이스만 사용해서는 flag 확인이 불가능하고, 콘솔 창에서 실행을 하던가 하는 방법을 사용해야 한다.

물론, 'runme'와 마찬가지로 IDA로 열면 해당 의도를 우회하고 flag 확인이 바로 가능하다.

'runme2.exe' 파일을 콘솔에서 실행한 모습

※ 'runme', 'runme2'는 IDA 없이 flag를 획득하는 게 원래 문제의 의도이다.

3. number

숫자를 입력 받을 수 있음

위 코드를 보고 sub_1400010E0 함수는 printf로, sub_140001070 함수는 scanf로 추정할 수 있다.

'number.exe' 파일을 콘솔에서 실행한 후 입력으로 '947285644'를 준 모습

※ argv 옆의 envp는 디컴파일이 잘못된 것으로, 필요없는, 즉 무의미한 로직이다. 이렇게 디컴파일된 코드를 볼 때는 백프로 신뢰하면 안 된다. 디컴파일러는 로직이 똑같냐, 즉 똑같은 인풋에 대해 똑같은 결과를 내냐만 중요할 뿐 과정은 중요하지 않다.

4. number2

숫자를 입력 받을 수 있음

이때, flags.txt 파일은 여러 개의 정답 후보인 플래그들이 있는 텍스트 파일이다. 만약 'flags.txt' 파일을 담은 Stream이 null이면 else로 분기되어 프로그램이 종료된다.

※ 코드 설명

fseek(Stream, 24672, 0): flags.txt 파일에서 처음부터 24,672바이트 떨어진 위치로 파일 포인터를 옮겨라
fread(byte_140024BF0, 0x30ui64, 1ui64, Stream): 현재 파일 위치에서 0x3A0 바이트씩 1개 byte_140024BF0 버퍼에 읽어 와라
- ui64: unsigned 64-bit integer
- i64: signed 64-bit integer

'number2.exe' 파일을 콘솔에서 실행한 후, 입력으로 '1419725'를 준 모습 (5678900/4 = 1419725)

※ %ld는 계산식은 못 읽고 정수만 읽을 수 있기 때문에 '5678900/4'처럼 계산식을 입력으로 넣을시, '/4'는 무시되고 '5678900'이 입력으로 들어간다. 때문에 직접 계산한 정답값을 입력으로 넣어줘야 한다.

5. number_elf

숫자를 입력 받을 수 있음

※ 리눅스에서는 'file' 명령어를 통해 파일 정보 확인이 가능하다.

윈도우는 함수 매핑 구조가 복잡해서 심볼이 잘 드러나지 않지만, 리눅스는 표준 C 라이브러리(libc) 함수를 직접 호출하는 방식이라 puts 같은 심볼이 그대로 노출되는 편이다.

'number' 파일을 wsl에서 실행한 후, 입력으로 '92737103'을 준 모습

※ 실행 파일

윈도우: exe
리눅스: elf
일반적으로 윈도우가 리눅스보다 리버싱하기 더 복잡하다.

6. plusplus

간단한 인코딩 방식의 암호화가 적용된 모습으로 flag가 출력된 모습

1) 첫 번째 while문

strcpy를 통해 flag 값을 v7이라는 변수에 저장한다. 이때, v3이 v7의 인덱스 번호를 의미한다.

리버싱을 할 때는 코드를 보고 어떤 역할을 하는지 보면서 네이밍을 해야 수월하게 리버싱을 할 수 있다.

e.g., v7: copy_flag, v3: idx(인덱스)

첫 번째 while문의 역할은 copy_flag의 인덱스를 이용해 flag의 길이를 구하는 것이다. (counting)

즉, v3은 결과적으로 idx가 아니라 flag_length를 저장한다.

string의 마지막 문자는 null 문자로, 아스키 코드로 0을 의미하기에, 이 null 문자가 올 때까지 반복하는 것이다.

while 문의 조건이 0이면 반복문 종료

2) 두 번째 while문

두 번째 while문은 v3이 0이 아니면, 즉 flag_length가 0이 아니면 v5에 copy_flag 값을 담고 실행된다.

v5: copy_flag2

그리고 함수의 최종 실행이 출력인데 sub_1400010B0 외에는 출력하는 함수로 유추할 수 있는 게 없기에 sub_1400010B0를 printf로 유추할 수 있다.

이때 printf로 유추되는 sub_1400010B0 함수를 통해 copy_flag2에 포인터 변수로 접근하여 +1을 함으로써 flag를 1씩 더해주는 방식으로 암호화하여 출력을 하고, v4를 이용해 글자 수를 counting하여 flag_length만큼 반복하도록 한다.

&unk_140018C58을 더블 클릭하면 "%c" 포맷이 나옴
"%c" 포맷을 통해 문자를 출력함을 유추할 수도 있음

&unk_140018C58을 더블 클릭한 모습

※ IDA에서 디컴파일 하는 단축키: F5

즉, flag를 얻기 위해서는 출력되는 string에서 1씩 빼주면 됨을 유추할 수 있다.

encoded = "gmbh|sfwfstjohqmvtqmvt~"

decoded = ""

for ch in encoded:
    decoded += chr(ord(ch) - 1)  

print(decoded)

복호화 결과

7. string_easy

문자열을 입력 받을 수 있음

strcmp는 입력받은 두 문자가 다르면 정수 값을 리턴하고 같으면 0을 리턴한다.

여기서는 strcmp를 이용해 input string이 "i8NlM20"과 같으면 flag가 출력된다.

'string_easy.exe' 파일을 실행한 후, 입력으로 'i8fNlM20'을 준 모습

8. string

문자열을 입력받을 수 있음

if문을 이용해 input string이 "Akaqe27J"이면 flag가 출력된다.

'string.exe' 파일을 실행한 후, 입력으로 'Zkaqe27J'를 준 모습

9. xor

숫자를 입력 받을 수 있음

해당 문제는 원래는 xor 연산이 포함되었으나, 컴파일러가 최적화하는 과정에서 xor 로직이 날라가 10진수 <->16진수 변환 관련 문제로 전환되었다.

'xor.exe' 파일을 실행한 후, 16진수 'DEAD8EEF'를 10진수로 변환한 값인 '3735928559'를 입력으로 준 모습

10. toyransome

문제 설명: 주어진 소스코드 파일을 분석하여 암호화된 파일을 복호화하는 문제
파일 구성
- toyransome_flag.enc: 암호화된 flag 파일
- toyransome.c: flag를 암호화하는 바이너리 파일

11. flag_generator

flag가 어느 메모리에 존재하는지 위치를 알려줌

flag가 존재하는 위치를 실행 시점에 디버깅하면 flag를 쉽게 확인 가능하다. (동적 분석)

브레이크 포인트를 잘 걸고 (여기에선 return문에 브레이크 포인트) 실행을 시켜주면 flag가 스택에 남아있는 거 확인 가능

이렇게 정적 분석으론 어렵지만 동적 분석으론 쉽게 풀리는 문제들이 많다.

※ IDA는 정적 분석 도구지만 동적 분석도 가능하여 브레이크 포인트를 걸고 실행시킬 수 있다.

Step into: 함수가 실행되는 그 안으로 들어간다는 의미
Step over: 그걸 넘어서 가겠다는 의미

동적 디버깅 방법

※ 참고자료

https://arsenic-dev.tistory.com/106

ForeignKey와 OneToOneField

arsenic-dev — Wed, 19 Nov 2025 17:55:49 +0900

1. ForeignKey (1:N 관계)

ForeignKey는 여러 개가 하나를 참조하는 Many-to-One 관계이다.

e.g., 여러 개의 Post가 하나의 User 참조
e.g., 여러 개의 Order가 하나의 Customer 참조

Example

from django.db import models

class User(models.Model):
    username = models.CharField(max_length=100)

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey(
        User,
        on_delete=models.CASCADE,     # 유저 삭제 시 그 유저 글도 같이 삭제
        related_name='posts'          # user.posts 로 역참조 가능
    )

Post : User = N : 1

하나의 User는 여러 개의 Post 가질 수 있음 -> user.posts.all()
하나의 Post는 반드시 하나의 author(User)만 가짐 -> post.author

2. OneToOneField (1:1 관계)

OneToOneField는 딱 하나와만 연결되는 1:1 관계이다.

e.g., User 1명당 Profile 1개
e.g., Student 1명당 StudentCard 1개

Example

from django.db import models
from django.contrib.auth.models import User

class Profile(models.Model):
    user = models.OneToOneField(
        User,
        on_delete=models.CASCADE,
        related_name='profile'
    )
    bio = models.TextField(blank=True)
    profile_image = models.ImageField(upload_to='profiles/', blank=True)

User : Profile = 1 : 1

한 유저는 딱 하나의 프로필만 가질 수 있음 -> user.profile
한 프로필도 딱 한 유저에만 연결됨 -> profile.user

OneToOneField의 경우, 내부적으로는 Unique 제약이 있는 ForeignKey라고 볼 수 있다.

Git 필수 명령어

arsenic-dev — Wed, 5 Nov 2025 21:45:31 +0900

1. GitHub 레포지토리에서 코드 받아오기 (clone)

누가 만들어둔 GitHub 프로젝트를 내 PC로 가져와서 편집하려는 경우 사용한다.

git clone <레포지토리_URL>

레포지토리가 내 PC에 복제되고, 이 안에서 코드 수정 -> commit -> push 가능해진다.

2. 내 로컬 프로젝트를 새 GitHub 레포지토리와 연결하기

내가 새 프로젝트를 로컬에서 만들었고, 그걸 GitHub에 올리고 싶을 경우 사용한다.

cd <프로젝트_폴더>
git init                     # 깃 시작
git add .                    # 전체 파일 스테이징
git commit -m "first commit" # 첫 커밋
git branch -M main           # main 브랜치 세팅(기본 master일 수도 있음)
git remote add origin <레포_URL>   # GitHub와 연결
git push -u origin main      # GitHub에 업로드

3. 연결되어 있는 상태에서 Push / Pull

Push (내 코드 -> GitHub 올리기)

git add .
git commit -m "commit message"
git push

Pull (GitHub -> 내 코드 최신화)

git pull

4. Branch 사용법

새 브랜치 생성 + 이동

git branch <브랜치명>
git checkout <브랜치명>

브랜치 목록 보기

git branch

브랜치 삭제

git branch -d <브랜치명>

5. 현재 git 상태 확인

git status

Django로 웹 개발하기: todo_list

arsenic-dev — Wed, 29 Oct 2025 12:44:16 +0900

권태형 저자님의 '백엔드를 위한 DJANGO REST FRAMEWORK with 파이썬'을 기반으로 정리한 글입니다.

Chapter 3: Django로 Todo 목록 웹 서비스 만들기

1. Todo 목록 웹 서비스 시작하기

프로젝트 생성하기

가상 환경 세팅 -> 장고 설치 -> 장고 프로젝트 생성 -> todo 앱 생성

Todo 프로젝트 설정하기

settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'todo',
]

TIME_ZONE = 'Asia/Seoul'

그리고 이후 개발에 필요한 파일들을 미리 만들어놓는다.

todo 앱 폴더 안에 templates 폴더를 만들고 그 안에 다시 todo 폴더 생성
todo 앱 폴더 안에 forms.py, models.py, urls.py 생성

마지막으로 관리자 계정을 생성한다.

Django가 내부 데이터베이스 테이블을 만들지 못한 상태에서 createsuperuser 명령을 실행하면 오류가 발생한다. 때문에 해당 오류 방지를 위해 migration을 적용해 Django가 필요한 모든 DB 테이블을 자동으로 생성할 수 있도록 해야 한다.

Todo 모델 생성하기

프로젝트의 첫 단계는 언제나 모델을 생성하는 것이다.

현재 필요한 필드를 가진 모델을 구현한 결과는 다음과 같다.

from django.db import models

class Todo(models.Model):
    title = models.CharField(max_length=100)
    description = models.TextField(blank=True)
    created = models.DateTimeField(auto_now_add=True)
    completed = models.BooleanField(default=False)
    important = models.BooleanField(default=False)

    def __str__(self):
        return self.title

이제 아래 코드를 통해 모델에 대한 마이그레이션을 진행하면 모델 생성이 완료된다.

python manage.py makemigrations
python manage.py migrate

그리고나서 관리자 페이지에서 모델을 확인할 수 있도록, todo/admin.py에서 Todo 모델을 등록한다.

from django.contrib import admin
from .models import Todo

admin.site.register(Todo)

관리자 페이지에 접속하려면 url이 설정되어야 하기 때문에, mytodo/urls.py에서 path가 아래처럼 잘 설정되어 있는지 확인한다.

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
]

2. Todo 전체 조회 기능 만들기

Todo 전체 조회 기능 컨셉

첫 번째 페이지인 Todo 전체 조회 기능에서는 완료되지 않은, 즉 진행 중인 Todo만 보여주고 완료된 Todo는 다른 페이지에서 보여주도록 한다.

Bootstrap으로 좀 더 멋진 템플릿 만들기

Bootstrap은 가장 유명하고 오래된 CSS 프레임워크이다. 미리 스타일이 정의되어 있으며, 사용법이 간단하고 정갈한 결과물이 만들어지기 때문에 지금처럼 간단하게 꾸미고 싶은 경우 유용하게 활용할 수 있다.

Template

todo_list.html

<html>
    <head>
        <title>TODO 목록 앱</title>
        <Link
            rel="stylesheet"
            href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
        />
        <Link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.7.1/font/boot-strap-icons.css" />
    </head>
    <body>
        <div class="container">
            <h1>TODO 목록 앱</h1>
            <p>
                <a href=""><i class="bi-plus"></i>Add Todo</a>
                <a href="" class="btn btn-primary" style="float:right">완료한 TODO목록</a>
            </p>
            <ul class="list-group">
                {% for todo in todos %}
                <li class="list-group-item">
                    <a href="">{{todo.title}}</a>
                    {% if todo.important %}
                    <span class="badge badge-danger">!</span>
                    {% endif %}
                    <div style="float:right">
                        <a href="" class="btn btn-danger">완료</a>
                        <a href="" class="btn btn-outline-primary">수정하기</a>
                    </div>
                </li>
                {% endfor %}
            </ul>
        </div>
    </body>
</html>

Bootstrap 사용 법

1. <head> 안에 <link> 태그가 있고 여기에서 Bootstrap을 불러온다.

Bootstrap을 사용하기 위한 방법은 두 가지, 첫 번째 방법은 Bootstrap 홈페이지에서 css 파일들을 받아와 프로젝트 폴더에 집어넣는 방식이고, 두 번째 방식은 웹 링크 형태로 제공되는 css 파일을 가져다 쓰도록 참조시키는 방식이다.

성능 면에서는 첫 번째 방법이 당연히 더 좋겠지만 간단히 적용할 땐 웹 링크 방식이 편리하다. 그리고 이런 방식을 cdn(content delivery network) 방식이라고 한다.

2. 각 태그마다 class를 작성한다.

Bootstrap은 결국 미리 작성된 CSS이므로, CSS의 기본 작성 단위인 class를 따르고 있다. class를 쓰면 여러 태그를 한꺼번에 스타일링 가능한데, 이러한 class를 통해 Bootstrap에서 작성한 스타일을 각 태그마다 적용하고 있으며 이 class 이름은 Bootstrap이 미리 정의해놓은 값이다.

<a>: 사용자가 클릭하는 링크
<link>: 브라우저가 참고하는 외부 리소스 연결

stylesheet: 외부 css 파일을 연결

list 태그 예시

<ul>
  <li>사과</li>
  <li>바나나</li>
  <li>딸기</li>
</ul>

기타 태그 및 css 속성

<i></i>: icon 삽입시 사용하는 태그
<span></span>: inline으로 특정 부분만 스타일이나 클래스를 적용할 때 쓰는 태그
style="float: right": 요소를 오른쪽으로 띄워 배치하고, 다른 내용이 왼쪽으로 감싸지게 하는 CSS 속성

※ HTML Tag auto close 적용 안 될시, vscode 하단에 언어가 HTML로 잘 설정되어 있는지 확인하고 안 되어 있으면 HTML로 설정해야 한다.

View

완료되지 않은 Todo만 전달해야 하기 때문에 completed=False 옵션으로 필터링한다.

from django.shortcuts import render, redirect
from .models import Todo

def todo_list(request):
    todos = Todo.objects.filter(completed=False)
    return render(request, 'todo/todo_list.html', {'todos': todos})

URL

메인 페이지에서 Todo 목록을 보여줄 수 있도록 todo/urls.py를 아래와 같이 작성한다.

from django.urls import path
from . import views

urlpatterns = [
    path('', views.todo_list, name='todo_list'),
]

또한, todo 앱 url을 프로젝트 url에 연결해야 하기에, mytodo/urls.py에 아래와 같이 작성한다.

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('todo/', include('todo.urls')),
]

3. Todo 상세 조회 기능 만들기

Todo 상세 조회 기능 컨셉

Todo를 선택했을 때 조회할 수 있는 기능으로, Todo 제목과 설명을 나타내도록 구현한다.

Template

todo_detail.html

<html>
    <head>
        <title>TODO 목록 앱</title>
        <Link
            rel="stylesheet"
            href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
        />
        <Link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.7.1/font/boot-strap-icons.css" />
    </head>
    <body>
        <div class="container">
            <h1>TODO 상세보기</h1>
            <div class="container">
                <div class="row">
                    <div class="col-md-12">
                        <div class="card">
                            <div class="card-body">
                                <h5 class="card-title">{{todo.title}}</h5>
                                <p class="card-text">{{todo.description}}</p>
                                <a href="{% url 'todo_list' %}" class="btn btn-primary">목록으로</a>
                            </div>
                        </div>
                    </div>  
                </div>
            </div>
        </div>
    </body>
</html>

View

def todo_detail(request, pk):
    todo = Todo.objects.get(id=pk)
    return render(request, 'todo/todo_detail.html', {'todo': todo})

선택된 Todo의 pk인 id를 기반으로 Todo 객체를 찾아 todo_detail.html로 전달할 수 있도록 위와 같이 작성하고, todo_list.html의 버튼에 링크를 넣는다.

<a href="{% url 'todo_detail' pk=todo.pk %}">{{todo.title}}</a>

URL

url은 todo/urls.py에서 /pk/로 설정하여 해당 Todo를 연결할 수 있도록 한다.

urlpatterns = [
    path('', views.todo_list, name='todo_list'),
    path('<int:pk>/', views.todo_detail, name='todo_detail'),
]

4. Todo 생성 기능 만들기

Todo 생성 기능 컨셉

todo/forms.py에 제목, 설명, 중요도를 입력할 수 있도록 입력 폼을 만들어 주어야 한다.

Template

todo/forms.py

from django import forms
from .models import Todo

class TodoForm(forms.ModelForm):
    class Meta:
        model = Todo
        fields = ('title', 'description', 'important')

이렇게 작성한 폼을 활용하여 템플릿을 작성한다.

todo_post.html

<html>
    <head>
        <title>TODO 목록 앱</title>
        <Link
            rel="stylesheet"
            href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
        />
        <Link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.7.1/font/boot-strap-icons.css" />
    </head>
    <body>
        <div class="container">
            <h1>TODO 추가하기</h1>
            <div class="container">
                <div class="row">
                    <div class="col-md-12">
                        <div class="card">
                            <div class="card-body">
                                <form method="POST">
                                    {% csrf_token %} {{form.as_p}}
                                    <button type="submit" class="btn btn-primary">등록</button>
                                </form>
                            </div>
                        </div>
                    </div>  
                </div>
            </div>
        </div>
    </body>
</html>

View

Todo를 생성하기 위한 뷰는 POST 요청을 처리할 수 있어야 한다. POST 요청이 들어왔을 때는 폼을 검증하고 데이터를 저장할 수 있도록 하며, GET 요청이 들어왔을 때는 폼을 포함한 템플릿 페이지를 보여주면 된다.

from django.shortcuts import render, redirect
from .models import Todo
from .forms import TodoForm

def todo_list(request):
    todos = Todo.objects.filter(completed=False)
    return render(request, 'todo/todo_list.html', {'todos': todos})

def todo_detail(request, pk):
    todo = Todo.objects.get(id=pk)
    return render(request, 'todo/todo_detail.html', {'todo': todo})

def todo_post(request):
    if request.method == "POST":
        form = TodoForm(request.POST)
        if form.is_valid():
            todo = form.save(commit=False)
            todo.save()
            return redirect('todo_list')
    else:
        form = TodoForm()
    return render(request, 'todo/todo_post.html', {'form': form})

그 후, todo_list.html의 버튼에 링크를 넣어준다.

<a href="{% url 'todo_post' %}"><i class="bi-plus"></i>Add Todo</a>

URL

urlpatterns = [
    path('', views.todo_list, name='todo_list'),
    path('<int:pk>/', views.todo_detail, name='todo_detail'),
    path('post/', views.todo_post, name='todo_post'),
]

5. Todo 수정 기능 만들기

Todo 수정 기능 컨셉

수정 기능을 만들 때는 생성 기능과 동일하게 작성하되, 기존 Todo 데이터를 불러와 함게 템플릿으로 보내는 것만 구현하면 된다.

View

def todo_post(request):
    if request.method == "POST":
        form = TodoForm(request.POST)
        if form.is_valid():
            todo = form.save(commit=False)
            todo.save()
            return redirect('todo_list')
    else:
        form = TodoForm()
    return render(request, 'todo/todo_post.html', {'form': form})

def todo_edit(request, pk):
    todo = Todo.objects.get(id=pk)
    if request.method == "POST":
        form = TodoForm(request.POST, instance=todo)
        if form.is_valid():
            todo = form.save(commit=False)
            todo.save()
            return redirect('todo_list')
    else:
        form = TodoForm(instance=todo)
    return render(request, 'todo/todo_post.html', {'form': form})

그리고 todo_list.html의 버튼에 링크를 다음과 같이 추가한다.

<a href="{% url 'todo_post' %}"><i class="bi-plus"></i>Add Todo</a>

<a href="{% url 'todo_edit' pk=todo.pk %}" class="btn btn-outline-primary">수정하기</a>

URL

urlpatterns = [
    path('', views.todo_list, name='todo_list'),
    path('<int:pk>/', views.todo_detail, name='todo_detail'),
    path('post/', views.todo_post, name='todo_post'),
    path('<int:pk>/edit/', views.todo_edit, name='todo_edit'),
]

6. Todo 완료 기능 만들기

Todo 완료 기능 컨셉

Todo 완료 기능은 완료 버튼을 눌렀을 때 Todo의 completed을 True로 설정해 주는 기능이다. 또한 완료 Todo 조회 기능은 완료된 Todo만 필터링하여 볼 수 있도록 하는 기능이다.

Template

done_list.html

<html>
    <head>
        <title>TODO 목록 앱</title>
        <Link
            rel="stylesheet"
            href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
        />
        <Link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.7.1/font/boot-strap-icons.css" />
    </head>
    <body>
        <div class="container">
            <h1>DONE 목록</h1>
            <p>
                <a href="{% url 'todo_list' %}" class="btn btn-outline-primary">홈으로</a>
            </p>
            <ul class="list-group">
                {% for done in dones %}
                <li class="list-group-item">
                    <a href="{% url 'todo_detail' pk=done.pk %}">{{done.title}}</a>
                    {% if done.important %}
                    <span class="badge badge-danger">!</span>
                    {% endif %}
                </li>
                {% endfor %}
            </ul>
        </div>
    </body>
</html>

그리고나서 todo_list.html의 버튼에 링크를 추가한다.

<a href="{% url 'done_list' %}" class="btn btn-primary" style="float:right">완료한 TODO 목록</a>

View

Todo 완료 기능에서 필요한 뷰는 두 가지로, 완료된 목록을 보여주는 기능과 Todo를 완료로 바꿔주는 기능이 있다.

완료된 목록을 보여주는 것은 앞서 todo_list() 뷰와 동일하게 작성되며 completed=True로 필터링 하는 것만 다르다. 그리고 Todo를 완료로 바꾸기 위해서는 Todo 객체를 가져와 completed을 True로 설정한 다음 저장하면 된다.

def done_list(request):
    dones = Todo.objects.filter(completed=True)
    return render(request, 'todo/done_list.html', {'dones': dones})

def todo_done(request, pk):
    todo = Todo.objects.get(id=pk)
    todo.completed = True
    todo.save()
    return redirect('todo_list')

마찬가지로, todo_list.html 내 버튼에 링크를 추가해 준다.

<a href="{% url 'todo_done' pk=todo.pk %}" class="btn btn-danger">완료</a>

URL

마지막으로 url을 연결한다.

urlpatterns = [
    path('', views.todo_list, name='todo_list'),
    path('<int:pk>/', views.todo_detail, name='todo_detail'),
    path('post/', views.todo_post, name='todo_post'),
    path('<int:pk>/edit/', views.todo_edit, name='todo_edit'),
    path('done/', views.done_list, name='done_list'),
    path('done/<int:pk>/', views.todo_done, name='todo_done'),
]

※ Django에서 pk와 id는 기본 키를 가리키며, 기본 키가 나중에 id가 아닌 다른 필드로 바뀌어도 pk는 항상 작동하므로, URL이나 템플릿에서는 pk로 통일하는 것이 안전하다.

결과: 모든 기능 정상 작동