path_finder.log

[git/github] 버전을 만들어보자

Tue, 25 Apr 2023 17:18:23 GMT

📌 흐름을 이해하기

이제부터 이 폴더 안에서 버전관리를 시작할거야!

$ git init

이 폴더의 상태를 확인하고 싶다!

$ git status
On branch master

No commits yet

Untracked files:
  (use "git add ..." to include in what will be committed)
        test.txt

nothing added to commit but untracked files present (use "git add" to track)

No commit yet 아직 커밋되지 않았다

Untracked files 못보던 새로운 파일이 생겼습니다!

이제 test.txt를 staging area로 올려보자!

$ git add test.txt 
                                        // 아무것도 안뜨면 잘 add 된거임
$ git status
On branch master

No commits yet

Changes to be committed: // 변화가 감지됐다!
  (use "git rm --cached ..." to unstage)
        new file:   test.txt

다시 내리는 것도 가능?

$ git rm --cached test.txt
rm 'test.txt'

$ git status
On branch master

No commits yet

Untracked files:
  (use "git add ..." to include in what will be committed)
        test.txt

올려야할 파일이 너무 많거나 전부 올리려면 어떡해요?

$ git add .     // 모두  staging area 로 옮겨라! 는 의미

Staging Area에서 Depository로 옮기기

$ git commit -m "commit message"

$ git commit -m "first commit"
[master (root-commit) 0c580a9] first commit
 1 file changed, 1 insertion(+)
 create mode 100644 test.txt

커밋 메세지가 뭔가요?

📌 어떤 변경사항이 생겨서 버전을 생성했는지 알려주기 위해 적는 메시지

커밋한 내역을 확인하고 싶어요

$ git log
commit 0c580a93a7919d0c6ec3ab99a01153ac534d5537 (HEAD -> master)
Author: Eugene Kim 
Date:   Wed Apr 26 01:39:24 2023 +0900

    first commit

만약 파일을 수정한다면?

$ git status
On branch master
Changes not staged for commit:
  (use "git add ..." to update what will be committed)
  (use "git restore ..." to discard changes in working directory)
        modified:   test.txt

no changes added to commit (use "git add" and/or "git commit -a")

수정한 파일을 다시 Staging Area로 옮기는건?

$ git add test.txt

$ git status
On branch master
Changes to be committed:
  (use "git restore --staged ..." to unstage)
        modified:   test.txt

그걸 버전으로 만들려면?

$ git commit -m "add string to test"
[master 7f63648] add string to test
 1 file changed, 1 insertion(+), 1 deletion(-)

$ git log
commit 7f63648c15ef69c06a302883b098f9b384883d26 (HEAD -> master)
Author: Eugene Kim 
Date:   Wed Apr 26 01:49:38 2023 +0900

    add string to test

commit 0c580a93a7919d0c6ec3ab99a01153ac534d5537
Author: Eugene Kim 
Date:   Wed Apr 26 01:39:24 2023 +0900

    first commit

commit에 관하여

commit할때 -m을 붙이지 않으면 자동으로 vi가 실행되는데, 그곳에 commit message를 더욱 자세히 적을 수 있다!

여기서 드는 의문점

⇒ 그래서 깃헙을 쓰는거다!

: 각자의 컴퓨터에만 존재하는 버전을 저장, 관리해주는 서비스

github에 코드를 업로드 한다 == github에 push한다.

📌 내 컴퓨터 : Local 저장소

github이 관리하는 컴퓨터 : 원격 저장소

Repository에 있는 모든 version이 모두 원격 저장소로 올라간다고 생각하면 됩니다

출처

https://www.inflearn.com/course/%EB%B9%A0%EB%A5%B4%EA%B2%8C-git/dashboard

[git/github] 버전 관리의 큰그림

Tue, 25 Apr 2023 17:14:50 GMT

git이란?

: 버전 관리 시스템

버전

게임에서 나오는 버전

: 유의미한 변화가 결과물로 나온것

⇒ 하나의 버전을 관리하는 과정에서 협업이 필요하다.

⇒ 하나의 버전이 관리되는 과정에서 되돌리는 과정이 필요하다

⇒ 하나의 버전이 관리되는 과정에서 효율적인 백업이 필요하다.

이것들을 해주는 도구 : git

버전이 만들어지는 두개의 단계

📌 버전이 되기까지 거쳐가는 두개의 단계, 세개의 공간이 있음

Working directory

: 작업 공간,
- 내가 코드 작업을 하는 공간
- 파일들이 만들어지는 공간
- 즉, 변경사항이 생기는 공간
  
  Q. 여기서 모든 변경사항을 버전으로 만들어야 하는가?
  
  A. 변경 사항들 중 다음 버전이 될 파일들을 선별해서, 선별된 파일들을 버전으로 만들자!
Staging Area
- 버전이 될 후보들이 올라오는 공간
- Working directory 에서 선별
Repository
- 진짜 버전이 저장되는 공간

명령어 맛보기

git <명령어>
git add // 변경된 파일을 Staging Area로 옮김
git commit // Staging Area의 파일을 Repository로 옮김

출처

https://www.inflearn.com/course/%EB%B9%A0%EB%A5%B4%EA%B2%8C-git/dashboard

Shellcode

Thu, 20 Apr 2023 12:13:43 GMT

소개

익스플로잇 (Exploit)

상대 시스템을 공격하는 것

셸 코드 (Shellcode)

익스플로잇을 위해 제작된 어셈블리 코드 조각
일반적으로 셸을 획득하기 위한 목적으로 셸코드 사용
셸을 획득하는 것은 시스템 해킹에서 매우 중요

⭐ 해커가 rip을 자신이 작성한 셸코드의 주소로 변경

셸 코드는 어셈블리어로 구성된 만큼 아키텍처와 운영체제에 따라 다르게 작성해야함

orw Shellcode

파일을 엵고 읽은 뒤 화면에 출력해주는 셸코드
/tmp/flag 를 읽는 셸코드 작성

char buf[0x30];

int fd = open("/tmp/flag", RD_ONLY, NULL);
read(fd, buf, 0x30);
write(1, buf, 0x30);

📌 알아두어야 하는 System Call

구현

; int fd = open("/tmp/flag", O_RDONLY, NULL) 이 부분을 구현할거임

push 0x67 ; g의 아스키코드 g는 왜 따로 하느냐? 64비트(8글자)가 다 차버려서ㅠㅠ
mov rax, 0x616c662f706d742f  ; /tmp/fla 문자열의 아스키 코드 -> 리틀 엔디언
push rax                     ; 16진수 두개씩 끊어서 읽어봐
mov rdi, rsp ; rdi = "/tmp/flag" , rdi는 arg0임
xor rsi, rsi  ; rsi = 0; RD_ONLY
xor rdx, rdx  ; rdx = 0
mov rax, 2    ; rax = 2 -> syscall_open
syscall       ; open("/tmp/flag", RD_ONLY, NULL)

; read(fd, buf, 0x30) 이번엔 이 부분을 구현할 거임
; – syscall의 반환 값은 rax로 저장, 따라서 open으로 획득한 /tmp/flag의 fd는 rax에 저장.
; – read의 첫 번째 인자를 이 값으로 설정해야 하므로 rax를 rdi에 대입.
; – rsi는 파일에서 읽은 데이터를 저장할 주소를 포인팅, 0x30만큼 읽을 것이므로, rsi에 rsp-0x30을 대입.
; – rdx는 파일로부터 읽어낼 데이터의 길이인 0x30으로 설정.
; – read 시스템콜을 호출하기 위해서 rax를 0으로 설정.
mov rdi, rax  ; rdi = fd
mov rsi, rsp  
sub rsi, 0x30 ; rsi = rsp-0x30 ; buf
mov rdx, 0x30 ; rdx = 0x30     ; len
mov rax, 0x0  ; rax = 0        ; syscall_read
syscall       ; read(fd, buf, 0x30

; write(1, buf, 0x30) 차례
; rsi, rdx는 read에서 사용한 값을 그대로 사용
mov rdi, 1  ; rdi = 1 ; fd = stdout 출력은 stdout으로 할거라서
mov rax, 0x1 ; rax = 1 ; syscall_write
syscall     ; write(fd, buf, 0x30)

📌 fd란?

구구절절한 설명

유닉스 계열의 운영체제에서 파일에 접근하는 소프트웨어에 제공하는 가상의 접근 제어자

0 : 일반 입력(Standard Input, STDIN) 주로 키보드

1 : 일반 출력(Standard Output, STDOUT) 화면

2 : 일반 오류(Standard Error, STDERR)

execve 셸코드

: 임의의 프로그램을 실행하는 셸코드

system call

구구절절한 설명

📌 출처 : 진구

C 언어에서 execve() 함수는 새로운 프로세스를 생성하는 시스템 콜입니다. 이 함수는 기존의 프로세스를 새로운 프로세스로 대체하는데 사용됩니다.

execve() 함수는 다음과 같은 선언을 갖습니다.


int execve(const char *filename, char *const argv[], char *const envp[]);

filename: 실행할 프로그램의 경로와 이름입니다.
argv[]: 실행할 프로그램에 전달할 인자값들을 담고 있는 문자열 배열입니다.
envp[]: 실행할 프로그램에서 사용할 환경 변수를 담고 있는 문자열 배열입니다.

execve() 함수를 호출하면 새로운 프로세스가 생성되고 filename으로 지정한 프로그램이 실행됩니다. 실행할 프로그램은 현재 프로세스와는 독립적으로 동작하며, argv[]와 envp[]를 통해 전달된 인자와 환경 변수를 사용할 수 있습니다.

execve() 함수는 호출에 성공하면 현재 프로세스의 메모리 영역을 대체하여 새로운 프로그램을 실행합니다. 즉, 현재 프로세스는 새로운 프로그램이 종료될 때까지 더 이상 실행되지 않습니다. 이러한 특징으로 인해, execve() 함수는 다른 프로그램을 실행하는 용도로 주로 사용됩니다.

예를 들어, 다음과 같은 코드는 ls 명령어를 실행하는 예제입니다.


#include 
#include 

int main(void) {
    char *argv[] = {"ls", "-l", NULL};
    execve("/bin/ls", argv, NULL);
    printf("This line will not be executed\n");
    return 0;
}

위 코드에서 execve() 함수는 /bin/ls 프로그램을 실행합니다. argv 배열은 ls 프로그램에 전달할 인자를 저장하고 있으며, NULL을 마지막으로 구분합니다. envp 배열은 NULL로 설정하여 환경 변수를 사용하지 않도록 합니다. 실행 결과로는 현재 디렉토리의 파일 목록이 출력됩니다. 이후의 코드는 execve() 함수가 호출되면 실행되지 않습니다.

출처

드림핵, 우리 학교 교수님

[Assembly] Assembly - 2

Tue, 18 Apr 2023 12:39:38 GMT

⭐ 이번 시간은 저번 시간보다 중요한 명령어를 배운다!

스택 Stack

push

val을 스택 최상단에 쌓음

📌 rsp란?

현재 스택의 최상단 주소를 갖고있는 레지스터

rsp -= 8 ; 왜 감소인가? 메모리 방향때문 어쩌구 저쩌
[rsp] = val

;[Register]
rsp = 0x7fffffffc400

;[Stack]
0x7fffffffc400 | 0x0  <= rsp
0x7fffffffc408 | 0x0

;[Code]
push 0x31337

;[Register]
rsp = 0x7fffffffc3f8

;[Stack]
0x7fffffffc3f8 | 0x31337 <= rsp 
0x7fffffffc400 | 0x0
0x7fffffffc408 | 0x0

pop

스택 최상단의 값을 꺼내서 reg에 대입

rsp += 8 ; 스택 주소는 반대임 그냥 받아들일 것
reg = [rsp-8]

;[Register]
rax = 0
rsp = 0x7fffffffc3f8

;[Stack]
0x7fffffffc3f8 | 0x31337 <= rsp 
0x7fffffffc400 | 0x0
0x7fffffffc408 | 0x0

;[Code]
pop rax

;[Register]
rax = 0x31337
rsp = 0x7fffffffc400

;[Stack]
0x7fffffffc400 | 0x0 <= rsp 
0x7fffffffc408 | 0x0

프로시저(Procedure)

📌 프로시저란?

특정 기능을 수행하는 코드 조각, 어셈블리어에 함수같은 거라고 생각하자

호출 Call : 프로시저를 부르는 행위
반환 Return : 프로시저에서 돌아오는 것

⭐ 호출할때는 프로시저 실행 후 원래 실행 흐름으로 돌아와야 하므로 call 다음에 명령어 주소(return address, 반환주소)를 스택에 저장하고 프로시저로 rip를 이동

call

addr에 위치한 프로시져 호출

push return_address
jmp addr

;[Register]
rip = 0x400000
rsp = 0x7fffffffc400 

;[Stack]
0x7fffffffc3f8 | 0x0
0x7fffffffc400 | 0x0 <= rsp

;[Code]
0x400000 | call 0x401000  <= rip
0x400005 | mov esi, eax
...
0x401000 | push rbp

;[Register]
rip = 0x401000
rsp = 0x7fffffffc3f8

;[Stack]
0x7fffffffc3f8 | 0x400005  <= rsp ; 다시 돌아갈 주소가 스택에 쌓임
0x7fffffffc400 | 0x0
[Code]
0x400000 | call 0x401000
0x400005 | mov esi, eax
...
0x401000 | push rbp  <= rip

leave

스택 프레임 정리

📌 스택프레임이란? 구구절절한 설명 고고

스택은 함수별로 자신의 지역변수 또는 연산과정에서 부차적으로 생겨나는 임시 값들을 저장하는 영역입니다. 만약 이 스택 영역을 아무런 구분 없이 사용하게 된다면, 서로 다른 두 함수가 같은 메모리 영역을 사용할 수 있게 됩니다.

예를 들어 A라는 함수가 B라는 함수를 호출하는데, 이 둘이 같은 스택 영역을 사용한다면, B에서 A의 지역변수를 모두 오염시킬 수 있습니다. 이 경우, B에서 반환한 뒤 A는 정상적인 연산을 수행할 수 없습니다.

따라서 함수별로 서로가 사용하는 스택의 영역을 명확히 구분하기 위해 스택프레임이 사용됩니다. 우분투 18.04에서 함수는 호출될 때 자신의 스택프레임을 만들고, 반환할 때 이를 정리합니다.

📌 rbp란?

스택의 시작점, 바닥을 가리키고 있는 레지스터

rsp은 꼭대기이므로 반대

mov rsp, rbp
pop rbp

;[Register]
rsp = 0x7fffffffc400
rbp = 0x7fffffffc480

;[Stack]
0x7fffffffc400 | 0x0 <= rsp
...
0x7fffffffc480 | 0x7fffffffc500 <= rbp
0x7fffffffc488 | 0x31337 

;[Code]
leave

;[Register]
rsp = 0x7fffffffc488
rbp = 0x7fffffffc500

;[Stack]
0x7fffffffc400 | 0x0
...
0x7fffffffc480 | 0x7fffffffc500
0x7fffffffc488 | 0x31337 <= rsp
...
0x7fffffffc500 | 0x7fffffffc550 <= rbp

red

return address로 반환

pop rip

;[Register]
rip = 0x401008
rsp = 0x7fffffffc3f8
[Stack]
0x7fffffffc3f8 | 0x400005    <= rsp
0x7fffffffc400 | 0

;[Code]
0x400000 | call 0x401000
0x400005 | mov esi, eax
...
0x401000 | mov rbp, rsp  
...
0x401007 | leave
0x401008 | ret  <= rip

;[Register]
rip = 0x400005
rsp = 0x7fffffffc400
[Stack]
0x7fffffffc3f8 | 0x400005
0x7fffffffc400 | 0x0    <= rsp

;[Code]
0x400000 | call 0x401000
0x400005 | mov esi, eax   <= rip
...
0x401000 | mov rbp, rsp  
...
0x401007 | leave
0x401008 | ret

스택 프레임의 할당과 해제

아주 좋은 예시

시스템 콜 System Call

배경

구구절절한 설명

윈도우, 리눅스, 맥 등의 현대 운영체제는 컴퓨터 자원의 효율적인 사용을 위해, 그리고 사용자에게 편리한 경험을 제공하기 위해, 내부적으로 매우 복잡한 동작을 합니다. 운영체제는 연결된 모든 하드웨어 및 소프트웨어에 접근할 수 있으며, 이들을 제어할 수도 있습니다. 그리고 해킹으로부터 이 막강한 권한을 보호하기 위해 커널 모드와 유저 모드로 권한을 나눕니다.

커널 모드는 운영체제가 전체 시스템을 제어하기 위해 시스템 소프트웨어에 부여하는 권한입니다. 파일시스템, 입력/출력, 네트워크 통신, 메모리 관리 등 모든 저수준의 작업은 사용자 모르게 커널 모드에서 진행됩니다. 커널 모드에서는 시스템의 모든 부분을 제어할 수 있기 때문에, 해커가 커널 모드까지 진입하게 되면 시스템은 거의 무방비 상태가 됩니다. 이에 대해서는 나중에 Linux Kernel Exploit 커리큘럼에서 자세히 배울 수 있습니다.

유저 모드는 운영체제가 사용자에게 부여하는 권한입니다. 브라우저를 이용하여 드림핵을 보거나, 유튜브를 시청하는 것, 게임을 하고 프로그래밍을 하는 것 등은 모두 유저 모드에서 이루어집니다. 리눅스에서 루트 권한으로 사용자를 추가하고, 패키지를 내려 받는 행위 등도 마찬가지입니다. 유저 모드에서는 해킹이 발생해도, 해커가 유저 모드의 권한까지 밖에 획득하지 못하기 때문에 해커로 부터 커널의 막강한 권한을 보호할 수 있습니다.

시스템 콜(system call, syscall)은 유저 모드에서 커널 모드의 시스템 소프트웨어에게 어떤 동작을 요청하기 위해 사용됩니다. 소프트웨어 대부분은 커널의 도움이 필요합니다. 예를 들어, 사용자가 cat flag를 실행하면, cat은 flag라는 파일을 읽어서 사용자의 화면에 출력해 줘야 합니다. 그런데 flag는 파일 시스템에 존재하므로 이를 읽으려면 파일시스템에 접근할 수 있어야 합니다. 유저 모드에서는 이를 직접 할 수 없으므로 커널이 도움을 줘야 합니다. 여기서, 도움이 필요하다는 요청을 시스템 콜이라고 합니다. 유저 모드의 소프트웨어가 필요한 도움을 요청하면, 커널이 요청한 동작을 수행하여 유저에게 결과를 반환합니다.

x64아키텍쳐에서는 시스템콜을 위해 syscall 명령어가 있습니다.

커널 모드 Kernel mode
유저 모드 User mode

시스템 콜 System Call

유저 모드에서 커널 모드의 시스템 소프트웨어에게 어떤 동작을 요청하기 위해 사용

요청: rax

인자 순서: rdi → rsi → rdx → rcx → r8 → r9 → stack

구구절절한 해석

오른쪽의 syscall table을 보면, rax가 0x1일 때, 커널에 write 시스템콜을 요청합니다. 이때 rdi, rsi, rdx가 0x1, 0x401000, 0xb 이므로 커널은 write(0x1, 0x401000, 0xb)를 수행하게 됩니다.

write함수의 각 인자는 출력 스트림, 출력 버퍼, 출력 길이를 나타냅니다. 여기서 0x1은 stdout이며, 이는 일반적으로 화면을 의미합니다. 0x401000에는 Hello World가 저장되어 있고, 길이는 0xb로 지정되어 있으므로, 화면에 Hello World가 출력됩니다.

;[Register]
rax = 0x1   
rdi = 0x1   
rsi = 0x401000  
rdx = 0xb   

;[Memory]
0x401000 | "Hello Wo"   
0x401008 | "rld"    
[Code]  
syscall

;-----------------;
;output
Hello World

[Assembly] Assembly - 1

Wed, 05 Apr 2023 18:37:58 GMT

어셈블리어란?

컴퓨터(CPU)의 기계어와 치환되는 언어

⚠️ CPU가 달라지면 어셈블리어도 달라진다!\

배경지식

CPU에 사용되는 명령어 집합 구조는 다양하다

📌 명령어 집합 구조 : ISA Instruction Set Architecture

→ 다양한 만큼 어셈블리어도 다양하다.

📌 내 컴퓨터의 환경은 x64아케텍처를 대상으로 하므로 x64만 어셈블리어를 다룬다

어셈블리어의 기본 구조

mov eax, 3 
; opcode operand1 operand2
; 대입해라 eax에 3을

명령어

개요

;데이터 이동
mov
lea

;산술 연산
inc
dec
add
sub

;논리 연산
and
or
xor
not

;비교
cmp
test

;분기
jmp, je, jg

;스택
push
pop

;프로시저(Prosedure)
call
ret
leave

;시스템 콜
syscall

; 강교수님 : 기타 등등 많으나 이것만 알아둬도 돼!
; 알아둬야 해

피연산자의 종류

상수 ( Immediate Value )
레지스터 ( Register )
메모리 ( Memory )

📌 메모리 피연산자는 [ 대괄호 ] 로 둘러쌓인 것으로 표현됨

앞에 크기 지정자(size directive) TYPE PTR 추가

TYPE
1. BYTE
2. WORD 워드, 2byte
3. DWORD 더블 워드, 4byte
4. QWORD 쿼터 워드, 8byte
```
QWORD PTR [0x80488000] ; 0x80488000의 데이터를 8byte만큼 참조
DWRD PTR [0x80488000] ; 0x80488000의 데이터를 4byte만큼 참조
WORD PTR [rax] ; rax가 가리키는 주소에서 데이터를 2byte 만큼 참조
```

데이터의 이동

어떤 값을 레지스터나 메모리에 옮기도록 지시

mov

src에 들어있는 값을 dst에 대입

mov dst, src ; src에 들어있는 값을 dst에 대입
; 순서 헷갈리지 말자! 도착지부터 적는거다.

mov rdi, rsi ; rsi의 값을 rdi에 대입
mov QWORD PTR[rdi], rsi ; rsi의 값을 rdi가 가리키는 주소에 대입
mov QWROD PTR[rdi+8*rcx], rsi ; rsi의 값을 rdi+8*rcx가 가리키는 주소에 대입

lea

src의 유효주소(Effective Address, EA)를 dst에 저장

lea dst, src ; src의 유효주소를 dst에 저장

lea rsi, [rbx+8*rcx] ; rbx+8*rcx를 rsi에 대입

산술 연산

add

dst에 src의 값을 더함

add dst, src ; dst에 src의 값을 더함

add eax, 3 ; eax += 3
add ax, WORD PTR[rdi] ; ax += *(WORD *)rdi

sub

dst에서 src의 값을 뺌

sub dst, src ; dst에서 src의 값을 뺌

sub eax, 3 ; eax -= 3
sub ax, WORD PTR[rdi] ; ax -= *(WORD *)rdi

inc

op의 값을 1 증가시킴

inc op ; op의 값을 1 증가시킴

inc eax ; eax += 1

dec

op의 값을 1 감소 시킴

dec op ; op의 값을 1 감소 시킴

dec eax ; eax -= 1

논리 연산

⚠️ 비트단위로 계산하는 거니까 16진수 → 2진수로 변환하여 계산해야함 귀찮음

and

dst와 src의 비트가 모두 1이면 1, 아니면 0

and dst, src ; **dst와 src의 비트가 모두 1이면 1, 아니면 0

;[Register]
eax = 0xffff0000
ebx = 0xcafebabe

;[Code]
and eax, ebx

;[Result]
eax = 0xcafe0000**

or

dst와 src의 비트 중 하나라도 1이면 1, 아니면 0

or dst, src ; **dst와 src의 비트 중 하나라도 1이면 1, 아니면 0

;[Register]
eax = 0xffff0000
ebx = 0xcafebabe

;[Code]
or eax, ebx

;[Result]
eax = 0xffffbabe ; 계산은 시간날때 해보세요**

xor

dst와 src의 비트가 서로 다르면 1, 같으면 0

xor dst src ; **dst와 src의 비트가 서로 다르면 1, 같으면 0

;[Register]
eax = 0xffffffff
ebx = 0xcafebabe

;[Code]
xor eax, ebx

;[Result]
eax = 0x35014541**

not

op의 비트 전부 반전

not op ; op의 비트 전부 반전

;[Register]
eax = 0xffffffff

;[Code]
not eax

;[Result]
eax = 0x00000000

비교

두 피연산자의 값을 비교하고 플래그를 설

cmp

op1과 op2를 비교

cmp op1, op2 ; op1과 op2를 비교
; 대소를 비교하고 플래그만 세울뿐, 결과를 op1에 저장하지는 않음

;[Code]
1: mov rax, 0xA
2: mov rbx, 0xA
3: cmp rax, rbx ; ZF=1

test

op1과 op2를 비교

test op1, op2 ; op1과 op2를 비교
; AND연산 취함 결과는 op1에 대입 안함

;[Code]
1: xor rax, rax
2: test rax, rax ; ZF=1
; ZF플래그를 보고 rax가 0이였는지 판단

분기

rip를 이동시켜 실행 흐름을 바꿈

⚠️ 분기문은 엄청 많지만 여백이 좁아 정리할 수 없다 고로 앞으로 알아가도록

jmp

addr로 rip를 이동시킴

📌 rip란?

프로세서가 읽고 있는 현재 명령의 위치를 가리키는 명령 포인터

jmp addr ; addr로 rip를 이동시킴

;[Code]
1: xor rax, rax
2: jmp 1 ; jump to 1

je

직전에 비교한 두 피연산자가 같으면 점프 (jump if equal)

je addr ; **직전에 비교한 두 피연산자가 같으면 점프 (jump if equal)**

;[Code]
1: mov rax, 0xcafebabe
2: mov rbx, 0xcafebabe
3: cmp rax, rbx ; rax == rbx
4: je 1 ; jump to 1

jg

직전에 비교한 두 연산자 중 전자가 더 크면 점프 (jump if greater)

jg addr ; **직전에 비교한 두 연산자 중 전자가 더 크면 점프 (jump if greater)

;[Code]
1: mov rax, 0x31337
2: mov rbx, 0x13337
3: cmp rax, rbx ; rax > rbx
4: jg 1  ; jump to 1**

까먹을만한 거

대괄호 안에 있으면 주소값이다

[GDB] GDB 메뉴얼

Wed, 05 Apr 2023 17:46:14 GMT

기본적인 실행, 종료

실행

> gdb
// 실행은 참 쉬움

종료

pwndbg> exit
// 종료도 참 쉬움

gdb 세팅 포맷이 무엇인지 확인하기

pwndbg> show disassembly-flavor

→ Intel 이면 Intel로 뜸

만약 다른 포맷이면 변경해야 함

써먹어보기

예시 코드

// Name : debugee.c
// Compile : gcc -o debugee debugee.c -no-pie
// --------------------------------------------
#include 

int main(void) { 

        int sum = 0;
        int val1 = 1;
        int val2 = 2;

        sum = val1 + val2;
        printf("1 + 2 = %d\n", sum);

        return 0;
}

바이너리 파일의 정보 확인하기

> readelf -h debugee // ELF (Executable and Linkable Format

→ 온갖 정보가 다 뜰거임

📌 Entry point address : 프로그램이 실제로 실행되는 주소(16진수)

시잒!

> gdb debugee

gdb + 실행파일

진짜 시잒!

pwndbg> start

Temporary breakpoint 1 at 0x40112a # 여기 멈춰 있다는 의미

Temporary breakpoint 1, 0x000000000040112a in main ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA # 세그먼트 정보들
────────────────────[ REGISTERS / show-flags off / show-compact-regs off ]─────────────────────
# 레지스터 정보들
*RAX  0x401126 (main) ◂— push rbp
*RBX  0x7fffffffde68 —▸ 0x7fffffffe1ef ◂— '/home/eugene/Workspace/hack/debugee'
*RCX  0x403e00 (__do_global_dtors_aux_fini_array_entry) —▸ 0x4010f0 (__do_global_dtors_aux) ◂— endbr64                                                                                        
*RDX  0x7fffffffde78 —▸ 0x7fffffffe213 ◂— 'CLUTTER_IM_MODULE=fcitx'
*RDI  0x1
*RSI  0x7fffffffde68 —▸ 0x7fffffffe1ef ◂— '/home/eugene/Workspace/hack/debugee'
 R8   0x0
*R9   0x7ffff7fcf6a0 (_dl_fini) ◂— push rbp
*R10  0x7ffff7fcb878 ◂— 0xc00120000000e
*R11  0x7ffff7fe18c0 (_dl_audit_preinit) ◂— mov eax, dword ptr [rip + 0x1b552]
 R12  0x0
*R13  0x7fffffffde78 —▸ 0x7fffffffe213 ◂— 'CLUTTER_IM_MODULE=fcitx'
*R14  0x403e00 (__do_global_dtors_aux_fini_array_entry) —▸ 0x4010f0 (__do_global_dtors_aux) ◂— endbr64                                                                                        
*R15  0x7ffff7ffd020 (_rtld_global) —▸ 0x7ffff7ffe2e0 ◂— 0x0
*RBP  0x7fffffffdd50 ◂— 0x1 # 레지스터 외워라 좀;
*RSP  0x7fffffffdd50 ◂— 0x1
*RIP  0x40112a (main+4) ◂— sub rsp, 0x10
─────────────────────────────[ DISASM / x86-64 / set emulate on ]──────────────────────────────
 ► 0x40112a      sub    rsp, 0x10 # 여기서 멈춰 있다고 친절하게 알려줌
   0x40112e      mov    dword ptr [rbp - 4], 0
   0x401135     mov    dword ptr [rbp - 8], 1
   0x40113c     mov    dword ptr [rbp - 0xc], 2
   0x401143     mov    edx, dword ptr [rbp - 8]
   0x401146     mov    eax, dword ptr [rbp - 0xc]
   0x401149     add    eax, edx
   0x40114b     mov    dword ptr [rbp - 4], eax
   0x40114e     mov    eax, dword ptr [rbp - 4]
   0x401151     mov    esi, eax
   0x401153     lea    rax, [rip + 0xeaa]
───────────────────────────────────────────[ STACK ]───────────────────────────────────────────
00:0000│ rbp rsp 0x7fffffffdd50 ◂— 0x1
01:0008│         0x7fffffffdd58 —▸ 0x7ffff7df318a (__libc_start_call_main+122) ◂— mov edi, eax
02:0010│         0x7fffffffdd60 ◂— 0x0
03:0018│         0x7fffffffdd68 —▸ 0x401126 (main) ◂— push rbp
04:0020│         0x7fffffffdd70 ◂— 0x100000000
05:0028│         0x7fffffffdd78 —▸ 0x7fffffffde68 —▸ 0x7fffffffe1ef ◂— '/home/eugene/Workspace/hack/debugee'
06:0030│         0x7fffffffdd80 —▸ 0x7fffffffde68 —▸ 0x7ffffffhack/debugee'
07:0038│         0x7fffffffdd88 ◂— 0x2181d7828d77fade
─────────────────────────────────────────[ BACKTRACE ]────────
 ► f 0         0x40112a main+4
   f 1   0x7ffff7df318a __libc_start_call_main+122
   f 2   0x7ffff7df3245 __libc_start_main+133
   f 3         0x401061 _start+33 # entry point + 33 byte
                                                                    # 실제 프로그램이 시작하는 시점은 main이 아니다!
──────────────────────────────────────────────────────────────
pwndbg>

break point 잡기

메인에 걸어두는 습관이 있으면 좋다.

여러개 걸어둘 수 있다. 그리고 순서도 상관 없다.

pwndbg> break *main # 메인 함수에 브레이크 걸라는 명령
Breakpoint 1 at 0x401126 # 메인 함수에서 break 걸었다!

run (r도 가능)

중단점 설정된곳까지 실행

pwndbg> run # 프로그램 실행
Starting program: /home/eugene/Workspace/hack/debugee 
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".                                                  

Breakpoint 1, 0x0000000000401126 in main ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
────[ REGISTERS / show-flags off / show-compact-regs off ]────
*RAX  0x401126 (main) ◂— push rbp
*RBX  0x7fffffffde68 —▸ 0x7fffffffe1ef ◂— '/home/eugene/Workspace/hack/debugee'
*RCX  0x403e00 (__do_global_dtors_aux_fini_array_entry) —▸ 0x4010f0 (__do_global_dtors_aux) ◂— endbr64                      
*RDX  0x7fffffffde78 —▸ 0x7fffffffe213 ◂— 'CLUTTER_IM_MODULE=fcitx'
*RDI  0x1
*RSI  0x7fffffffde68 —▸ 0x7fffffffe1ef ◂— '/home/eugene/Workspace/hack/debugee'
 R8   0x0
*R9   0x7ffff7fcf6a0 (_dl_fini) ◂— push rbp
*R10  0x7ffff7fcb878 ◂— 0xc00120000000e
*R11  0x7ffff7fe18c0 (_dl_audit_preinit) ◂— mov eax, dword ptr [rip + 0x1b552]                                              
 R12  0x0
*R13  0x7fffffffde78 —▸ 0x7fffffffe213 ◂— 'CLUTTER_IM_MODULE=fcitx'
*R14  0x403e00 (__do_global_dtors_aux_fini_array_entry) —▸ 0x4010f0 (__do_global_dtors_aux) ◂— endbr64                      
*R15  0x7ffff7ffd020 (_rtld_global) —▸ 0x7ffff7ffe2e0 ◂— 0x0
*RBP  0x1
*RSP  0x7fffffffdd58 —▸ 0x7ffff7df318a (__libc_start_call_main+122) ◂— mov edi, eax                                         
*RIP  0x401126 (main) ◂— push rbp
─────────────[ DISASM / x86-64 / set emulate on ]─────────────
 ► 0x401126        push   rbp # 여기서 멈췄다! 우리가 원했던 메인함수에 브레이크 걸림
   0x401127      mov    rbp, rsp
   0x40112a      sub    rsp, 0x10
   0x40112e      mov    dword ptr [rbp - 4], 0
   0x401135     mov    dword ptr [rbp - 8], 1
   0x40113c     mov    dword ptr [rbp - 0xc], 2
   0x401143     mov    edx, dword ptr [rbp - 8]
   0x401146     mov    eax, dword ptr [rbp - 0xc]
   0x401149     add    eax, edx
   0x40114b     mov    dword ptr [rbp - 4], eax
   0x40114e     mov    eax, dword ptr [rbp - 4]
──────────────────────────[ STACK ]───────────────────────────
00:0000│ rsp 0x7fffffffdd58 —▸ 0x7ffff7df318a (__libc_start_call_main+122) ◂— mov edi, eax                                  
01:0008│     0x7fffffffdd60 ◂— 0x0
02:0010│     0x7fffffffdd68 —▸ 0x401126 (main) ◂— push rbp
03:0018│     0x7fffffffdd70 ◂— 0x100000000
04:0020│     0x7fffffffdd78 —▸ 0x7fffffffde68 —▸ 0x7fffffffe1ef ◂— '/home/eugene/Workspace/hack/debugee'                    
05:0028│     0x7fffffffdd80 —▸ 0x7fffffffde68 —▸ 0x7fffffffe1ef ◂— '/home/eugene/Workspace/hack/debugee'                    
06:0030│     0x7fffffffdd88 ◂— 0xc884d300c9241961
07:0038│     0x7fffffffdd90 ◂— 0x0
────────────────────────[ BACKTRACE ]─────────────────────────
 ► f 0         0x401126 main
   f 1   0x7ffff7df318a __libc_start_call_main+122
   f 2   0x7ffff7df3245 __libc_start_main+133
   f 3         0x401061 _start+33
──────────────────────────────────────────────────────────────

continue

pwndbg> continue # 얘를 입력하면 프로그램이 끝까지 실행됨
Continuing.
1 + 2 = 3
[Inferior 1 (process 17990) exited normally]

gdb 명령어 요약

b : break
c : continue
r : run
si : step into ( 함수로 들어감 )
ni next instruction ( 함수를 넘어감 )
i : info
k : kill
pd : pdisas

disassemble

특정 부분의 어셈블리 코드를 볼 수 있다.

유사한 명령어 : u, nearpc, pdisassemble

pwndbg> disassemble main
Dump of assembler code for function main:
   0x0000000000401126 <+0>:     push   rbp
   0x0000000000401127 <+1>:     mov    rbp,rsp
   0x000000000040112a <+4>:     sub    rsp,0x10
   0x000000000040112e <+8>:     mov    DWORD PTR [rbp-0x4],0x0
   0x0000000000401135 <+15>:    mov    DWORD PTR [rbp-0x8],0x1
   0x000000000040113c <+22>:    mov    DWORD PTR [rbp-0xc],0x2
   0x0000000000401143 <+29>:    mov    edx,DWORD PTR [rbp-0x8]
   0x0000000000401146 <+32>:    mov    eax,DWORD PTR [rbp-0xc]
   0x0000000000401149 <+35>:    add    eax,edx
   0x000000000040114b <+37>:    mov    DWORD PTR [rbp-0x4],eax
   0x000000000040114e <+40>:    mov    eax,DWORD PTR [rbp-0x4]
   0x0000000000401151 <+43>:    mov    esi,eax
   0x0000000000401153 <+45>:    lea    rax,[rip+0xeaa]        # 0x402004                                                    
   0x000000000040115a <+52>:    mov    rdi,rax
   0x000000000040115d <+55>:    mov    eax,0x0
   0x0000000000401162 <+60>:    call   0x401030 
   0x0000000000401167 <+65>:    mov    eax,0x0
   0x000000000040116c <+70>:    leave
   0x000000000040116d <+71>:    ret
End of assembler dump.

ni, si

공통점 : 어세믈리 명령어를 한줄 씩 실행

차이점 :

ni : 서브루틴의 내부로 들어가지 않음

si : 서브루틴의 내부로 진입

pwndbg> b *main+40
Breakpoint 2 at 0x40114e
pwndbg> b *main
Breakpoint 3 at 0x401126
# 일단은 두 군데에 브레이크 걸어둠
# si, ni 사용할때마다 한칸씩 앞으로 감
# continue는 브레이크 걸린 부분까지 하이패스

📌 si로 진입 후 함수 끝까지 한번에 실행하 : finish

메모리 값 확인

x/숫자단위포맷 시작주소
x/10gx $rsp

→ rsp에서 80바이트를 8바이트씩 hex형식으로 출력

📌 o : 8진법

x : 16진법

u : 10진법

t : 2진법

b : 1byte 단위

h : 2byte 단위 half word

w : 4byte 단위 word

g : 8byte 단위 giant

i : 역어셈블된 명령어의 명령 메모리를 볼 수 있음

c : ASCII 표의 바이트를 자동으로 볼 수 있음

S : 문자 데이터의 전체 문자열을 보여줌

pwndbg> x/10gx $rsp # rsp에서 80byte를 8byte씩 hex형식으로 출력
0x7fffffffdd98: 0x00007ffff7df318a      0x0000000000000000
0x7fffffffdda8: 0x0000000000401126      0x0000000100000000
0x7fffffffddb8: 0x00007fffffffdea8      0x00007fffffffdea8
0x7fffffffddc8: 0xe93492b27d999a21      0x0000000000000000
0x7fffffffddd8: 0x00007fffffffdeb8      0x0000000000403e00

pwndbg> x/5i $rip # rip부터 5줄의 어셈블리 명령어 출력
=> 0x401126 :     push   rbp
   0x401127 :   mov    rbp,rsp
   0x40112a :   sub    rsp,0x10
   0x40112e :   mov    DWORD PTR [rbp-0x4],0x0
   0x401135 :  mov    DWORD PTR [rbp-0x8],0x1

pwndbg> x/s 0x400000 # 특정 주소의 문자열 출력
0x400000:       "\177ELF\002\001\001"

변수값 확인 : print

pwndbg> print args
$1 = 2

pwndbg> print argv[0]
$2 = 0x7fffffffe20b "/home/eugene/Workspace/hack/bugfile"

레지스터 값 확인 : info reg

pwndbg> info reg # 레지스터 전체값 
rax            0x555555555149      93824992235849
rbx            0x7fffffffde88      140737488346760
rcx            0x555555557dd8      93824992247256
rdx            0x7fffffffdea0      140737488346784
rsi            0x7fffffffde88      140737488346760
rdi            0x2                 2
rbp            0x7fffffffdd70      0x7fffffffdd70
rsp            0x7fffffffdd50      0x7fffffffdd50
r8             0x0                 0
r9             0x7ffff7fcf6a0      140737353938592
r10            0x7ffff7fcb878      140737353922680
r11            0x7ffff7fe18c0      140737354012864
r12            0x0                 0
r13            0x7fffffffdea0      140737488346784
r14            0x555555557dd8      93824992247256
r15            0x7ffff7ffd020      140737354125344
rip            0x555555555158      0x555555555158 
eflags         0x206               [ PF IF ]
cs             0x33                51
ss             0x2b                43
ds             0x0                 0
es             0x0                 0
fs             0x0                 0
gs             0x0                 0

pwndbg> info reg $rsp # 특정 레지스터 값
rsp            0x7fffffffdd50      0x7fffffffdd50

스택 확인

x/[조회하는 메모리 범위]xw[조회하는 메모리 지점]

0x7fffffffdd50: 0xffffde88      0x00007fff      0x00000000      0x00000002
0x7fffffffdd60: 0x00000000      0x00000000      0x00000000      0x00000000
0x7fffffffdd70: 0x00000002      0x00000000      0xf7df318a      0x00007fff
0x7fffffffdd80: 0x00000000      0x00000000      0x55555149      0x00005555
0x7fffffffdd90: 0x00000000      0x00000002      0xffffde88      0x00007fff
0x7fffffffdda0: 0xffffde88      0x00007fff      0xc2fecbe3      0x6cd326ff
0x7fffffffddb0: 0x00000000      0x00000000      0xffffdea0      0x00007fff
0x7fffffffddc0: 0x55557dd8      0x00005555      0xf7ffd020      0x00007fff

후기

어렵지만 재밌다.

[Numpy] 배열 생성

Wed, 05 Apr 2023 07:47:56 GMT

Numpy 배열과 텐서

배열 생성

float 타입의 vector 생성

import numpay as np //  Numpy 호출
test_array = np.array([1, 4, 5, 8], float) 
// 생성할 데이터, 데이터 타입

m x n 형태의 행렬

import numpy as np
test_list = [[1,4,5,8],[1,4,5,8]]
np.array(test_list, float)

test_array2 = [[1,4,5,8],[1,4,5]] // 모든 데이터가 채워져 있어야 함 np.array(test_list2, float) // ValueError

⚠️ 동적 타이핑은 지원하지 않음 ⚠️
```python
import numpy as np
test_array = np.array([1,4,5,8], float)
test_array

// output
array([1.,4.,5.,8.])

Numpy array와 Python list간의 차이점은?

Python list : 메모리상에 연속적으로 배열되어 있는 것이 아니라 해당 값의 메모리 주소만 연속적으로 배열 Numpy array : 실제 값을 메모리상에서 연속적으로 나열, 각 값들의 메모리 크기가 동일해야 함

배열 생성 예시

import numpy as np
test_array = np.array([1,3,5,"8"], float)
print(test_array)

// output
[1. 3. 5. 8.]

자동 형 변환

print(type(test_array[3]) # 실수형으로 자동 형 변환 실시

# output

배열 전체의 데이터 타입 반환 .dtype

print(test_array.dtype) 
# output
float64 # 메모리에 8바이트씩 할당

# 정수형 Numpy 배열로 생성
np.array([[1,2,3.5], [4, 5, 6.4]], dtype=int) 
# output
array([[1,2,3],
       [4,5,6]])

배열의 구조(Shape) 반환 .shape

📌 배열의 구조(shape) 배열 객체의 차원 구성이 어떠한지 나타내는 함수

print(test_array.shape)
# output
(4,) # 튜플 형태
# 1차원의 랭크를 가지면서 4개의 요소를 가지고 있는 Numpy 배열

matrix = [[1,2,3,5], [1,2,5,7], [2,4,6,7]]
np.array(matrix, int).shape
# output
(3, 4)
# 앞의 값은 행(row), 뒤의 값은 열(column)이다.
# 2차원 랭크를 가지면서 3행 4열의 요소를 가지고 있는 Numpy배열

랭크 반환 .ndim

배열의 모든 데이터 개수 .size

배열 요소의 크기 반환 .itemsize

ㅇ