미친해커

[Android] Run Applications as Root for Android

미친해커 — Thu, 6 Jun 2024 05:41:30 +0900

글을 시작하기 전 양해 말씀드립니다. 저는 안드로이드, 리눅스 운영체제에 대해 자세히 알지 못해 인터넷 검색과 연구하면서 알아낸 결과로 추측하여 글을 작성했습니다. 잘못된 정보가 있다면 댓글 부탁드립니다.

How do you typcially run an application as root?

Root 권한으로 애플리케이션을 실행하는 방법은 안드로이드 5.0을 기준으로 이전과 이후로 나뉘게 된다.

또한 현재 안드로이드 운영체제는 기본적으로 시스템 앱(System Application)이 아닌 일반 앱(Application)은 Root 권한으로 실행할 수 없다고 한다.

Before Android 5.0

안드로이드 5.0 이전에는 AndroidManifest.xml에 android.permission.ACCESS_SUPERUSER 권한을 선언하면 가능하다.

After Android 5.0

안드로이드 5.0 이후에는 일반 앱을 Root 권한으로 실행하는 것은 불가능하다. Android 5.0 Lolipop에서부터 android.permission.ACCESS_SUPERUSER가 없어지게 돼 사용되지 않다.

다음 사이트에서 그 내용을 확인할 수 있다.

How-To SU

0. Table of Contents 0 Table of Contents 1 Introduction 2 Code: libsuperuser 3 How to call su 3.1 Common pitfalls 3.2 Making the call 3.3 Checking for su availability 3.4 Checking for

su.chainfire.eu

How applications run on Android (Background Knowledge)

안드로이드 5.0 이후에서 애플리케이션을 Root 권한으로 실행시키는 것이 완전히 불가능한 것은 아니다.

Root 권한으로 애플리케이션을 실행하기 위해서는 먼저 안드로이드의 애플리케이션이 어떤 원리로 실행되는지 알아야 할 필요가 있다.

What language is the application written?

우리가 알고 있다시피 안드로이드 애플리케이션은 주로 Java(자바)로 작성되어 있다. 그렇기 때문에 리눅스인 안드로이드에서 네이티브 프로세스로 실행될 수 없다.

Dalvik

Dalvik은 VM이며 DVM이라고도 불린다. Android 4.4(API 19)에서 처음 등장했으며 자바를 구동하는 JVM 대신 사용된다.

Android가 Java를 사용하면서 JVM을 사용하지 않고 DVM을 사용하는 이유는 라이선스와 메모리 효율성 등의 문제가 있다. JVM이나 DVM이나 모두 Java를 사용한 VM이기에 애플리케이션을 동작하는데 문제는 존재하지 않는다.

Zygote

앞서 말했 듯이 안드로이드 애플리케이션은 달빅(Dalvik) 가상 머신에서 동작한다. 각 안드로이드 애플리케이션은 독립적으로 가상 머신 위에서 동작할 것이며 실행될 때마다 가상 머신을 초기화한다. 즉, 안드로이드 애플리케이션이 실행될 때마다 많은 과정이 필요하고 이로 인해 많은 시간이 소요 돼 애플리케이션의 실행을 지연시킨다.

안드로이드에는 Zygote(자이고트)라는 이름의 프로세스가 존재하는데 Zygote는 애플리케이션이 실행되기 전에 가상 머신의 코드 및 메모리 정보를 공유함으로써 애플리케이션이 실행되는 시간을 단축시킬 수 있다.

Zygote는 가상 머신의 코드 및 메모리뿐만 아니라 안드로이드 프레임워크에서 동작하는 애플리케이션이 사용할 클래스와 자원을 미리 로딩해 해당 자원에 대한 연결 정보를 구성한다. 이 덕분에 새로 실행되는 애플리케이션은 필요한 자원들에 대한 연걸 정보를 매번 구성하지 않아도 되기 때문에 빠르기 실행된다.

Process creation(Application execution) via Zygote

Zygote는 안드로이드 애플리케이션이 실행될 때 필요한 달빅 가상 머신의 초기화와 자원들을 미리 로딩되어 있는데 어떻게 이 리소스를 사용해 애플리케이션을 실행시킬 수 있을까? 바로 fork(clone) 시스템 콜이다.

fork 함수는 새로운 자식 프로세스를 생성하고 새로 생성된 프로세스는 부모 프로세스의 메모리 구성 정보 및 공유 라이브러리에 대한 링크 정보를 공유한 상태이다. 프로세스가 그대로 복제되는 셈이다. Zygote는 fork를 사용해 자신을 복제한 후 그 위에 안드로이드 애플리케이션을 로드함으로써 애플리케이션을 실행한다.

What is app_process?

Zygote 또한 자바로 작성되어 있어 다른 네이티브 서비스나 데몬처럼 init 프로세스에서 바로 실행할 수 없다. 그렇기 때문에 Zygote는 app_process를 통해 Dalvik VM을 초기화한 후 ZygoteInit 클래스를 로딩해 실행하는 절차를 거친다.

init 프로세스는 app_process와 더불어 다양한 데몬 프로세스를 실행시키는데 이는 /init.zygote64_32.rc 파일에서 확인할 수 있다. (AArch64의 경우 x86과 x64 두 개의 zygote가 실행된다. 해당 글에서 zygote는 app_process64만을 의미한다)

service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
    class main
    socket zygote stream 660 root system
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart audioserver
    onrestart restart cameraserver
    onrestart restart media
    onrestart restart netd
    writepid /dev/cpuset/foreground/tasks

service zygote_secondary /system/bin/app_process32 -Xzygote /system/bin --zygote --socket-name=zygote_secondary
    class main
    socket zygote_secondary stream 660 root system
    onrestart restart zygote
    writepid /dev/cpuset/foreground/tasks

위 정의에서 알 수 있듯이 app_process는 zygote의 "진짜 이름"으로 app_process가 init 프로세스의 의해 서비스 데몬으로 실행되어 ZygoteInit 클래스 를 로딩해 Zygote를 실행한다.

/system/bin/app_process 는 /system/bin/app_process64 의 심볼릭 링크이다.

Guess the workflow of Zygote

Zygote가 안드로이드 애플리케이션을 실행시킨다는 사실을 우리는 알았을 때 바로 알 수 있는 한 가지 있다. 바로 Zygote는 init 프로세스의 의해 서비스 데몬으로 실행되기에 Root 권한으로 실행된다는 것이다. 그렇다면 Zygote의 자식 프로세스로 실행되는 안드로이드 애플리케이션도 "원래"는 Root 권한으로 실행되었던 적이 있다는 사실이다.

com.termux 애플리케이션의 부모와 조부모인 zygote와 init는 Root권한이지만 com.termux 애플리케이션은 Root 권한이 아닌 일반적인 애플리케이션 권한으로 내려가 있는 것을 확인할 수 있다.

위와 같은 사실을 통해 Zygote가 안드로이드 애플리케이션을 로드한 후 자신의 권한을 낮춘 다음에 안드로이드 애플리케이션(MainActivity)을 호출한다는 의미가 된다.

Zygote source code anaysis

Zygote 프로세스의 워크플로우를 추측했으니 이제 Zygote의 소스코드를 분석해보려고 한다.

(안드로이드 7.1.2 Release 39 기준)

중요하다고 생각되는 함수가 호출되는 윗 라인에 주석을 달아놓았고 주석에 1), 2) 와 같이 작성되어 있는 함수는 후에 서술할 안드로이드 애플리케이션을 Root 권한으로 실행하는데 영향을 끼치는 함수들로 아래에서 따로 부가적인 설명이 존재한다.

ZygoteInit.main() 부터 안드로이드 애플리케이션 호출까지의 과정은 더보기를 눌러주세요

ZygoteInit.main() 부터 안드로이드 애플리케이션의 호출까지의 과정이다.

core/java/com/android/internal/os/ZygoteInit.java - platform/frameworks/base - Git at Google

* Copyright (C) 2007 The Android Open Source Project * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * http://www.apache.org/lice

android.googlesource.com

Call Trace
[1] core/java/com/android/internal/os/ZygoteInit.java - main()

/*
https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-7.1.2_r39/core/java/com/android/internal/os/ZygoteInit.java#712
Line 712
*/
public static void main(String argv[]) {

    /* 중간 생략 */
    
    try {
    
        /* 중간 생략 */
        
        boolean startSystemServer = false;
        String socketName = "zygote";
        String abiList = null;
        for (int i = 1; i < argv.length; i++) {
            if ("start-system-server".equals(argv[i])) {
                // Zygote를 호출할 때 --start-system-server 플래그가 존재
                startSystemServer = true;
            } else if (argv[i].startsWith(ABI_LIST_ARG)) {
                abiList = argv[i].substring(ABI_LIST_ARG.length());
            } else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
                socketName = argv[i].substring(SOCKET_NAME_ARG.length());
            } else {
                throw new RuntimeException("Unknown command line argument: " + argv[i]);
            }
        }
        if (abiList == null) {
            throw new RuntimeException("No ABI list supplied.");
        }
        
        /*
        안드로이드 애플리케이션 실행을 위한 요청 수신을 받기 위한 소켓 등록
        UDS(Unix Domain Socket)을 사용하며 init.rc에서 app_process를 실행할 때 등록했던 소켓을 이용
        socket zygote stream 660 root system
        */
        registerZygoteSocket(socketName);
        
        /* 중간 생략 */
        
        /*
        Classes, Resources, OpenGL, Shared Libraries, Text Resources 등을 로드
        내부에서 다음 각 함수를 호출
        preloadClasses()
        preloadResources()
        preloadOpenGL()
        preloadSharedLibraries()
        preloadTextResources()
        */
        preload();
        
        /* 중간 생략 */
        
        /*
        UDS를 모니터링 하면서 안드로이드 애플리케이션 생성 요청을 처리하는 루프를 실행
        */
        runSelectLoop(abiList);
        closeServerSocket();
    } catch (MethodAndArgsCaller caller) {
        caller.run();
    } catch (Throwable ex) {
        Log.e(TAG, "Zygote died with exception", ex);
        closeServerSocket();
        throw ex;
    }
}

Call Trace

[1] core/java/com/android/internal/os/ZygoteInit.java - main()
[2] core/java/com/android/internal/os/ZygoteInit.java - runSelectLoop()

/*
https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-7.1.2_r39/core/java/com/android/internal/os/ZygoteInit.java#825
Line 825
*/
private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
    // 안드로이드 애플리케이션 실행 요청 소켓을 저장할 리스트
    ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
    // 안드로이드 애플리케이션 실행 대기 리스트
    ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
    fds.add(sServerSocket.getFileDescriptor());
    peers.add(null);
    while (true) {
    
        /* 중간 생략 */
        
        for (int i = pollFds.length - 1; i >= 0; --i) {
            if ((pollFds[i].revents & POLLIN) == 0) {
                continue;
            }
            if (i == 0) {
                // 0번 index에서 이벤트 발생 -> 안드로이드 애플리케이션 실행 요청이 들어옴
                ZygoteConnection newPeer = acceptCommandPeer(abiList);
                peers.add(newPeer);
                fds.add(newPeer.getFileDesciptor());
            } else {
                // 안드로이드 애플리케이션 실행
                boolean done = peers.get(i).runOnce();
                if (done) {
                    peers.remove(i);
                    fds.remove(i);
                }
            }
        }
    }
}

core/java/com/android/internal/os/ZygoteConnection.java - platform/frameworks/base - Git at Google

android.googlesource.com

/*
https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-7.1.2_r39/core/java/com/android/internal/os/ZygoteConnection.java#132
Line 132
*/
boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {

    /* 중간 생략 */
    
    int pid = -1;
    FileDescriptor childPipeFd = null;
    FileDescriptor serverPipeFd = null;
    try {
    
        /* 중간 생략 */
        
        // 애플리케이션 실행을 위해 fork() 및 권한 등 설정
        pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
                parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
                parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
                parsedArgs.appDataDir);
    } catch (ErrnoException ex) {
        logAndPrintError(newStderr, "Exception creating pipe", ex);
    } catch (IllegalArgumentException ex) {
        logAndPrintError(newStderr, "Invalid zygote arguments", ex);
    } catch (ZygoteSecurityException ex) {
        logAndPrintError(newStderr,
                "Zygote security policy prevents request: ", ex);
    }
    
    /* 중간 생략 */
}

core/java/com/android/internal/os/Zygote.java - platform/frameworks/base - Git at Google

* Copyright (C) 2014 The Android Open Source Project * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * http://www.apache.org/lice

android.googlesource.com

/*
https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-7.1.2_r39/core/java/com/android/internal/os/Zygote.java#91
Line 91
*/
// Forks a new VM instance. The current VM must have been started with the -Xzygote flag.
public static int forkAndSpecialize(int uid, int gid, int[] gids, int debugFlags,
      int[][] rlimits, int mountExternal, String seInfo, String niceName, int[] fdsToClose,
      String instructionSet, String appDataDir) {
    VM_HOOKS.preFork();
    
    /*
    C/C++ 코드로 작성된 네이티브 함수를 호출
    함수 안에서 인자의 있는 uid와 gid로 프로세스의 uid와 gid가 변경 됨
    */
    int pid = nativeForkAndSpecialize(
              uid, gid, gids, debugFlags, rlimits, mountExternal, seInfo, niceName, fdsToClose,
              instructionSet, appDataDir);
              
    // Enable tracing as soon as possible for the child process.
    if (pid == 0) {
        Trace.setTracingEnabled(true);
        // Note that this event ends at the end of handleChildProc,
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "PostFork");
    }
    VM_HOOKS.postForkCommon();
    return pid;
}

core/jni/com_android_internal_os_Zygote.cpp - platform/frameworks/base - Git at Google

* Copyright (C) 2008 The Android Open Source Project * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * http://www.apache.org/lice

android.googlesource.com

Call Trace
[1] core/java/com/android/internal/os/ZygoteInit.java - main()
[2] core/java/com/android/internal/os/ZygoteInit.java - runSelectLoop()
[3] core/java/com/android/internal/os/ZygoteConnection.java - runOnce()
[4] core/java/com/android/internal/os/Zygote.java - forkAndSpecialize()
[5] core/jni/com_android_internal_os_Zygote.cpp - nativeForkAndSpecialize()

/*
https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-7.1.2_r39/core/jni/com_android_internal_os_Zygote.cpp#652
Line 652
*/
static jint com_android_internal_os_Zygote_nativeForkAndSpecialize(
        JNIEnv* env, jclass, jint uid, jint gid, jintArray gids,
        jint debug_flags, jobjectArray rlimits,
        jint mount_external, jstring se_info, jstring se_name,
        jintArray fdsToClose, jstring instructionSet, jstring appDataDir) {
    jlong capabilities = 0;
    
    /* 중간 생략 */
    
    /*
    Utility routine to fork zygote and specialize the child process.
    Zygote가 fork()를 통해 애플리케이션 실행할 때 호출되는 네이티브 함수
    */
    return ForkAndSpecializeCommon(env, uid, gid, gids, debug_flags,
            rlimits, capabilities, capabilities, mount_external, se_info,
            se_name, false, fdsToClose, instructionSet, appDataDir);
}

core/jni/com_android_internal_os_Zygote.cpp - platform/frameworks/base - Git at Google

android.googlesource.com

/*
https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-7.1.2_r39/core/jni/com_android_internal_os_Zygote.cpp#444
Line 444
*/
// Utility routine to fork zygote and specialize the child process.
static pid_t ForkAndSpecializeCommon(JNIEnv* env, uid_t uid, gid_t gid, jintArray javaGids,
                                     jint debug_flags, jobjectArray javaRlimits,
                                     jlong permittedCapabilities, jlong effectiveCapabilities,
                                     jint mount_external,
                                     jstring java_se_info, jstring java_se_name,
                                     bool is_system_server, jintArray fdsToClose,
                                     jstring instructionSet, jstring dataDir) {
  /* 중간 생략 */
  
  /*
  Zygote 프로세스 복제(fork)
  fork()로 생성된 프로세스가 안드로이드 애플리케이션으로 실행 됨
  */
  pid_t pid = fork();
  
  if (pid == 0) {
    // 안드로이드 애플리케이션으로 실행되는 자식 프로세스 루틴
    // The child process.
    
    /* 중간 생략 */
    
    /*
    후에 인자로 들어온 uid 값으로 UID를 변경하게 되는데 이때 UID를 변경해도
    Root의 기능을 유지할 수 있도록 설정
    
    이 기능은 함수를 호출한 쓰레드에서만 동작함
    즉, UID 변경 후에도 현재 쓰레드는 Root 권한을 행사할 수 있지만 
    다른 쓰레드는 그러지 못함
    */
    // Keep capabilities across UID change, unless we're staying root.
    if (uid != 0) {
      EnableKeepCapabilities(env);
    }
    
    /*
    1) 안드로이드 애플리케이션이 실행된 이후에 Capability를 얻지 못하게 하기 위해
    Root 권한이 소유할 수 있는 모든 Capability BoundingSet을 Drop 함
    
    BoundingSet : 프로세스가 실행 중인 동안 얻을 수 있는 Capability
    */
    DropCapabilitiesBoundingSet(env);
    
    /* 중간 생략 */
    
    /*
    2) 프로세스의 Real, Effective, Saved GID를 설정
    
    현재 함수의 인자에는 gid가 존재한다. 해당 인자에는 설정되어야 하는
    안드로이드 애플리케이션의 gid가 넘어온다. 해당 gid로 프로세스의
    egid, egid, sgid를 설정한다.
    */
    int rc = setresgid(gid, gid, gid);
    if (rc == -1) {
      ALOGE("setresgid(%d) failed: %s", gid, strerror(errno));
      RuntimeAbort(env, __LINE__, "setresgid failed");
    }
    
    /*
    3) 프로세스의 Real, Effective, Saved UID를 설정
    
    현재 함수의 인자에는 uid가 존재한다. 해당 인자에는 설정되어야 하는
    안드로이드 애플리케이션의 uid가 넘어온다. 해당 uid로 프로세스의
    euid, euid, suid를 설정한다.
    */
    rc = setresuid(uid, uid, uid);
    if (rc == -1) {
      ALOGE("setresuid(%d) failed: %s", uid, strerror(errno));
      RuntimeAbort(env, __LINE__, "setresuid failed");
    }
    
    /* 중간 생략 */
    
    /*
    4) 함수의 인자에는 permittedCapabilities와 effectiveCapabilities가 존재한다.
    이는 실행하려는 안드로이드 애플리케이션이 특정 루트 권한의 기능이 필요한 경우
    Capability를 이용해 해당 기능을 사용할 수 있도록 설정 하는 것이다.
    
    거의 대부분의 일반적인 안드로이드 애플리케이션은 아무런 권한도 설정되지 않는다.
    */
    SetCapabilities(env, permittedCapabilities, effectiveCapabilities);
    
    /* 중간 생략 */
    
    /*
    안드로이드 애플리케이션의 실행 준비가 완료되었다면 다음 함수를 통해
    안드로이드 애플리케이션을 호출(실행)한다.
    */
    env->CallStaticVoidMethod(gZygoteClass, gCallPostForkChildHooks, debug_flags,
                              is_system_server, instructionSet);                          
    if (env->ExceptionCheck()) {
      RuntimeAbort(env, __LINE__, "Error calling post fork hooks.");
    }
  } else if (pid > 0) {
    // the parent process
    /* 중간 생략 */
  }
  return pid;
}

안드로이드 애플리케이션의 실행 과정을 추측한 후에 실제로 소스코드를 분석했을 때 거의 100% 추측 결과와 일치했다.

안드로이드 애플리케이션을 호출하기 전에 소스코드에 주석으로 표시한 4개의 함수를 통해 프로세스 스스로의 권한을 낮춘 후 CallStaticVoidMethod() 함수를 통해 안드로이드 애플리케이션 함수를 호출한다.

Call Trace
[1] core/java/com/android/internal/os/ZygoteInit.java - main()
[2] core/java/com/android/internal/os/ZygoteInit.java - runSelectLoop()
[3] core/java/com/android/internal/os/ZygoteConnection.java - runOnce()
[4] core/java/com/android/internal/os/Zygote.java - forkAndSpecialize()
[5] core/jni/com_android_internal_os_Zygote.cpp - nativeForkAndSpecialize()
[6] core/jni/com_android_internal_os_Zygote.cpp - ForkAndSpecializeCommon()
 └ static void DropCapabilitiesBoundingSet(JNIEnv* env);
 └ int setresgid(gid_t rgid, gid_t egid, gid_t sgid); // Kernel Function
 └ int setresuid(uid_t ruid, uid_t euid, uid_t suid); // Kernel Function
 └ static void SetCapabilities(JNIEnv* env, int64_t permitted, int64_t effective);

setresgid()와 setresuid() 함수는 커널 함수로 프로세스의 gid와 uid를 변경하는 함수이다. 다음 링크에 더 자세한 설명이 작성되어 있다.

setresuid(2) - Linux manual page

setresuid(2) — Linux manual page setresuid(2) System Calls Manual setresuid(2) NAME top setresuid, setresgid - set real, effective, and saved user or group ID LIBRARY top Standard C library (libc, -lc) SYNOPSIS top #de

man7.org

/*
https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-7.1.2_r39/core/jni/com_android_internal_os_Zygote.cpp#227
Line 227
*/
static void DropCapabilitiesBoundingSet(JNIEnv* env) {
  /*
  i의 값에 해당되는 Capability를 가져옴 Capability가 존재한다면
  0 이상을 반환, 존재하지 않는다면 음수를 반환
  */
  for (int i = 0; prctl(PR_CAPBSET_READ, i, 0, 0, 0) >= 0; i++) {
    /*
    현재 프로세스에서 i 값의 Capability를 BoundingSet에서 제거
    
    Capability가 바운딩(Bounding)되어 있지 않다면 허가(Permiited)되더라도
    실제(Effective)로 사용할 수 없다. 이는 Root 권한이라고 할지라도 바운딩과
    허가되어 있지 않다며 Root 권한으로써 기능을 수행할 수 없다
    */
    int rc = prctl(PR_CAPBSET_DROP, i, 0, 0, 0);
    if (rc == -1) {
      if (errno == EINVAL) {
        ALOGE("prctl(PR_CAPBSET_DROP) failed with EINVAL. Please verify "
              "your kernel is compiled with file capabilities support");
      } else {
        RuntimeAbort(env, __LINE__, "prctl(PR_CAPBSET_DROP) failed");
      }
    }
  }
}

/*
https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-7.1.2_r39/core/jni/com_android_internal_os_Zygote.cpp#241
Line 241
*/
static void SetCapabilities(JNIEnv* env, int64_t permitted, int64_t effective) {
  __user_cap_header_struct capheader;
  memset(&capheader, 0, sizeof(capheader));
  capheader.version = _LINUX_CAPABILITY_VERSION_3;
  capheader.pid = 0;
  
  __user_cap_data_struct capdata[2];
  memset(&capdata, 0, sizeof(capdata));
  capdata[0].effective = effective;
  capdata[1].effective = effective >> 32;
  capdata[0].permitted = permitted;
  capdata[1].permitted = permitted >> 32;
  
  /*
  capset 함수를 통해 effective와 permitted capability를 설정한다.
  
  일반적인 안드로이드 애플리케이션의 경우에는 아무런 값도 설정되지 않는다.
  이는 실제(Effective)로 사용 가능한 기능과 사용에 허가(Permitted) 받은
  Capability를 모두 지우겠다는 말이 된다.
  */
  if (capset(&capheader, &capdata[0]) == -1) {
    ALOGE("capset(%" PRId64 ", %" PRId64 ") failed", permitted, effective);
    RuntimeAbort(env, __LINE__, "capset failed");
  }
}

최종적으로 ForkAndSpecializeCommon() 함수의 시작부터 안드로이드 애플리케이션 시작까지 소스 코드의 워크 플로우는 다음과 같다.

How to run application as root for Android

Zygote가 프로세스를 실행하기 전 권한들을 모두 Drop하고 uid와 gid를 변경한다. 이때 특정 uid와 gid를 가지고 있는 안드로이드 애플리케이션의 경우에는 Capabilities를 Drop하지 않고 uid와 gid를 변경하지 않도록 함수를 조작할 수 있다면 특정 안드로이드 애플리케이션을 Root 권한으로 실행시키는 것이 가능해진다.

안드로이드 애플리케이션을 Root 권한으로 실행하기 위해 모니터링하며 조작이 필요한 함수는 다음과 같다.

int setresuid(uid_t ruid, uid_t euid, uid_t suid);
int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
int prctl(int option, ...);
int capset(cap_user_header_t hdrp, const cap_user_data_t datap);

Zygote 프로세스의 특정 함수의 동작을 조작하기 위해서 LD_PRELOAD를 사용했다.

[Reversing] LD_PRELOAD를 이용한 후킹

LD_PRELOADLD_PRELOAD는 Linux 운영체제의 환경 변수이다. LD_PRELOAD에는 Linux 운영체제의 공유 라이브러리(Shared Library) 파일이 설정되고 설정된 공유 라이브러리들을 모든 공유 라이브러리들보다 먼저

blog.crazyhacker.kr

LD_PRELOAD로 로드되는 후킹 라이브러리 코드는 다음과 같다.

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>
#include <unistd.h>
#include <sys/prctl.h>
#include <sys/capability.h>
#include <linux/seccomp.h>

pid_t pid = -1;

int (*origin_setresuid)(uid_t ruid, uid_t euid, uid_t suid);
int (*origin_setresgid)(gid_t rgid, gid_t egid, gid_t sgid);
int (*origin_prctl)(int option, ...);
int (*origin_capset)(cap_user_header_t __hdr_ptr, const cap_user_data_t __data_ptr);

void dropCapabilitiesBoundingSet()
{
    for (int i = 0; origin_prctl(PR_CAPBSET_READ, i, 0, 0, 0) >= 0; i++)
    {
        if (origin_prctl(PR_CAPBSET_DROP, i, 0, 0, 0) == -1)
        {
            printf("Failed %d\n", i);
        }
    }
}

int isRootApplication(pid_t uid)
{
    char line[512];
    FILE *package_list = fopen("/data/system/packages.list", "r");
    FILE *root_app_list = fopen("/data/local/tmp/root_app.list", "r");

    if (package_list == NULL || root_app_list == NULL)
        goto exit;

    while (fgets(line, sizeof(line), package_list) != NULL)
    {
        char root_package_name[64];
        char package_name[128];
        pid_t package_uid = -1;
        sscanf(line, "%s %d", package_name, &package_uid);

        if (package_uid == uid)
        {
            while (fgets(root_package_name, sizeof(root_package_name), root_app_list) != NULL)
            {
                if (strncmp(package_name, root_package_name, strlen(package_name)) == 0)
                {
                    fclose(package_list);
                    fclose(root_app_list);
                    return 1;
                }
            }
        }
    }

exit:
    fclose(package_list);
    fclose(root_app_list);
    
    return 0;
}

int capset(cap_user_header_t __hdr_ptr, const cap_user_data_t __data_ptr)
{
    if (pid == getpid())
        return 0;

    if (origin_capset == NULL)
        origin_capset = dlsym(RTLD_NEXT, "capset");

    return origin_capset(__hdr_ptr, __data_ptr);
}

int prctl(int option, ...)
{
    va_list args;
    va_start(args, option);

    long arg2 = va_arg(args, long);
    long arg3 = va_arg(args, long);
    long arg4 = va_arg(args, long);
    long arg5 = va_arg(args, long);

    va_end(args);

    if (option == PR_CAPBSET_DROP)
        return 0;

    if (origin_prctl == NULL)
        origin_prctl = dlsym(RTLD_NEXT, "prctl");

    return origin_prctl(option, arg2, arg3, arg4, arg5);
}

int setresuid(uid_t ruid, uid_t euid, uid_t suid)
{
    if (isRootApplication(ruid))
    {
        pid = getpid();
        dropCapabilitiesBoundingSet();
        return 0;
    }

    if (origin_setresuid == NULL)
        origin_setresuid = dlsym(RTLD_NEXT, "setresuid");

    return origin_setresuid(ruid, euid, suid);
}

int setresgid(gid_t rgid, gid_t egid, gid_t sgid)
{
    if (isRootApplication(rgid))
        return 0;
	
    if (origin_setresgid == NULL)
        origin_setresgid = dlsym(RTLD_NEXT, "setresgid");

    return origin_setresgid(rgid, egid, sgid);
}

How does Zygote run?

LD_PRELOAD를 사용하기 위해서는 Zygote의 환경 변수를 조작해야하기 때문에 Zygote가 어떠한 방식으로 init 프로세스의 의해 실행되는지 알아야할 필요가 있다.

Zygote는 init 프로세스가 자기 자신을 fork() 함수를 통해 복제한 뒤 execve() 함수를 통해 app_process를 실행하는 방식으로 실행된다.

execve() 함수의 원형을 보면 envp 인자가 존재하는데 해당 인자가 실행되는 프로그램의 환경 변수를 설정하게 된다.

int execve(const char *pathname, char *const argv[], char *const envp[]);

Zygote를 실행하기 위해 execve() 함수를 호출할 때 envp 인자에 LD_PRELOAD를 삽입하는 방식으로 조작할 수 있다.

How to set the LD_PRELOAD environment variable on Zygote

Zygote의 함수를 조작하기 위해 Zygote 프로세스의 환경 변수에 LD_PRELOAD를 추가해 해당 함수들을 조작해 안드로이드 애플리케이션이 Root 권한으로 실행될 수 있도록 해야한다.

init 프로세스를 이용해 Zygote 프로세스에 LD_PRELOAD 환경 변수를 삽입하는 순서는 다음과 같다.

※ init 프로세스는 Zygote 프로세스가 종료되었을 때 Zygote 프로세스를 재시작한다. ※
[1] init 프로세스를 ptrace로 감시한다.
[2] 기존 Zygote 프로세스를 KILL 한다.
[3] init 프로세스는 Zygote의 SIGCHLD 시그널을 받고 Zygote 프로세스를 재시작한다.
[4] init 프로세스는 Zygote의 재시작을 위해 fork() 함수를 호출한다. 이때 해당 함수를 통해 생성된 프로세스로 ptrace를 옮긴다.
[5] 새로 생성된 프로세스(New Zygote)에서 execve() 함수로 app_process를 실행한다. 이때 envp 인자에 LD_PRELOAD를 삽입한다.
[6] LD_PRELOAD로 인해 위에서 언급한 4개의 함수가 후킹된 상태로 Zygote 프로세스 실행 성공

PoC Video

PoC 코드는 다음 Github에서 확인할 수 있다.

GitHub - jungjin0003/Run-Application-as-Root-for-Android: Run Application as Root for Android

Run Application as Root for Android. Contribute to jungjin0003/Run-Application-as-Root-for-Android development by creating an account on GitHub.

github.com

[Reversing] LD_PRELOAD를 이용한 후킹

미친해커 — Fri, 3 May 2024 00:19:29 +0900

LD_PRELOAD

LD_PRELOAD는 Linux 운영체제의 환경 변수이다.

LD_PRELOAD에는 Linux 운영체제의 공유 라이브러리(Shared Library) 파일이 설정되고 설정된 공유 라이브러리들을 모든 공유 라이브러리들보다 먼저 프로그램에 로드한다.

Linux 운영체제의 응용 프로그램은 라이브러리가 로드된 순서대로 사용하려는 함수가 존재하는지 확인한다. 이때 LD_PRELOAD로 인해 먼저 로드된 라이브러리에 사용하려는 함수가 존재한다면 LD_PRELOAD의 라이브러리의 함수 주소를 가져온다. 이러한 원리를 이용한 방법이 LD_PRELOAD를 이용한 후킹 기법이다,

*공유 라이브러리(Shared Libary) : Linux 운영체제의 공유 라이브러리로 확장자는 주로 .so 이며 Windows 운영체제의 DLL 파일과 같다.

LD_PRELOAD Environment Variable

Linux 운영체제에서 LD_PRELOAD 환경 변수를 설정하는 방법은 여러가지인데, 그중 자주 사용되는 두 가지 방법이다.

Inline

첫 번째 방법은 특정 프로그램에만 설정하는 방법이다. 이렇게 Shell에서 프로그램을 실행시킬 때 앞에 LD_PRELOAD를 설정해주면 해당 프로그램에만 적용해 실행할 수 있다.

root@ubuntu:~# LD_PRELOAD=/tmp/libtest.so ./example

In the current Shell

두 번째 방법은 현재 쉘에서 실행되는 모든 프로그램에 LD_PRELOAD를 설정하는 방법이다. 다음과 같이 export 명령어를 사용해 Shell에 환경 변수를 설정하면 이후 해당 쉘에서 실행되는 모든 프로그램에 LD_PRELOAD가 설정되어 실행된다.

root@ubuntu:~# export LD_PRELOAD=/tmp/libtest.so
root@ubuntu:~# ./example

Make a shared library to be used for LD_PRELOAD

Linux 운영체제에서 LD_PRELOAD를 사용하는 후킹은 그렇게 어렵지 않다. 기본적으로 함수명만 동일하다면 LD_PRELOAD를 사용해 후킹을 진행할 수 있다. 반환형, 인자 등 함수명을 제외한 그 무엇도 신경쓰지 않지만 정상적으로 인자를 받고 후킹을 진행하기 위해서는 해당 함수의 원형을 사용하는 것이 좋다.

다음과 같은 코드의 프로그램에 LD_PRELOAD를 적용한다고 했을 때의 공유 라이브러리를 만들어보겠다.

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
    char key[] = "This is secret key";
    char buf[64] = { 0 };

    strcpy(buf, key);

    return 0;
}

위 프로그램 비밀키를 buf로 strcpy 함수를 이용해 복사한다. 이때 strcpy 함수를 후킹해 비밀키의 내용을 출력해보려고 한다.

Check prototype of the function to hooking

먼저 strcpy 함수의 원형을 알아보자. 리눅스 매뉴얼에 따르면 strcpy 함수의 원형을 다음과 같다.

strcpy(3) - Linux manual page

strcpy(3) — Linux manual page strcpy(3) Library Functions Manual strcpy(3) NAME top stpcpy, strcpy, strcat - copy or catenate a string LIBRARY top Standard C library (libc, -lc) SYNOPSIS top #include char *stpcpy(char

man7.org

char *stpcpy(char *restrict dst, const char *restrict src);

위 내용을 통해 후킹할 함수를 정의했다. 내용은 src 인자로 들어온 문자열을 출력하는 것이다.

#include <stdio.h>

char *strcpy(char *dst, const char *src)
{
    printf("Data : %s", src);
    return dst;
}

하지만 한가지 문제가 존재하는데 후킹한 함수가 정상적으로 해당 함수의 역할을 수행해야할 필요가 있다. 그렇기 때문에 원본 함수의 주소를 알아내는 방법을 알아야 한다.

How to get address of original function

Linux 운영체제에서는 dlsym 함수를 통해 원본 함수의 주소를 구할 수 있다.

dlsym(3) - Linux manual page

dlsym(3) — Linux manual page dlsym(3) Library Functions Manual dlsym(3) NAME top dlsym, dlvsym - obtain address of a symbol in a shared object or executable LIBRARY top Dynamic linking library (libdl, -ldl) SYNOPSIS to

man7.org

void *dlsym(void *restrict handle, const char *restrict symbol);

해당 함수를 사용하기 위해서는 dlfcn.h 헤더 파일이 필요하고 _GNU_SOURCE 상수가 정의되어 있어야한다.

#define _GNU_SOURCE
#include <dlfcn.h>

handle에는 함수를 검색할 라이브러리가 들어가야 하지만 특정 라이브러리에서 함수 주소를 구하는 것이 아니라면 RTLD_NEXT를 전달하면 되고 symbol에는 함수명을 전달하면 된다.

RTLD_NEXT는 현재 라이브러리 다음으로 로드된 라이브러리를 의미하기 때문에 다음 라이브러리부터 차례대로 해당 함수가 존재하는지 라이브러리에서 확인해 주소를 구하게 된다.

#define _GNU_SOURCE
#include <stdio.h>
#include <dlfcn.h>

char *(*origin_strcpy)(char *dst, const char *src);

char *strcpy(char *dst, const char *src)
{
    if (origin_strcpy == NULL)
    {
        origin_strcpy = dlsym(RTLD_NEXT, "strcpy");
    }
    printf("Data : %s", src);

    return origin_strcpy(dst, src);
}

위 소스코드를 리눅스에서 컴파일러를 이용해 컴파일 한 후에 LD_PRELOAD를 이용해 프로그램을 실행하면 다음과 같은 결과를 볼 수 있다.

root@ubuntu:/tmp# LD_PRELOAD=./libtest.so ./main
Data : This is secret key

원래는 비밀키를 복사한 후에 아무런 반응 없이 종료되어야할 프로그램이 LD_PRELOAD에 설정된 라이브러리로 인해 인자로 들어온 비밀키를 출력하는 모습을 볼 수 있다.

이렇게 LD_PRELOAD를 이용한 후킹을 진행해보았다. Linux 운영체제는 Windows 운영체제에 비해 후킹이 비교적 간단했으며 이런 기능이 운영체제 자체적으로 존재한다는 것이 신기했다.

서식 테스트2

미친해커 — Mon, 12 Dec 2022 02:48:37 +0900

서식 테스트2

서식 테스트

미친해커 — Sat, 22 Oct 2022 00:12:00 +0900

Hello World

[Network] IPv6(Internet Protocol version 6) 헤더

미친해커 — Sat, 1 Oct 2022 19:27:12 +0900

인터넷 프로토콜

인터넷 프로토콜(IP, Internet Protocol)은 두 호스트가 네트워크에서 패킷을 교환하며 정보를 주고 받는 데 사용하는 규약이며, 호스트의 주소 지정과 패킷 분할 및 조립 기능을 담당한다. 줄여서 아이피(IP)라고도 한다.

주소 체계

인터넷 프로토콜은 특정한 호스트의 주소를 지정할 수 있도록 설계되었다. 보편적으로 사용되는 IP 주소 체계는 IPv4와 IPv6가 있다.

IPv6는 인터넷 프로토콜의 6번째 버전이다. IPv4 주소가 모두 소진되어 더 이상 IPv4 주소를 할당할 수 없음에 따라 IPv6가 개발되었다.

IPv6는 128비트로 구성되어 있으며, 16비트(2바이트)를 16진수로 표현하여 8자리로 나타낸다.

IPv6 주소 예시 : 2001:0db8:85a3:08d3:1319:8a2e:0370:7334

IPv6 주소의 개수는 128비트로 표현할 수 있는 2^128개인 약 3.4x10^38개의 주소를 갖고 있어 거의 무한대로 쓸 수 있다.

헤더

인터넷 프로토콜 버전 6 헤더는 확장 헤더를 포함하지 않은 경우 40바이트이다.

[Network] IPv4(Internet Protocol version 4) 헤더

미친해커 — Sat, 1 Oct 2022 01:58:05 +0900

인터넷 프로토콜

주소 체계

인터넷 프로토콜은 특정한 호스트의 주소를 지정할 수 있도록 설계되었다. 보편적으로 사용되는 IP 주소 체계는 IPv4와 IPv6가 있다.

IPv4는 인터넷 프로토콜의 4번째 버전이다. 전 세계적으로 사용된 첫 번째 인트넷 프로토콜이며, 과거에 사용되던 유일한 인터넷 프로토콜이였으나 오늘날에는 IPv4의 주소가 소진되어 IPv4의 할당이 중지되고 IPv6로 대체되고 있다.

IPv4의 주소체계는 총 12자리이며 네 부분으로 나뉜다. 각 부분 마다 0~255까지 3자리의 수로 표현된다. IPv4는 32비트로 구성되어 있으며, 한 부분당 1바이트이다.

IPv4 주소 예시 : 192.168.123.100

IPv4 주소의 개수는 32비트로 표현할 수 있는 2^32개인 약 43억개이다.

헤더

인터넷 프로토콜 버전 4 헤더는 옵션 미지정시 20바이트이며, 고정 20바이트와 가변 0 ~ 40바이트가 있다.

인터넷 프로토콜 버전 4 헤더는 최소 20바이트의 사이즈를 가지며 옵션에 따라 0 ~ 40바이트가 늘어날 수 있다.

IPv4 헤더의 고정 부분

IPv4 헤더의 가변 부분

typedef struct _NETWORK_IP_HEADER
{
    unsigned char HeaderLength : 4;          // IP Header Length
    unsigned char Version : 4;               // Internet Protocol Version
    union
    {
        unsigned char TypeOfService;         // Type of Service
        struct
        {
            unsigned char ECN : 2;           // Differentiated Services Codepoint
            unsigned char DSCP : 6;          // Explicit Congestion Notification
        };
    };
    unsigned short TotalLength;              // Total Packet Length in byte except for Ethernet Header Length
    unsigned short Identification;           // IP Packet Identifier
    union
    {
        unsigned short Flag;                 // Information about the status of the packet segmentation.
        unsigned short FragmentOffset : 13;  // Original Location of Split Packets
        struct
        {
            unsigned short : 13;             // bit field padding
            unsigned short MoreFragment : 1; // More fragment packets present
            unsigned short DontFragment : 1; // It is last fragment packet
            unsigned short Reserved : 1;     // Reserved, always set to 0
        } Flags;
    };
    unsigned char TTL;                       // Time To Live
    unsigned char Protocol;                  // Protocol Type in the next layer
    unsigned short Checksum;                 // Header Checksum
    struct sockaddr_in SourceAddr;           // Source IP Address
    struct sockaddr_in DestinationAddr;      // Destination IP Address
    // unsigned long SourceAddr;
    // unsigned long DestinationAddr;
} NETWORK_IP_HEADER, *PNETWORK_IP_HEADER;

[Network] 이더넷 헤더 (Ethernet Header(Protocol))

미친해커 — Thu, 29 Sep 2022 20:21:31 +0900

이더넷

이더넷(Ethernet)은 컴퓨터 네트워크에서 사용하는 기술이다. LAN, MAN, WAN 등 거의 모든 네트워크 분야에서 활용되는 기술 규격이며, OSI 모델의 데이터 링크 계층에서 MAC 패킷과 프로토콜 형식을 정의한다.

개요

이더넷은 네트워크에서 각 기기들이 48비트 길이의 고유한 MAC 주소를 가지고 데이터를 주고 받을 수 있도록 만들어졌다.

헤더

이더넷 헤더의 사이즈는 총 14바이트으로 이루어져 있으며, 6바이트의 도착지(Destination) 그리고 출발지(Source) MAC 주소, 2바이트의 Ethernet Type이 존재한다.

Ethernet Type에는 다음 계층의 프로토콜이 무엇인지 기록된다.

typedef struct _NETWORK_ETHERNET_HEADER
{
    unsigned char Destination[6]; /* Destination MAC Address */
    unsigned char Source[6];      /* Source MAC Address */
    unsigned short Type;          /* Ethernet Type */
} NETWORK_ETHERNET_HEADER, *PNETWORK_ETHERNET_HEADER;

[Network] 네트워크 바이트 오더 (Network Byte Order)

미친해커 — Thu, 29 Sep 2022 19:25:10 +0900

바이트 오더(Byte Order)

네트워크 바이트 오더를 설명하기 전에 바이트 오더에 대해 먼저 설명해야 한다.

바이트 오더란 컴퓨터 메모리에 바이트가 저장되는 순서를 바이트 오더라고 부른다. 바이트 오더는 저장되는 방식에 따라 다르며 Little Endian, Middle Endian, Big Endian 등의 바이트 오더가 존재한다.

Intel과 AMD 계열의 프로세서는 주로 Little Endian을 사용한다.

저장 방식

빅 엔디안은 상위 바이트부터 순서대로 저장 되고 리틀 엔디안은 하위 바이트부터 순서대로 저장된다는 차이점이 있다.

종류	0x1234 표현(2바이트 표현)	0x12345678 표현(4바이트 표현)
Big Endian (빅 엔디안)	`01 02 03 04 05 06 07 08 00000000 12 34 XX XX XX XX XX XX`	`01 02 03 04 05 06 07 08 00000000 12 34 56 78 XX XX XX XX`
Little Endian (리틀 엔디안)	`01 02 03 04 05 06 07 08 00000000 34 12 XX XX XX XX XX XX`	`01 02 03 04 05 06 07 08 00000000 78 56 34 12 XX XX XX XX`

네트워크 바이트 오더(Network Byte Order)

네트워크 바이트 오더(Network Byte Order)란 네트워크에서 사용하는 바이트 오더(Byte Order)를 말한다.

네트워크에서는 Big Endian을 사용한다. 그렇기 때문에 주로 Little Endian을 사용하는 대부분의 PC는 네트워크 바이트 오더를 호스트 바이트 오더(해당 PC가 사용하는 바이트 오더)로 변환해야 할 필요가 있다.

[C] 패킷의 이더넷(Ethernet) 헤더의 정보 출력하기

미친해커 — Wed, 28 Sep 2022 21:57:06 +0900

이더넷 프로토콜이란?

이더넷은 전세계적으로 사용되는 기술 규격이다. OSI 모델 데이터 링크 계층에서 MAC 패킷과 프로토콜을 정의한다. 또한 네트워크에서 각 기기가 48비트 길이의 고유 MAC 주소를 이용하여 데이터를 주고 받을 수 있도록 만들어졌다.

이더넷 헤더

이더넷 헤더의 사이즈는 총 14바이트으로 이루어져 있으며, 6바이트의 도착지(Destination) 그리고 출발지(Source) MAC 주소, 2바이트의 Ethernet Type이 존재한다.

Ethernet Type에는 다음 계층의 프로토콜이 무엇인지 기록된다.

구조체

C언어를 기준으로 구조체는 아래와 같이 정의할 수 있으며 필요한 경우 구조체 바이트 정렬이 필요하다.

typedef struct _NETWORK_ETHERNET_HEADER
{
    unsigned char Destination[6]; /* Destination MAC Address */
    unsigned char Source[6];      /* Source MAC Address */
    unsigned short Type;          /* Ethernet Type | You need to change the byte order */
} NETWORK_ETHERNET_HEADER, *PNETWORK_ETHERNET_HEADER;

네트워크 바이트 오더(Network Byte Order)

네트워크 바이트 오더(Network Byte Order)란 네트워크에서 사용하는 바이트 오더(Byte Order)를 말한다. 쉽게 말해 컴퓨터 시스템에는 Little Endian, Middle Endian, Big Endian 등의 바이트 오더가 존재한다.

네트워크에서는 Big Endian을 사용하고 대부분의 프로세서는 Little Endian을 사용한다. 두 엔디안의 차이는 아래와 같다.

종류	0x1234 표현(2바이트 표현)	0x12345678 표현(4바이트 표현)
Big Endian (빅 엔디안)	`01 02 03 04 05 06 07 08 00000000 12 34 XX XX XX XX XX XX`	`01 02 03 04 05 06 07 08 00000000 12 34 56 78 XX XX XX XX`
Little Endian (리틀 엔디안)	`01 02 03 04 05 06 07 08 00000000 34 12 XX XX XX XX XX XX`	`01 02 03 04 05 06 07 08 00000000 78 56 34 12 XX XX XX XX`

빅 엔디안은 상위 바이트부터 순서대로 저장되고 리틀 엔디안은 하위 바이트부터 순서대로 저장된다는 차이점이 있다.

바이트 오더에 대한 자세한 내용은 아래 포스트를 참고해주세요.

[Network] 네트워크 바이트 오더 (Network Byte Order)

바이트 오더(Byte Order) 네트워크 바이트 오더를 설명하기 전에 바이트 오더에 대해 먼저 설명해야 한다. 바이트 오더란 컴퓨터 메모리에 바이트가 저장되는 순서를 바이트 오더라고 부른다. 바이

crazyhacker.tistory.com

주요 함수

`ntohs`

ntohs(Network byte order TO Host byte order Short) 함수는 2바이트 데이터를 네트워크 바이트 오더에서 호스트 바이트 오더로 변환하는 함수이다.

unsigned short Data = ntohs(NetworkByteOrderData);

예제 코드

예제 코드는 이전 포스팅에서 제작한 패킷 캡쳐 프로그램에서 기능을 추가했다.

#include <stdio.h>
#include <pcap.h>

typedef struct _NETWORK_ETHERNET_HEADER
{
    unsigned char Destination[6];
    unsigned char Source[6];
    unsigned short Type; // You need to change the byte order.
} NETWORK_ETHERNET_HEADER, *PNETWORK_ETHERNET_HEADER;

int main(int argc, char *argv[])
{
    if (argc < 2)
    {
        printf("Usage: %s [interface]\n", argv[0]);
        return -1;
    }
    
    char errbuf[PCAP_ERRBUF_SIZE];
    pcap_t *pcap = pcap_open_live(argv[1], BUFSIZ, 1, 1000, errbuf);

    if (pcap == NULL)
    {
        fprintf(stderr, "pcap_open_live(%s) return null - %s\n", argv[1], errbuf);
        return -1;
    }

    while (1)
    {
        struct pcap_pkthdr* header;
        const unsigned char *packet;
        int res = pcap_next_ex(pcap, &header, &packet);
        if (res == 0) continue;
        if (res == PCAP_ERROR || res == PCAP_ERROR_BREAK)
        {
            printf("pcap_next_ex return %d(%s)\n", res, pcap_geterr(pcap));
			break;
        }
        
        NETWORK_ETHERNET_HEADER *Ethernet = packet;
        Ethernet->Type = ntohs(Etherent->Type);
        
        printf("[Destination] : ");
        for (int i = 0; i < 6; i++)
        {
            printf("%02X ", Ethernet->Destination[i]);
        }
        putchar('\n');

        printf("[Source] : ");
        for (int i = 0; i < 6; i++)
        {
            printf("%02X ", Ethernet->Source[i]);
        }
        putchar('\n');
        
        printf("[EthernetType] : 0x%04X\n", Ethernet->Type);
    }
}

$ ifconfig
ens33: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
		...

$ sudo ./main ens33
[Destination] : 00 50 56 FC 50 1D 
[Source] : 00 0C 29 7A 5F 24 
[EthernetType] : 0800
...

[C] pcap로 네트워크 패킷 캡쳐하기

미친해커 — Fri, 23 Sep 2022 03:42:37 +0900

pcap이란?

pcap(packet capture)는 네트워크 프로그래밍을 위한 라이브러리다. 유닉스 계열의 운영 체제들은 libpcap 라이브러리에 pcap이 포함되어 있어 libpcap을 이용해 네트워크 프로그래밍을 할 수 있다.

윈도우는 WinPcap이라고 하는 libpcap의 포팅된 버전을 사용한다.

네트워크의 패킷들을 잡을 수 있으며 일반적으로는 볼수 없는 헤더들의 데이터도 모두 캡처하여 볼 수 있다. pcap API는 C언어로 작성되어 있어 여러 언어에서 사용할 수 있다는 장점이 있다. (해당 블로그에서는 Unix 계열의 운영 체제들을 기준으로 실습한다)

libpcap 설치하기

블로그에서는 Ubuntu와 Kali Linux에서 프로그래밍 실습을 진행한다. 해당 운영 체제에는 기본적으로 libpcap 라이브러리가 설치되어 있지 않기 때문에 패키지 매니저를 통한 라이브러리 설치가 필요하다. 다음 명령어로 설치할 수 있다.

libpcap를 사용하기 위해서는 pcap.h 헤더 파일을 사용하면 된다.

$ sudo apt-get update
$ sudo apt-get install libpcap-dev

주요 함수

`pcap_open_live`

pcap_open_live 함수는 네트워크 인터페이스를 오픈하는 함수이다. 해당 함수는 pcap_t* 핸들을 반환하고 반환된 핸들을 사용해 패킷 캡쳐, 전송 등 작업을 수행할 수 있다.

char errbuf[PCAP_ERRBUF_SIZE];
pcap_t *pcap = pcap_open_live("eth0", BUFSIZ, 1, 1000, errbuf);

`pcap_close`

pcap_close 함수는 오픈한 네트워크 인터페이스 핸들을 닫아주는 함수이다. 네트워크 인터페이스를 오픈한 상태로 있다면 해당 인터페이스를 프로세스가 계속 점유하고 있기 때문에 사용하지 않을 때에는 반드시 닫아주어야 한다.

pcap_close(pcap);

`pcap_next_ex`

pcap_next_ex 함수는 네트워크 인터페이스로부터 패킷을 캡쳐하는 함수이다. 캡처된 패킷은 TCP 프로토콜의 경우 Ethernet, IP, TCP 등 모든 헤더와 데이터를 반환한다. 실제 반환되는 값으로는 함수의 성공 또는 실패 여부를 반환한다.

struct pcap_pkthdr {
    struct timeval ts;	/* time stamp */
    bpf_u_int32 caplen;	/* length of portion present */
    bpf_u_int32 len;	/* length this packet (off wire) */
};

struct pcap_pkthdr *header;
const unsigned char *packet;
int res = pcap_next_ex(pcap, &header, &packet);

header에는 해당 패킷 캡쳐된 시간과 길이가 저장되어 있으며 packet에는 캡쳐된 패킷의 헤더들과 데이터의 정보가 담겨 있다.

예제 코드

예제 코드는 캡쳐되는 모든 패킷들의 바이트 수를 출력하는 프로그램이다. 프로그램 실행 시에 인자로 패킷을 캡처할 네트워크 인터페이스의 이름을 넣어주면 동작한다.

#include <stdio.h>
#include <pcap.h>

int main(int argc, char *argv[])
{
    if (argc < 2)
    {
        printf("Usage: %s [interface]\n", argv[0]);
        return -1;
    }
    
    char errbuf[PCAP_ERRBUF_SIZE];
    pcap_t *pcap = pcap_open_live(argv[1], BUFSIZ, 1, 1000, errbuf);

    if (pcap == NULL)
    {
        fprintf(stderr, "pcap_open_live(%s) return null - %s\n", "ens33", errbuf);
        return -1;
    }

    while (1)
    {
        struct pcap_pkthdr* header;
        const unsigned char *packet;
        int res = pcap_next_ex(pcap, &header, &packet);
        if (res == 0) continue;
        if (res == PCAP_ERROR || res == PCAP_ERROR_BREAK)
        {
            printf("pcap_next_ex return %d(%s)\n", res, pcap_geterr(pcap));
			break;
        }
        printf("%d bytes captured\n", header->caplen);
    }
}

$ ifconfig
ens33: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        ...

$ sudo ./main ens33
60 60 bytes captured
98 98 bytes captured
98 98 bytes captured
98 98 bytes captured
98 98 bytes captured
...

[Windows] Windows 10 Kernel Debugging 환경 준비

미친해커 — Tue, 20 Sep 2022 22:34:13 +0900

Install WinDbg

윈도우 커널 디버깅은 우리가 일반적으로 알고 있는 x64dbg와 같은 디버거로는 디버깅할 수 없다. 윈도우에서 제작한 WinDbg를 사용해 디버깅할 수 있다.

기본적으로 WinDbg는 두 종류가 있는데 하나는 SDK에서 설치할 수 있는 디버거와 Microsoft Store에서 다운로드할 수 있는 디버거이다. 본문에서는 Microsoft Store에 있는 WinDbg Preview를 기준으로 설명하겠다.

WinDbg Preview는 Microsoft Store에서 "Windbg" 키워드로 검색하면 바로 다운로드 받을 수 있다.

Set the symbol path and server

이제 디버거의 심볼 패스와 서버를 설정해야 한다. 윈도우 커널을 디버깅하면서 필요한 디버깅 심볼들이 필요하기 때문이다. 디버깅 심볼이 존재하지 않으면 그건 윈도우 자체를 아무것도 없이 리버싱하는 것과 마찬가지다.

[파일] -> [Settings] -> [Debugging settings] -> [Default symbol path]를 SRV*c:\dbgsymbols*http://msdl.microsoft.com/download/symbols로 설정하면 된다.

Set the Windows Debug Mode

이제 윈도우를 디버그 모드로 부팅할 수 있도록 설정해줘야 한다. 다음과 같은 절차를 따라오면 된다.

bcdedit /dbgsettings net hostip:192.168.64.135 port:50000 /* 포트는 자유이지만 대개 50000를 쓰는 듯 하다 */
bcdedit /set bootmenupolicy legacy
bcdedit /copy {current} /d "Windows 10 [Debug, F8]"
bcdedit /debug {GUID} on /* {GUID}는 위 명령어를 입력시 출력됨 */

IP, Port, Key를 WinDbg에 입력하고 [OK] 버튼을 클릭한다.

[OK] 버튼을 클릭하면 아래 사진과 같이 IPv4를 사용하여 커널 디버깅을 위해 클라이언트가 연결될 때까지 대기하는 것을 확인할 수 있다.

Windows Booting the Debug Mode

Windbg가 커널 디버깅을 위해 대기중이라면 디버그 모드를 설정했던 윈도우를 재부팅시켜준다. 그럼 이번엔 아래와 같은 부팅화면을 볼수 있다.

아래 우리가 새롭게 추가한 부팅 옵션을 선택하고 F8 키를 눌러준다. 여기에서 디버깅 모드를 선택하면 자동으로 디버깅 모드로 부팅된다.

모두 정상적으로 설정하였다면 디버깅 모드로 부팅을 선택한 후 대기하다보면 WinDbg가 연결되는 것을 확인할 수 있다.

Success Windows Kernel Debugging (Attack to Kernel)

[Windows] Windows Kernel Driver 개발 환경 준비

미친해커 — Mon, 22 Aug 2022 12:04:39 +0900

Install Visual Studio

Visual Studio Code와 Mingw(GCC)를 활용해서도 윈도우 커널 드라이버 개발을 할 수 있지만, Visual Studio에서 개발하는 편이 훨씬 간편하다고 생각한다.

1. 개발할 윈도우 버전 선택

윈도우 커널 드라이버는 하위 호환성은 지켜지지만 상위 호환성은 지켜지지 않는다. 그렇기에 자신이 개발할 드라이버의 대상이 되는 윈도우 버전을 잘 선택해야 한다.

하위 호환성 : Windows 7 드라이버를 Windows 10에서 실행
상위 호환성 : Windows 10 드라이버를 Windows 7에서 실행

이전 WDK 버전 및 기타 다운로드 - Windows drivers

WDK(Windows 드라이버 키트), Windows 디버거(WinDBG) 등을 설치합니다.

docs.microsoft.com

위 페이지에서 내가 개발하려는 윈도우의 버전에 맞춰서 Visual Studio를 설치하길 바란다. 개인적으로는 Visual Studio 2019를 추천한다. 현재 기준 최신버전 Visual Studio 2022 버전은 윈도우 커널 드라이버를 개발하는 적합하지 않고 오류도 발생한다.

Thank you for downloading Visual Studio - Visual Studio

New to Visual Studio? Learning a new development tool can be overwhelming. Take this step-by-step learning journey at your own pace to successfully create a simple app in any language of your choice. Let’s get started! First please make sure to open your

visualstudio.microsoft.com

Visual Studio 2019는 위 링크에서 다운로드 받을 수 있다.

2. Windows SDK 설치

Visual Studio를 설치하면 워크로드에서 [C++를 사용한 데스크톱 개발] 를 선택한다.

그리고 [개별 구성 요소] -> [Windows 10 SDK(원하는 버전)] 을 선택해준다.

Install Windows Driver Kit (WDK)

Visual Studio에서 SDK까지 모두 설치가 끝났다면 이제 Windows Driver Kit (WDK)를 설치해야 한다. 본인이 설치했던 SDK와 같은 버전의 WDK를 설치해야 한다. 다음 사이트에서 SDK 버전별로 윈도우 버전을 확인할 수 있다.

Windows SDK 및 에뮬레이터 보관

이전 버전의 Windows 및 Windows Phone 플랫폼에서 개발을 위해 이전 Windows SDK 및 에뮬레이터 릴리스를 다운로드하여 설치합니다.

developer.microsoft.com

버전을 확인하고 다음 사이트에서 해당 버전에 맞는 WDK를 설치해준다.

이전 WDK 버전 및 기타 다운로드 - Windows drivers

WDK(Windows 드라이버 키트), Windows 디버거(WinDBG) 등을 설치합니다.

docs.microsoft.com

Finish

이렇게 Visual Studio 프로젝트 만들기에 Empty WDM Driver 라는 템플릿이 생성되었다면 성공적으로 윈도우 커널 드라이버 개발 환경이 준비된 것이다.

[Windows] Instrumentation Callback 응용하기 - syscall detect

미친해커 — Mon, 15 Aug 2022 06:50:46 +0900

GitHub - jungjin0003/Instrumentation-Callback

Contribute to jungjin0003/Instrumentation-Callback development by creating an account on GitHub.

github.com

Instrumentation Callback을 통해 알 수 있는 것

지금까지의 포스팅만 봤을 때 Instrumentation Callback은 그저 syscall 어셈블리가 실행되었다는 정보 밖에 알 수 없었다. 하지만 Instrumentation Callback은 그 외에도 아래와 같은 정보들을 구할 수 있다.

Original Return Address (sysret 가 되었을 때 원래 돌아가야 할 주소)
Syscall Number
Function Name

How Do I Get The Above Information?

Instrumentation Callback으로 등록된 함수가 호출되었을 때 r10 레지스터에는 원래 돌아가야 할 리턴 주소가 기록되어 있다. 이를 보고 어떠한 커널 함수를 호출했는지 알아낼 수 있다.

What is The Syscall Detect?

결국 tracking와 크게 다를게 없다. 하지만 이번 응용하기에서 다른점은 syscall instruction을 호출한 주소가 실제 ntdll.dll 또는 win32u.dll가 아니라면 프로그램 실행을 중지하는 원리이다.

Sample

#include <stdio.h>
#include <windows.h>

#pragma comment (lib, "ntdll.lib")

#define PROCESS_INFO_CLASS_INTRUMENTATION 40
#define RIP_SANITY_CHECK(Rip,BaseAddress,ModuleSize) (Rip > BaseAddress) && (Rip < (BaseAddress + ModuleSize))

NTSYSAPI NTSTATUS NTAPI NtSetInformationProcess(HANDLE ProcessHandle, PROCESS_INFORMATION_CLASS ProcessInformationClass, PVOID ProcessInformation, ULONG ProcessInformationLength);

#ifdef __GUNC__
__declspec(naked) NTSTATUS SystemCall(ULONG number)
{
    __asm__ __volatile__ ("mov rax, r10");
    __asm__ __volatile__ ("syscall");
    __asm__ __volatile__ ("ret");
}
#elif _MSC_VER
extern PVOID GetSyscallReturnAddress();
extern NTSTATUS SystemCall(ULONG number);
#endif

typedef struct _PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION
{
    ULONG Version;
    ULONG Reserved;
    PVOID Callback;
} PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION, *PPROCESS_INSTRUMENTATION_CALLBACK_INFORMATION;

VOID CALLBACK InstrumentationCallback()
{
    static HANDLE NtdllBase;
    static HANDLE Win32uBase;
    
    PVOID ReturnAddress = NULL;

#ifdef __GNUC__
    __asm__ __volatile__ (
        "mov %[ReturnAddress], r10\n\t"
        :
        : [ReturnAddress] "m" (ReturnAddress)
    );
#elif _MSC_VER
    ReturnAddress = GetSyscallReturnAddress();
#else
#error This compiler is not supported. Please checck the compiler or target OS
#endif

    if (NtdllBase == NULL)
        NtdllBase = GetModuleHandleA("ntdll.dll");

    if (Win32uBase == NULL)
        Win32uBase = GetModuleHandleA("win32u.dll");

    DWORD NtdllSize = ((IMAGE_NT_HEADERS *)((ULONG_PTR)NtdllBase + ((IMAGE_DOS_HEADER *)NtdllBase)->e_lfanew))->OptionalHeader.SizeOfImage;
    DWORD Win32uSize = Win32uBase == NULL ? 0 : ((IMAGE_NT_HEADERS *)((ULONG_PTR)Win32uBase + ((IMAGE_DOS_HEADER *)Win32uBase)->e_lfanew))->OptionalHeader.SizeOfImage;

    if (!(RIP_SANITY_CHECK(ReturnAddress, (ULONG_PTR)NtdllBase, NtdllSize)) || (Win32uBase != NULL && !(RIP_SANITY_CHECK(ReturnAddress, (ULONG_PTR)Win32uBase, Win32uSize))))
    {
        printf("[SYSCALL-DETECT] Kernel returns to unverified module, preventing further execution!\n");
        __debugbreak();
    }

    return;
}

int main(int argc, char *argv[])
{
    PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION nirvana;
    nirvana.Version = 0;
    nirvana.Reserved = 0;
    nirvana.Callback = InstrumentationCallback;

    NtSetInformationProcess(GetCurrentProcess(), PROCESS_INFO_CLASS_INTRUMENTATION, &nirvana, sizeof(PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION));
    SystemCall(0x46); // NtYieldExecution

    printf("[SYSTEM] Successfully executed the syscall instruction\n");

    return 0;
}

MSVC 컴파일용 어셈블리

; File : extern.asm
_TEXT SEGMENT

PUBLIC GetSyscallReturnAddress
PUBLIC SystemCall

GetSyscallReturnAddress PROC
    mov rax, r10
    ret
GetSyscallReturnAddress ENDP

SystemCall PROC
    mov rax, rcx
    syscall
    ret
SystemCall ENDP

_TEXT ENDS

END

=====GCC=====
CommandLine : gcc.exe main.c -o main.exe -lntdll -masm=intel
=====MSVC====
CommandLine : ml64.exe /c extern.asm => result : extern.obj
CommandLink : cl.exe main.c extern.obj /Od /Z7 /link /MANIFEST:NO /DEBUG:FULL /OPT:REF /OPT:ICF /OPT:LBR

실행 결과

$ main.exe
[SYSCALL-DETECT] Kernel returns to unverified module, preventing further execution!

Reference

Detecting Manual Syscalls from User Mode - Winternl

By now direct system calls are ubiquitous in offensive tooling. Manual system calls remain effective for evading userland based EDRs. From within userland, there has been little answer to this powerful technique. Such syscalls can be effectively mitigated

winternl.com

Visual Studio 컴파일러에서 msvcrt.dll 사용하기

미친해커 — Thu, 11 Aug 2022 05:55:01 +0900

기본적으로 Visual Studio의 MSVC로 컴파일을 진행하면 vcruntime140.dll, ucrtbase.dll을 사용하는 것을 확인할 수 있다.

이는 Windows SDK에 있는 라이브러리를 사용하는 것으로 알고 있는데, 해당 DLL을 사용하면 다른 윈도우에서 프로그램을 실행했을 때 ucrtbase.dll과 vcruntime140.dll이 없으면 프로그램이 동작하지 않는 문제가 발생한다.

물론 프로그램을 배포할 때 DLL을 함께 배포하면 문제 없지만 이는 반드시 프로그램을 실행하기 전에 DLL을 배포해야 한다는 귀찮음이 존재한다. 하지만 모든 윈도우에는 기본적으로 msvcrt.dll이 존재하고 msvcrt.dll과 ucrtbase.dll, vcruntime140.dll에 있는 함수가 다르지 않다. 버전의 차이로만 알고 있다. 그렇기 때문에 컴파일과 링킹 과정에서 이 두 DLL대신 msvcrt.dll을 사용하면 문제 없이 모든 윈도우에서 사용할 수 있다.

먼저 msvcrt.lib 파일을 다운로드 받아야 한다. 기본적으로 포함은 되어 있지만 확인해보니 그냥 껍데기만 있는 파일이라 실제로 사용할 수 있는 msvcrt.lib를 다운로드 받아야 한다.

MSVCRT.zip

2.29MB

[프로젝트 속성] -> [링커] -> [입력] -> [특정 기본 라이브러리 무시] -> libcmt.lib, msvcprt.lib 추가

[프로젝트 속성] -> [링커] -> [입력] -> [추가 종속성] -> msvcrt.lib 추가

이렇게 추가해주면 msvcrt.dll 가 링크되어 msvcrt.dll을 사용할 수 있게된다.

Visual Studio 컴파일할 때 쓸 때 없는 Reference 없애기

미친해커 — Thu, 11 Aug 2022 05:11:45 +0900

Visual Studio의 컴파일러인 MSVC로 컴파일을 하면 가끔 이런 이상한 코드가 추가되는 경우가 있다.

모든 함수가 jmp 어셈블리로 호출되도록 이루어져 있다.

위 이미지 처럼 모든 함수가 참조되어 있는 것을 확인할 수 있다. 그럼 해당 바이너리 내에서 호출하는 모든 함수들이 이 jmp를 거쳐서 호출되게 된다.

필자는 개인적으로 이걸 매우 싫어하는데 지금까지 이 때문에 Mingw를 애용했다고 해도 과언이 아니다. 하지만 이제야 해결 방법을 깨달았다. 이는 MSVC의 LINK의 최적화 옵션을 설정하면 된다.

[프로젝트 속성] -> [링커] -> [최적화] -> [참조] -> [/OPT:REF]

이 옵션을 설정해주면 저런 참조 코드가 생성되지 않는다. 커맨드 라인으로 한다면 다음과 같다.

cl.exe main.c /link /OPT:REF

[Windows] Instrumentation Callback 응용하기 - syscall tracking

미친해커 — Tue, 2 Aug 2022 22:03:48 +0900

GitHub - jungjin0003/Instrumentation-Callback

Contribute to jungjin0003/Instrumentation-Callback development by creating an account on GitHub.

github.com

Instrumentation Callback을 통해 알 수 있는 것

Original Return Address (sysret 가 되었을 때 원래 돌아가야 할 주소)
Syscall Number
Function Name

How Do I Get The Above Information?

Sample

#include <stdio.h>
#include <windows.h>

#pragma comment (lib, "ntdll.lib")

#define PROCESS_INFO_CLASS_INSTRUMENTATION 40

typedef struct _PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION
{
	ULONG Version;
	ULONG Reserved;
	PVOID Callback;
} PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION, * PPROCESS_INSTRUMENTATION_CALLBACK_INFORMATION;

#ifdef _MSC_VER
extern VOID GetInstrumentationCallbackData(PDWORD lpSyscallNumber, FARPROC *lpProcAddress);
#endif

VOID CALLBACK InstrumentationCallback()
{
    FARPROC Function = NULL;
	DWORD SystemCallNumber = 0;
#ifdef __GNUC__
    __asm__ __volatile__ (
        "mov eax, dword ptr ds:[r10 - 0x10]\n\t"
        "mov %[SystemCallNumber], eax\n\t"
        "lea rax, qword ptr ds:[r10 - 0x14]\n\t"
        "mov %[Function], rax\n\t"
        :
        : [SystemCallNumber] "m" (SystemCallNumber), [Function] "m" (Function)
    );
#elif _MSC_VER
    GetInstrumentationCallbackData(&SystemCallNumber, &Function);
#else
#error This compiler is not supported. Please checck the compiler or target OS
#endif
    ULONG_PTR ImageBase = GetModuleHandleA("ntdll.dll");
    IMAGE_EXPORT_DIRECTORY *EXPORT = ImageBase + ((IMAGE_NT_HEADERS *)(ImageBase + ((IMAGE_DOS_HEADER *)ImageBase)->e_lfanew))->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;

    printf("System Call Number : 0x%02x\n", SystemCallNumber);
    printf("Function Address : 0x%p\n", Function);

    for (int i = 0; i < EXPORT->NumberOfNames; i++)
    {
        if (ImageBase + *(DWORD *)(ImageBase + EXPORT->AddressOfFunctions + *(WORD *)(ImageBase + EXPORT->AddressOfNameOrdinals + i * 2) * 4) == Function)
        {
            printf("Function name : %s\n", ImageBase + *(DWORD *)(ImageBase + EXPORT->AddressOfNames + i * 4));
            break;
        }
    }
}

int main(int argc, char *argv[])
{
    PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION nirvana;
    nirvana.Version = 0;
    nirvana.Reserved = 0;
    nirvana.Callback = InstrumentationCallback;
    
    NtSetInformationProcess(GetCurrentProcess(), PROCESS_INFO_CLASS_INSTRUMENTATION, &nirvana, sizeof(nirvana));
    OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());

    return 0;
}

MSVC 컴파일용 어셈블리

; File : extern.asm
_TEXT SEGMENT

PUBLIC GetInstrumentationCallbackData

GetInstrumentationCallbackData PROC
    mov eax, dword ptr [r10 - 10h]
    mov dword ptr [rcx], eax
    lea rax, qword ptr [r10 - 14h]
    mov qword ptr [rdx], rax
    ret
GetInstrumentationCallbackData ENDP

_TEXT ENDS

END

=====GCC=====
CommandLine : gcc.exe main.c -o main.exe -lntdll -masm=intel
=====MSVC====
CommandLine : ml64.exe /c extern.asm => result : extern.obj
CommandLink : cl.exe main.c extern.obj /Od /Z7 /link /MANIFEST:NO /DEBUG:FULL /OPT:REF /OPT:ICF /OPT:LBR

실행 결과

System Call Number : 0x26
Function Address : 0x00007FFD5F22D3F0
Function name : NtOpenProcess
System Call Number : 0x2c
Function Address : 0x00007FFD5F22D4B0
Function name : NtTerminateProcess
System Call Number : 0x0f
Function Address : 0x00007FFD5F22D110
Function name : NtClose
System Call Number : 0x0f
Function Address : 0x00007FFD5F22D110
Function name : NtClose
System Call Number : 0x0f
Function Address : 0x00007FFD5F22D110
Function name : NtClose
System Call Number : 0x0f
Function Address : 0x00007FFD5F22D110
Function name : NtClose

[Windows] Instrumentation Callback 등록하기

미친해커 — Tue, 2 Aug 2022 13:08:42 +0900

Instrumentation Callback's Strcture

Instrumentation Callback을 등록하기 위해서는 특정한 구조체를 사용해야 한다.

typedef struct _PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION
{
    ULONG Version;  // x64 -> 0 | x86 -> 1
    ULONG Reserved; // Always 0
    PVOID Callback; // VOID (CALLBACK *InstrumentationCallback)();
} PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION, *PPROCESS_INSTRUMENTATION_CALLBACK_INFORMATION;

How to Reigster Instrumentation Callback?

Instrumentation Callback을 등록하기 위해서는 NtSetInforamationProcess 함수를 사용해야 한다.

VOID CALLBACK InstrumentationCallback()
{
    printf("Instrumentation Callback\n");
}

PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION nirvana;
nirvana.Version = 0;
nirvana.Reserved = 0;
nirvana.Callback = InstrumentationCallback;

NtSetInformationProcess(hProcess, PROCESS_INFO_CLASS_INSTRUMENTATION, &nirvana, sizeof(PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION));

Example

#include <stdio.h>
#include <windows.h>

#define PROCESS_INFO_CLASS_INSTRUMENTATION 40

NTSYSAPI NTSTATUS NTAPI NtSetInformationProcess(HANDLE ProcessHandle, PROCESS_INFORMATION_CLASS ProcessInformationClass, PVOID ProcessInformation, ULONG ProcessInformationLength);

typedef struct _PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION
{
    ULONG Version;
    ULONG Reserved;
    PVOID Callback;
} PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION, *PPROCESS_INSTRUMENTATION_CALLBACK_INFORMATION;

VOID CALLBACK InstrumentationCallback()
{
    printf("Instrumentation Callback\n");
}

int main(int argc, char *argv[])
{
    PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION nirvana;
    nirvana.Version = 0;
    nirvana.Reserved = 0;
    nirvana.Callback = InstrumentationCallback;
    
    NtSetInformationProcess(GetCurrentProcess(), PROCESS_INFO_CLASS_INSTRUMENTATION, &nirvana, sizeof(PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION));
    OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());
    
    return 0;
}

[Windows] Instrumentation Callback이란?

미친해커 — Mon, 1 Aug 2022 23:46:07 +0900

What is Instrumentation Callback?

Instrumentation Callback(계측 콜백)이란 Windows 시스템에서 지원하는 콜백중 하나이다.

When will this Callback be Called?

Instrumentation Callback은 프로세스에서 syscall을 호출하는 모든 커널함수들이 호출되었을 때 호출된다.

예외

단 NtContinue, NtTerminateProcess, NtTerminateThread (현재 스레드에서 호출한 경우), NtRaiseException 함수의 경우에는 콜백이 동작하지 않는다.

[Arduino] LoRa Step 6 - 전파법에 맞춰 로라 설정하기

미친해커 — Sat, 30 Jul 2022 20:03:30 +0900

대한민국에서 로라를 사용하기 위해서 신경써야하는 조항은 2개가 있다. 주파수와 출력세기이다. 이 부분은 하드웨어 적으로 값을 세팅해주고 사용해야 한다. 잠깐 연습삼아 사용하는건 괜찮을지 몰라도 지속적으로 법에 어긋나는 주파수와 출력세기를 사용하다가는 문제가 발생할 수 있다.

주파수 (Channel)

대한민국에서 등록?하지 않고 사용할 수 있는 주파수 범위는 917.1 ~ 923.3 MHz 이다.

E32-900T30D 주파수 설정 공식

해당 모듈의 기본 주파수는 868MHz로 설정되어 있다.

이전에 첨부했었던 데이터 시트를 확인해보면 기본 862MHz + CHAN * 1MHz 공식으로 주파수를 설정한다. 채널을 60으로 설정하게되면 862MHz + 60 * 1MHz으로 922MHz 주파수를 사용할 수 있게된다.

E32-900T30D 주파수 설정 방법

#include <SoftwareSerial.h>
#include "EBYTE.h"

#define PIN_M0 4
#define PIN_M1 5
#define PIN_AX 6

SoftwareSerial LoRa(2, 3);
EBYTE Transceiver(&LoRa, PIN_M0, PIN_M1, PIN_AX);

void setup()
{
    Serial.begin(115200);
    LoRa.begin(9600);
    Transceiver.init();            // 초기화
    Transceiver.SetChannel(60);    // 채널(주파수) 설정
    Transceiver.SaveParameters();  // 설정 저장
}

void loop()
{
}

출력세기 (Transmission Power)

출력세기는 주파수 채널별로 다른데 자세한건 아래 포스트에서 확인할 수 있다.

[Arduino] LoRa Step 3 - 대한민국에서 LoRa를 사용하기 위한 법 조항

전파법 LoRa를 처음 접하는 사람이라면 갑자기 왜 법을 언급하는데 의아해 할 수도 있다. 하지만 전파는 공공재이기 때문에 국가의 관리하에 사용해야한다. 로라는 주파수를 사용해 통신하기 때

crazyhacker.tistory.com

E32-900T30D 출력세기 종류

해당 모듈의 출력세기는 데이터 시트에 나와 있듯이 총 4종류를 지원하는데 필자도 몰랐던 사실이지만 mW(밀리와트)와 dBm(데시벨 밀리와트)가 다르다는 것이었다. 위 포스팅에서는 단위가 mW로 표시되어 있지만 데이터 시트에는 dBm으로 표시되어 있다. 그래서 해당 단위를 변환해줄 필요가 있다. 아래 사이트에서 변환이 가능하다.

dBm to Watt Caluclator - everything RF

What is dBm to watts conversion calculator? dBm to Watts conversion calculator converts the power value in dBm to Watts value. Watt (W) is a SI unit for measuring the power and dBm is a decibel unit for measuring the power. How to calculate power (in watt)

www.everythingrf.com

실제로 사이트에서 변환하면 충격적인 결과를 알 수 있는데 바로 30dBm이 1W 였던 것이다...

E32-900T30D 출력세기 설정 방법

우리가 사용할 수 있는 최대 출력세기는 200mW 인데 1W면 규정치에 5배나 되는 세기이다. 이러한 출력 세기를 지속적으로 사용하면 무조건 문제가 발생할 수 밖에 없다.

제일 낮은 21dBm을 확인해보면 125mW 인것을 확인할 수 있다.

그렇다면 채널은 20 ~ 32 (920.9 ~ 923.3 MHz)를 사용하면 실외 고정용 점대점 무선기기에 한해서 200mW 이하의 출력세기를 사용할 수 있다. 그렇다는 건 밖에서 움직이며 사용할 수 없다는 것을 뜻한다...

어쩔 수 없지만 지금 있는 E32-900T30D 모듈을 사용하기 위해서는 이 방법 말고는 없다.

#include <SoftwareSerial.h>
#include "EBYTE.h"

#define PIN_M0 4
#define PIN_M1 5
#define PIN_AX 6

SoftwareSerial LoRa(2, 3);
EBYTE Transceiver(&LoRa, PIN_M0, PIN_M1, PIN_AX);

void setup()
{
    Serial.begin(115200);
    LoRa.begin(9600);
    Transceiver.init();                 // 초기화
    Transceiver.SetChannel(60);         // 채널(주파수) 설정
    Transceiver.SetTransmitPower(0b11); // 출력세기 설정
    Transceiver.SaveParameters();       // 설정 저장
}

void loop()
{
}

마무리

필자가 생각했을 때 가장 중요한 요소는 주파수와 출력세기라고 생각했기 때문에 이번 포스팅에서는 두가지만 소개했다. UART Baud Rate나 Air Data Rate는 어떻게 설정하더라고 법적으로 큰 문제가 없는 것같아서 다음 포스팅에서는 이 외에 설정들을 셋팅하는 것을 해보려고 한다

[Wireshark] Tree에 Item을 추가해 데이터 시각화하기

미친해커 — Sat, 30 Jul 2022 04:53:28 +0900

이번 포스팅에서는 와이어샤크의 Tree(트리)에 TreeItem을 생성하고 생성된 TreeItem에 Item을 추가해 데이터를 보다 보기 좋게 시각화하려고 한다.

이전 포스팅을 읽지 않았다면 읽는 것을 추천한다.

[Wireshark] Dissector로 프로토콜 만들기

Create a Protocol use Wireshark API 우선 Wireshark(와이어샤크)에서 제공하는 API를 활용해 직접 프로토콜을 정의한다. MyProto = Proto.new("MyProto", "My Custom Protocol") Define Dissector of MyProto 새..

crazyhacker.tistory.com

How to add TreeItem to Wireshark

dissector의 인자로 들어오는 root를 이용해 TreeItem을 생성할 수 있다.

MyProto = Proto.new("MyProto", "My Custom Protocol")

function MyProto.dissector(buf, pinfo, root)
    pinfo.cols.protocol = "MY_PROTOCOL"
    local st = root:add(MyProto, "MY PROTOCOL DATA", buf(0, buf:len()))
end

DissectorTable.get("tcp.port"):add(8080, MyProto)

위 코드는 MY PROTOCOL DATA라는 이름의 트리 아이템을 추가하는 코드이다. 생성된 트리 아이템을 변수에 저장해야 하위에 아이템을 생성할 수 있다.

How to add Sub-Item for TreeItem

위에서 생성한 트리 아이템에 아이템을 추가해 데이터를 보기 좋게 만들 수 있다.

st:add(buf(0), "Data: " .. buf(0):bytes():tohex())

위 이미지와 같이 아이템이 생성된 것을 확인할 수 있다.

생성된 아이템을 클릭해보면 아래에 해당되는 데이터가 파란색으로 하이라이트 되는 것을 볼 수 있는데 이는 자동적으로 되는 것이 아니라 st:add 함수에서 첫 번째 인자로 해당 범위를 지정해주는 것이다.

st:add(buf(0, 2), "Data: " .. buf(0, 2):bytes():tohex())

위 코드를 예로 들자면 buf(0, 2) 는 TCP 프로토콜 Payload의 오프셋 0부터 2바이트를 아이템의 범위로 지정해준다는 의미이다. 맨 위의 예시에서는 offset만 지정해주고 length는 지정하지 않았기 때문에 오프셋 0부터 모든 데이터가 범위로 지정됐다.

[Reversing] EAT Hooking Step 2

미친해커 — Thu, 28 Jul 2022 04:10:47 +0900

이번 포스팅에서는 EAT에서 함수의 주소를 구하는 원리와 EAT 후킹 방법에 대해 설명하려고 한다. EAT는 IAT와 다르게 오프셋이 저장되기 때문에 x86이라면 모를까 x64 환경에서는 100% 성공한다고 장담할 수는 없다. 하지만 해당 블로그는 따로 명시되어 있지 않다면 Windows x64를 기준으로 작성하기 때문에 x64 환경에서 EAT 후킹 방법에 대해서 설명하려고 한다.

How to do EAT hooking ways?

EAT에서 사용하는 오프셋은 최대 4바이트로 Windows x64는 8바이트 주소를 사용하기 때문에 해당 DLL의 ImageBase로부터 4바이트 이상의 주소로 이동하도록 후킹할 수는 없다.

위에서 설명했지만 주소가 4바이트를 넘지 않는다면 오프셋만 덮어씌워서 후킹이 가능하다. (여기에서는 편리를 위해 x86을 기반으로 코드를 작성하겠다)

#include <stdio.h>
#include <windows.h>

int WINAPI NewMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType)
{
    return MessageBoxA(hWnd, "Hooked..!", "Hooked..!", uType);
}

int main(int argc, char *argv[])
{
    ULONG_PTR ImageBase = GetModuleHandleA("user32.dll");

    if (ImageBase == NULL)
        ImageBase = LoadLibraryA("user32.dll");

    int (WINAPI *HookMessageBoxA)(HWND, LPCSTR, LPCSTR, UINT) = GetProcAddress(ImageBase, "MessageBoxA");
    HookMessageBoxA(NULL, "Not Hooked..!", "Not Hooked..!", 0);

    printf("[*] Module Name : user32.dll\n");
    printf("[*] ImageBase : %p\n", ImageBase);

    IMAGE_DOS_HEADER *DOS = ImageBase;
    printf("[*] Image Dos Header : 0x%p\n", DOS);

    IMAGE_NT_HEADERS *NT = ImageBase + DOS->e_lfanew;
    printf("[*] Image Nt Header : 0x%p\n", NT);

    IMAGE_EXPORT_DIRECTORY *EXPORT = ImageBase + NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
    printf("[*] Export Table : 0x%p\n", EXPORT);

    printf("[+] Number Of Functions : %d\n", EXPORT->NumberOfFunctions);
    printf("[+] Number Of Names : %d\n", EXPORT->NumberOfNames);

    DWORD *AddressOfFunctions = ImageBase + EXPORT->AddressOfFunctions;
    DWORD *AddressOfNames = ImageBase + EXPORT->AddressOfNames;
    WORD *AddressOfNameOrdinals = ImageBase + EXPORT->AddressOfNameOrdinals;

    for (int i = 0; i < EXPORT->NumberOfNames; i++)
    {
        if (strcmp(ImageBase + AddressOfNames[i], "MessageBoxA") == 0)
        {
            DWORD flOldProtect;
            VirtualProtect(&AddressOfFunctions[AddressOfNameOrdinals[i]], 4, PAGE_READWRITE, &flOldProtect);
            AddressOfFunctions[AddressOfNameOrdinals[i]] = (ULONG_PTR)NewMessageBoxA - (ULONG_PTR)ImageBase;
            break;
        }
    }

    HookMessageBoxA = GetProcAddress(ImageBase, "MessageBoxA");
    HookMessageBoxA(NULL, "Not Hooked..!", "Not Hooked..!", 0);

    return 0;
}

EAT Hooking.exe

0.05MB

[*] Module Name : user32.dll
[*] ImageBase : 766C0000
[*] Image Dos Header : 0x766C0000
[*] Image Nt Header : 0x766C00E8
[*] Export Table : 0x7675CC10
[+] Number Of Functions : 1215
[+] Number Of Names : 998

위 코드를 x86 아키텍쳐로 컴파일 후 실행하면 처음에 GetProcAddress 함수를 이용해 구한 함수는 정상적으로 메시지가 출력되지만 두번째에 GetProcAddress 함수를 이용해 구한 함수는 인자가 조작되어 호출되는 것을 확인할 수 있따.

이렇게 GetProcAddress 함수를 통해 구한 MessageBoxA 함수의 주소와 NewMessageBoxA 함수의 주소가 같은 것을 확인할 수 있다. 하지만 IAT를 통해 함수를 호출하는 경우에는 후킹이 되지 않고 정상적인 호출이 가능하다.

[Wireshark] Dissector로 프로토콜 만들기

미친해커 — Thu, 28 Jul 2022 03:51:30 +0900

Create a Protocol use Wireshark API

우선 Wireshark(와이어샤크)에서 제공하는 API를 활용해 직접 프로토콜을 정의한다.

MyProto = Proto.new("MyProto", "My Custom Protocol")

Define Dissector of MyProto

새롭게 생성한 프로토콜의 대한 dissector를 정의해준다.

function MyProto.dissector(buf, pinfo, root)
    pinfo.cols.protocol = "MY_PROTOCOL"
    root:add(MyProto, "MY PROTOCOL DATA", buf(0))
end

dissector 함수의 인자는 총 3개 이며 각각 패킷 데이터, 패킷 정보, 패킷 프레임?이다.

Parameter buf

dissector의 buf는 와이어샤크에서 실질적인 데이터를 버퍼를 가리킨다. (Tvb object)

buf에 해당되는 부분

하지만 이더넷 헤더와 같은 정보들은 포함되어 있지 않다. buf에 들어오는 데이터는 payload만 들어오게 된다.

buf에 들어오는 데이터

Parameter pinfo

dissector의 pinfo는 와이어샤크의 패킷의 정보를 표시하는 테이블을 가리킨다. (Pinfo object)

pinfo에는 Number, Time, Protocol 등의 Column의 정보를 수정할 수 있고 또 새로운 Column을 추가할 수 있다. 다음 코드는 Protocol Column의 데이터를 수정한다.

pinfo.cols.protocol = "MY_PROTOCOL"

Protocol 컬럼이 변경된 모습

Parameter root

dissector의 root는 와이어샤크의 패킷의 데이터를 표시하는 트리를 가리킨다. (TreeItem object)

와이어샤크의 중앙에 있는 이 트리는 해당 패킷의 프로토콜에 맞춰서 패킷의 데이터를 보기 편하게 구분하여 보여준다. 우리가 만든 커스텀 프로토콜은 이러한 트리 구조가 등록되어 있지 않기 때문에 아무런 트리가 생성되지 않게 된다. root는 이 트리들이 모여있는 곳을 말한다. 다음 코드는 새로운 트리를 생성하는 코드이다.

root:add(MyProto, "MY PROTOCOL DATA", buf(0))

MY PROTOCOL DATA 트리가 생성된 모습

Set the MyProto

이제는 저 수 많은 패킷중 어떤 패킷이 MyProto에 속하는 패킷인지 설정해야 한다. 해당 방법은 와이어샤크의 필터를 사용하는 방법과 유사하다.

DissectorTable.get("tcp.port"):add(8080, MyProto)

위 코드는 TCP 프로토콜의 포트가 8080일 경우 MyProto로 설정한다는 말이다. 이렇게 설정하게 된다면 8080 포트로 통신하는 모든 TCP 패킷들이 MyProto.dissector 함수를 거치게 된다.

최종 코드

MyProto = Proto.new("MyProto", "My Custom Protocol")

function MyProto.dissector(buf, pinfo, root)
    pinfo.cols.protocol = "MY_PROTOCOL"
    root:add(MyProto, "MY PROTOCOL DATA", buf(0, buf:len()))
end

DissectorTable.get("tcp.port"):add(8080, MyProto)

마무리

여기까지 Lua 스크립트를 이용해 와이어샤크에 커스텀 프로토콜을 추가해 하위 트리를 생성 그리고 프로토콜의 이름을 수정하는 방법을 알아보았다.

다음 포스팅에서는 우리가 생성했던 하위 트리(MY PROTOCOL DATA)에 Item을 생성하여 데이터를 분류하여 표시하는 방법을 알아보려고 한다.

[Wireshark] Lua Script 개발 환경설정

미친해커 — Thu, 28 Jul 2022 03:15:10 +0900

Install Visual Studio Code Lua Script Extenstion

VS Code에서 Lua Script에 대한 확장을 설치해줘야 한다.

환경설정 끝

Lua를 이용해 Wireshark의 스크립트를 추가할 계획이기 때문에 따로 Lua를 설치해줄 필요는 없다. 그리고 사실 VS Code에서 Lua 확장을 설치하던 설치하지 않던 큰 차이는 발생하지 않는다. 어차피 Wireshark의 API 함수들을 VS Code가 자동으로 IntelliSense 해주지 못하기 때문이다.

[Reversing] EAT Hooking Step 1

미친해커 — Thu, 28 Jul 2022 02:31:13 +0900

[Reversing] EAT Hooking Step 0

EAT Hooking EAT(Export Address Table) Hooking 이란 EAT의 API 주소를 조작하여 후킹하는 기법을 말한다. EAT에는 라이브러리가 외부로 Export 하는 함수명 또는 변수명과 주소가 기록되어 있다. 응용 프로그램..

crazyhacker.tistory.com

이전 포스팅에서 EAT 구조에 대해서 간단히 배웠었다. 이번 포스팅에서는 C언어를 활용해 실제 EAT에 등록되어 있는 함수들의 이름과 주소를 불러오는 프로그램을 만들어볼 예정이다.

Get Library ImageBase

EAT 주소를 구하기 위해서는 IMAGE_DOS_HEADER(Dos Header)를 구해야 한다. Dos Header의 주소는 해당 라이브러리의 ImageBase의 주소와 동일하다.

ULONGLONG ImageBase = GetModuleHandleA("user32.dll");

GetModuleHandleA

GetModuleHandleA API는 특정 라이브러리의 ImageBase를 반환하는 함수이다.

LPCSTR(const char *) 자료형을 인자로 받으며 라이브러리의 이름을 전달하면 된다. NULL이 전달될 경우 해당 함수는 현재 프로그램의 ImageBase를 반환한다.

HMODULE GetModuleHandleA(LPCSTR lpModuleName);

GetModuleHandleA function (libloaderapi.h) - Win32 apps

Retrieves a module handle for the specified module. The module must have been loaded by the calling process. (ANSI)

docs.microsoft.com

실제 함수 원형을 살펴보면 HMODULE이라는 Handle(핸들)을 반환하지만 이는 과거 MS-DOS 시절의 호환성을 위한 것일 뿐, 신경 쓰지 않아도 된다. 실제 반환되는 값을 확인해보면 ImageBase의 주소인 것을 확인할 수 있다.

How to get EAT Address From DOS Header

EAT 주소를 구하기 전 NT Header의 주소를 구해야 한다. NT Header 주소는 Dos Header를 이용해 구할 수 있다.

First, Get NT Header From DOS Header

Dos Header의 e_lfanew 멤버 변수와 ImageBase를 더하는 방법으로 NT Header 주소를 구할 수 있다.

IMAGE_DOS_HEADER *DOS = ImageBase;
printf("Image Dos Header : 0x%p\n", DOS);

IMAGE_NT_HEADERS *NT = ImageBase + DOS->e_lfanew;
printf("Image Nt Header : 0x%p\n", NT);

위에서 구했던 ImageBase 주소를 DOS Header의 주소로 설정하고 참조 연산자를 이용해 e_lfanew에 접근하여 NT Header 주소를 구할 수 있다.

NT Header는 x86, x64 이렇게 나뉘는데 해당 포스팅에서는 x64를 기준으로 설명한다. 하지만 x86, x64 간의 큰 차이는 없다.

Second, Get EAT Address From NT Header

NT Header의 Optional Header에 있는 DataDirectory 0번째 인덱스(IMAGE_DIRECTORY_ENTRY_EXPORT를 사용하면 된다)에 EAT의 RVA가 기록되어 있다.

IMAGE_EXPORT_DIRECTORY *EXPORT = ImageBase + NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
printf("Export Table : 0x%p\n", EXPORT);

printf("Number Of Functions : %d\n", EXPORT->NumberOfFunctions);
printf("Number Of Names : %d\n", EXPORT->NumberOfNames);

VA = ImageBase + RVA 공식이 성립하기 때문에 ImageBase에 RVA를 더하여 실제 EAT 주소를 구할 수 있다.

위 코드를 보면 IMAGE_DIRECTORY_ENTRY_EXPORT를 사용해 인덱스를 구하는데 헤더파일을 보면 DataDirectory 각각의 위치가 정의 되어 있다.

#define IMAGE_DIRECTORY_ENTRY_EXPORT          0
#define IMAGE_DIRECTORY_ENTRY_IMPORT          1
#define IMAGE_DIRECTORY_ENTRY_RESOURCE        2
#define IMAGE_DIRECTORY_ENTRY_EXCEPTION       3
#define IMAGE_DIRECTORY_ENTRY_SECURITY        4
#define IMAGE_DIRECTORY_ENTRY_BASERELOC       5
#define IMAGE_DIRECTORY_ENTRY_DEBUG           6
#define IMAGE_DIRECTORY_ENTRY_ARCHITECTURE    7
#define IMAGE_DIRECTORY_ENTRY_GLOBALPTR       8
#define IMAGE_DIRECTORY_ENTRY_TLS             9
#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG    10
#define IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT   11
#define IMAGE_DIRECTORY_ENTRY_IAT            12
#define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT   13
#define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14

Print a Function Name and Address

함수 주소는 Ordinal을 이용해 구할 수 있다. Ordinal이란 AddressOfFunctions의 인덱스로 사용된다.

AddressOfNameOrdinals에서 현재 인덱스의 해당되는 함수명의 함수 주소의 Ordinal을 구할 수 있다.

for (int i = 0; i < EXPORT->NumberOfNames; i++)
{
    printf("%s : %p\n", ImageBase + *(DWORD *)(ImageBase + EXPORT->AddressOfNames + i * 4), ImageBase + *(DWORD *)(ImageBase + EXPORT->AddressOfFunctions + *(WORD *)(ImageBase + EXPORT->AddressOfNameOrdinals + i * 2) * 4));
}

Export 되는 함수들이 반드시 함수명을 포함해서 Export 되는 것은 아니다. 그렇기 때문에 예시에서는 NumberOfNames로 이름이 존재하는 함수들의 대한 정보만 출력했다.

필자도 알고 있다. 위 예시코드는 내가 봐도 복잡하고 이해하기 어렵다. 그렇기 때문에 보다 이해하기 쉽게 코드를 바꿔보면 아래와 처럼도 사용할 수 있다.

DWORD *AddressOfFunctions = ImageBase + EXPORT->AddressOfFunctions;
DWORD *AddressOfNames = ImageBase + EXPORT->AddressOfNames;
WORD *AddressOfNameOrdinals = ImageBase + EXPORT->AddressOfNameOrdinals;

for (int i = 0; i < EXPORT->NumberOfNames; i++)
{
    printf("%s : %p\n", ImageBase + AddressOfNames[i], ImageBase + AddressOfFunctions[AddressOfNameOrdinals[i]]);
}

위 코드가 훨씬도 가독성이 좋고 예쁘지만 필자는 쓸 때 없는 메모리 사용을 싫어하기 때문에 변수를 사용하지 않고 라인 하나로 처리하는 것을 좋아한다.~~(이거 쓰면서 생각났는데 그럼 register 변수를 선언하면 되는 거였다...)~~

Compile and Troubleshooting

왜 제목을 컴파일 그리고 트러블 슈팅이라고 했을까? 그렇다.. 위에 예시 코드 그대로 이어서 컴파일하면 무조건 런타임 에러가 발생할 것이다. 그래도 우선 컴파일하고 실행해보자 아래는 완성된 코드다.

#include <stdio.h>
#include <windows.h>

int main(int argc, char *argv[])
{
    ULONGLONG ImageBase = LoadLibraryA("user32.dll");

    IMAGE_DOS_HEADER *DOS = ImageBase;
    printf("Image Dos Header : 0x%p\n", DOS);

    IMAGE_NT_HEADERS *NT = ImageBase + DOS->e_lfanew;
    printf("Image Nt Header : 0x%p\n", NT);

    IMAGE_EXPORT_DIRECTORY *EXPORT = ImageBase + NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
    printf("Export Table : 0x%p\n", EXPORT);

    printf("Number Of Functions : %d\n", EXPORT->NumberOfFunctions);
    printf("Number Of Names : %d\n", EXPORT->NumberOfNames);

    DWORD *AddressOfFunctions = ImageBase + EXPORT->AddressOfFunctions;
    DWORD *AddressOfNames = ImageBase + EXPORT->AddressOfNames;
    WORD *AddressOfNameOrdinals = ImageBase + EXPORT->AddressOfNameOrdinals;

    for (int i = 0; i < EXPORT->NumberOfNames; i++)
    {
        printf("%s : %p\n", ImageBase + AddressOfNames[i], ImageBase + AddressOfFunctions[AddressOfNameOrdinals[i]]);
    }
}

아마 아래와 같이 출력되고 프로그램이 강제 종료될 것이다.

Image Dos Header : 0x0000000000000000

출력된 결과를 보면 GetModuleHandleA의 반환 값이 NULL이라는 것을 알 수 있는데 왜 NULL을 반환하는 걸까?

Why dose GetModuleHandleA Return NULL?

GetModuleHandleA가 NULL을 반환하는 이유는 MSDN을 확인해보면 알 수 있다.

파라미터 항목에 분명하게 "로드된 모듈의 이름" 이라고 적혀있다. 런타임 에러가 발생하는 원인은 해당 프로세스에 user32.dll이 로드되어 있지 않기 때문이다.

Solution

해결방법은 간단하다. 로드되어 있지 않는 것이 문제라면 로드시키면 된다. 모듈을 로드를 하기 위해서는 다음 함수를 사용하면 된다.

HMODULE LoadLibraryA(LPCSTR lpLibFileName);

LoadLibraryA function (libloaderapi.h) - Win32 apps

Loads the specified module into the address space of the calling process. (LoadLibraryA)

docs.microsoft.com

LoadLibraryA는 GetModuleHandleA와 똑같이 해당 모듈의 ImageBase를 반환한다.

차이점은 GetModuleHandleA 모듈이 로드되어 있어야 하는 것이라면 LoadLibraryA는 모듈이 로드되어 있지 않다면 해당 모듈을 로드하고 ImageBase를 반환한다. 즉 모듈이 존재하지 않는 이상 NULL이 반환되지 않는다.

이제 코드를 수정해보자

Modified Code

#include <stdio.h>
#include <windows.h>

int main(int argc, char *argv[])
{
    ULONGLONG ImageBase = GetModuleHandleA("user32.dll");
    
    if (ImageBase == NULL)
        ImageBase = LoadLibrary("user32.dll");

    IMAGE_DOS_HEADER *DOS = ImageBase;
    printf("Image Dos Header : 0x%p\n", DOS);

    IMAGE_NT_HEADERS *NT = ImageBase + DOS->e_lfanew;
    printf("Image Nt Header : 0x%p\n", NT);

    IMAGE_EXPORT_DIRECTORY *EXPORT = ImageBase + NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
    printf("Export Table : 0x%p\n", EXPORT);

    printf("Number Of Functions : %d\n", EXPORT->NumberOfFunctions);
    printf("Number Of Names : %d\n", EXPORT->NumberOfNames);

    DWORD *AddressOfFunctions = ImageBase + EXPORT->AddressOfFunctions;
    DWORD *AddressOfNames = ImageBase + EXPORT->AddressOfNames;
    WORD *AddressOfNameOrdinals = ImageBase + EXPORT->AddressOfNameOrdinals;

    for (int i = 0; i < EXPORT->NumberOfNames; i++)
    {
        printf("%s : %p\n", ImageBase + AddressOfNames[i], ImageBase + AddressOfFunctions[AddressOfNameOrdinals[i]]);
    }
}

수정된 코드를 다시 컴파일해 실행해보면 정상적으로 실행되는 것을 볼 수 있다.

Image Dos Header : 0x00007FFA16120000
Image Nt Header : 0x00007FFA161200F8
Export Table : 0x00007FFA161C1D50
Number Of Functions : 1215
Number Of Names : 1005
ActivateKeyboardLayout : 00007FFA1614C660
AddClipboardFormatListener : 00007FFA1614CE40
------------중략------------
wsprintfW : 00007FFA161499A0
wvsprintfA : 00007FFA161473F0
wvsprintfW : 00007FFA161499D0

다음 포스팅에서는 실제 EAT 후킹을 해볼 생각이다.

[Reversing] EAT Hooking Step 0

미친해커 — Tue, 19 Jul 2022 23:44:20 +0900

EAT Hooking

EAT(Export Address Table) Hooking 이란 EAT의 API 주소를 조작하여 후킹하는 기법을 말한다.

EAT에는 라이브러리가 외부로 Export 하는 함수명 또는 변수명과 주소가 기록되어 있다.

응용 프로그램 또는 다른 라이브러리가 GetProcAddress를 사용하여 라이브러리가 Export 하는 함수 또는 변수의 주소를 가져온다. 이때 GetProcAddress API는 이 테이블을 참조하여 주소를 구한다. EAT Hooking은 이 원리를 이용한 후킹 기법이다.

EAT Structure

EAT 구조는 아래와 같다.

typedef struct _IMAGE_EXPORT_DIRECTORY {
    DWORD Characteristics;
    DWORD TimeDateStamp;
    WORD MajorVersion;
    WORD MinorVersion;
    DWORD Name;                  // 라이브러리의 이름
    DWORD Base;
    DWORD NumberOfFunctions;     // export 함수의 개수
    DWORD NumberOfNames;         // export 함수 중 이름을 가지는 함수의 개수
    DWORD AddressOfFunctions;    // 함수의 RVA를 가지는 배열의 시작 주소
    DWORD AddressOfNames;        // 함수 이름의 RVA를 가지는 배열의 시작 주소
    DWORD AddressOfNameOrdinals; // 이름이 있는 함수의 Oridnal 배열의 시작 주소
} IMAGE_EXPORT_DIRECTORY,*PIMAGE_EXPORT_DIRECTORY;

이 중에서 자주 사용하는 멤버 변수는 아래와 같다.

NumberOfFunctions
NumberOfNames
AddressOfFunctions
AddressOfNames
AddressOfNameOrdinals

How to get IMAGE_EXPORT_DIRECTORY address?

IMAGE_EXPORT_DIRECTORY의 주소는 어떻게 구할 수 있을까?

IMAGE_EXPORT_DIRECTORY는 NT Header(IMAGE_NT_HEADER)를 통해 구할 수 있다.

NT Header의 Optional Header를 보면 DataDirectory가 배열로 존재한다. DataDirectory의 0번째 인덱스의 VirtualAddress가 IMAGE_EXPORT_DIRECTORY의 RVA이다. 코드로 나타낸다면 아래와 같다.

IMAGE_NT_HEADERS *NT;
IMAGE_IMPORT_DESCRIPTOR *IMPORT = ImageBase + NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;

이번 포스팅에서 EAT를 이해하려고 하지 않아도 된다. 다음 포스팅부터 C언어로 작성된 코드를 보면 EAT에 대해 보다 빠르게 이해할 수 있을 것같다.

[WoW] WoW 프로세스의 커널 함수 호출 과정

미친해커 — Tue, 14 Jun 2022 11:09:22 +0900

How are ntdll.dll and WoW ntdll.dll different?

ntdll.dll은 커널 함수가 정의 되어 있는 DLL이다. 유저 모드의 커널 함수들은 syscall을 통해 커널 함수를 호출할 수 있다. 하지만 운영체제(커널)은 64Bit이며 WoW 프로세스는 32Bit로 동작한다. 그렇기에 32Bit 프로세스는 syscall 하기 전 64Bit 모드로 전환할 필요가 있다.

<좌> WoW ntdll.dll <우> 64Bit ntdll.dll

위 이미지와 같이 WoW ntdll.dll의 경우 syscall number를 eax 레지스터에 지정하고 syscall이 아닌 call edx로 어떠한 함수를 호출하는 것을 확인할 수 있다.

Which function is invoked using edx register?

call edx는 ntdll!Wow64SystemServiceCall함수를 호출한다.

해당 함수는 ntdll!Wow64Transition를 참조해 다른 함수로 점프한다.

ntdll!Wow64SystemServiceCall에서 wow64cpu!KiFastSystemCall로 넘어가게 된다.

<좌> IDA Pro <우> Cheat Engine x64

아쉽게도 IDA Pro에서는 jmp far 어셈블리가 해석되지 않는다. 아무래도 Opcode 0xEA 어셈블리가 지원되지 않는 모양이다.

jmp far 0033:XXXXXXXX 는 아래에 있는 jmp qword ptr ds:[r15+0xF8]으로 이동하게 된다.

여기부터는 64Bit 모드로 동작하게 된다. 계속해서 r15 레지스터에 어떤 값이 들어가 있는지 확인해야 한다.

What is the value of the r15 register?

점프하기 전 레지스터의 상태

r15 레지스터가 가르키는 주소로 이동해 값을 확인

r15가 0x77893620이고 해당 주소는 wow64cpu!TurboThunkDispatch의 주소라는 것을 Windbg를 통해 알 수 있었다.

Where is the address to jump (jmp qword ptr ds:[r15+0xF8])

r15(0x77893620) + 0xF8 = 0x77893718

0x77893718에는 wow64cpu!CpupReturnFromSimulatedCode의 주소가 작성되어 있다.

이렇게 64Bit 모드로 전환하고 점프(호출)하는 함수를 알아낼 수 있었다.

wow64cpu!CpupReturnFromSimulatedCode

다음 함수의 어셈블리를 먼저 확인해보자

wow64cpu!CpupReturnFromSimulatedCode, wow64cpu!TurboDispatchJumpAddressStart, wow64cpu!ServiceNoTurbo함수가 있는 것을 확인할 수 있다.

wow64cpu!CpupReturnFromSimulatedCode와 wow64cpu!TurboDispatchJumpAddressStart는 하나의 함수 처럼 이어져 있다.

wow64cpu!TurboDispatchJumpAddressStart에서 jmp qword ptr ds:[r15+rcx*8]을 하게 되는데 디버깅 결과, wow64cpu!ServiceNoTurbo로 이동하는 것을 확인했다.

wow64cpu!ServiceNoTurbo는 wow64cpu!TurboDispatchJumpAddressEnd라고도 불린다.

다음은 호출은 call qword ptr ds:[wow64cpu!_imp_Wow64SystemServiceEx]이다.

wow64cpu!_imp_Wow64SystemServiceEx

심볼 네이밍을 보면 Wow64SystemServiceEx를 wow64cpu.dll이 import 하기 때문에 IAT에 등록되어 있음을 알 수 있다.

Wow64SystemServiceEx는 wow64.dll에 존재하는 것을 확인 했고 해당 함수를 IDA Pro로 확인해보았다.

전체 코드는 아래 더보기를 클릭하면 나온다.

__int64 __fastcall Wow64SystemServiceEx(unsigned int SyscallNumber, __int64 a2)
{
  struct _TEB *v3; // rdi
  __int64 v4; // r8
  __int64 v5; // rdx
  struct _TEB *v6; // rbx
  __int64 v7; // rax
  __int64 (__fastcall *v8)(__int64); // rsi
  _QWORD *v9; // rsi
  __int64 *v10; // rdi
  __int64 *v11; // rax
  __int64 v12; // rcx
  _QWORD *v14; // rcx
  unsigned int v15; // [rsp+20h] [rbp-898h]
  PVOID v16; // [rsp+38h] [rbp-880h] BYREF
  int v17; // [rsp+40h] [rbp-878h]
  char v18[8]; // [rsp+48h] [rbp-870h] BYREF
  __int64 v19; // [rsp+50h] [rbp-868h]
  unsigned int v20; // [rsp+58h] [rbp-860h]
  unsigned int v21; // [rsp+5Ch] [rbp-85Ch]
  unsigned int v22; // [rsp+60h] [rbp-858h]
  char v23; // [rsp+64h] [rbp-854h]
  PVOID v24; // [rsp+70h] [rbp-848h] BYREF
  __int64 v25[259]; // [rsp+78h] [rbp-840h] BYREF
  __int64 v26; // [rsp+890h] [rbp-28h] BYREF

  v16 = NtCurrentTeb()->TlsSlots[12];
  v3 = 0i64;
  v17 = 0;
  NtCurrentTeb()->TlsSlots[12] = &v16;
  v4 = (SyscallNumber >> 12) & 3;
  v5 = SyscallNumber & 0xFFF;
  if ( (unsigned int)v5 > LODWORD(ServiceTables[3 * v4 + 1]) )
  {
    v15 = 0xC000001C;
  }
  else
  {
    v6 = NtCurrentTeb();
    v7 = (int)v6->SpareUlong0;
    if ( (_DWORD)v7 )
    {
      if ( (int)v7 < 0 )
        v3 = v6;
      else
        v3 = (struct _TEB *)((char *)v6 + v7);
    }
    v24 = v6->TlsSlots[3];
    v25[1] = (__int64)v25;
    v25[0] = (__int64)v25;
    v25[2] = (__int64)&v26;
    v6->TlsSlots[3] = &v24;
    v8 = *(__int64 (__fastcall **)(__int64))(*(_QWORD *)&ServiceTables[3 * v4] + 8 * v5);
    v20 = (SyscallNumber >> 12) & 3;
    v21 = SyscallNumber & 0xFFF;
    v6->LastErrorValue = HIDWORD(v3->NtTib.Self);
    if ( pfnWow64LogSystemService )
    {
      v19 = a2;
      v23 = 0;
      Wow64LogSystemServiceWrapper(v18);
      v15 = v8(a2);
      v23 = 1;
      v22 = v15;
      Wow64LogSystemServiceWrapper(v18);
    }
    else if ( v8 == whNtSetTimerEx )
    {
      v15 = whNtSetTimerEx(a2);
    }
    else if ( v8 == whNtCallbackReturn )
    {
      v15 = whNtCallbackReturn(a2);
    }
    else if ( v8 == whNtQueryVirtualMemory )
    {
      v15 = whNtQueryVirtualMemory(a2);
    }
    else if ( v8 == whNtOpenKeyEx )
    {
      v15 = whNtOpenKeyEx(a2);
    }
    else if ( v8 == whNtQueryValueKey )
    {
      v15 = whNtQueryValueKey(a2);
    }
    else
    {
      v15 = v8(a2);
    }
    HIDWORD(v3->NtTib.Self) = v6->LastErrorValue;
    v9 = v6->TlsSlots[3];
    v10 = v9 + 1;
    v11 = (__int64 *)v9[1];
    v12 = *v11;
    if ( (_QWORD *)v11[1] != v9 + 1 || *(__int64 **)(v12 + 8) != v11 )
      __fastfail(3u);
    *v10 = v12;
    for ( *(_QWORD *)(v12 + 8) = v10; v11 != v10; v14[1] = v10 )
    {
      RtlFreeHeap(NtCurrentPeb()->ProcessHeap, 0, v11);
      v11 = (__int64 *)*v10;
      v14 = *(_QWORD **)*v10;
      if ( *(__int64 **)(*v10 + 8) != v10 || (__int64 *)v14[1] != v11 )
        __fastfail(3u);
      *v10 = (__int64)v14;
    }
    v6->TlsSlots[3] = (PVOID)*v9;
  }
  NtCurrentTeb()->TlsSlots[12] = v16;
  if ( *(_DWORD *)(Wow64InfoPtr + 8) && (v17 & 3) == 0 && (v17 & 4) == 0 )
    Wow64SetupForInstrumentationReturn();
  return v15;
}

__int128 ServiceTables[];

__int64 __fastcall Wow64SystemServiceEx(unsigned int SyscallNumber, __int64 a2)
{
  .....
  v4 = (SyscallNumber >> 12) & 3; // Syscall Number가 정상이라면 0
  v5 = SyscallNumber & 0xFFF;     // Syscall Number가 정상이라면 0
  /*
    LODWORD(ServiceTables[3 * v4 + 1])의 값이 정상적인 Syscall Number를
    인자로 받은 호출이라면 0x1000이 된다. 그러기에 반드시 else 빠지는 것이
    정상적인 진행이다.
  */
  if ( (unsigned int)v5 > LODWORD(ServiceTables[3 * v4 + 1]) )
  {
    v15 = 0xC000001C;
  }
  else
  {
    ....
    //whNtXXXXX Syscall Number에 맞는 함수 주소를 가져옴
    v8 = *(__int64 (__fastcall **)(__int64))(*(_QWORD *)&ServiceTables[3 * v4] + 8 * v5);
    v20 = (SyscallNumber >> 12) & 3;
    v21 = SyscallNumber & 0xFFF;
    v6->LastErrorValue = HIDWORD(v3->NtTib.Self);
    if ( pfnWow64LogSystemService )
    {
      v19 = a2;
      v23 = 0;
      Wow64LogSystemServiceWrapper(v18);
      v15 = v8(a2);
      v23 = 1;
      v22 = v15;
      Wow64LogSystemServiceWrapper(v18);
    }
    else if ( v8 == whNtSetTimerEx )
    {
    ....
    else
    {
      v15 = v8(a2); // whNtxxxxxx 함수 호출
    }
    ....
}

분석해본 결과 v8에 현재 호출한 커널 함수 이름의 wh(ex: whNtxxxxxxx)를 붙인 함수의 주소를 저장한다.

예를 들어 NtOpenProcess를 호출했다면, v8에는 whNtOpenProcess의 주소가 담긴다. 그리고 해당 함수들이 v15 = v8(a2)에서 호출된다.

일부 커널 함수들은 v15 = v8(a2) 라인에서 실행하지 않고 if문으로 실행하는 루틴이 빠져있다. 왜 인지는 모르겠다.

일부 커널 함수들은 따로 if문으로 걸러내어 호출하게 된다.

What is the whNtxxxxxxx function in wow64.dll?

whNtxxxxxxxx 함수는 실제 Ntxxxxxxx 함수를 호출하기 전에 호출되는 함수이다.

NTSTATUS __fastcall whNtOpenProcess(unsigned int *a1)
{
  _DWORD *v1; // rdi
  ACCESS_MASK v2; // er14
  int *v3; // rsi
  void **v4; // rbx
  struct _CLIENT_ID *v5; // r9
  NTSTATUS result; // eax
  __int64 v7; // [rsp+0h] [rbp-68h] BYREF
  int v8; // [rsp+20h] [rbp-48h]
  __int64 v9; // [rsp+28h] [rbp-40h] BYREF
  POBJECT_ATTRIBUTES ObjectAttributes; // [rsp+30h] [rbp-38h] BYREF
  __int64 *v11; // [rsp+38h] [rbp-30h]
  struct _CLIENT_ID ClientId; // [rsp+40h] [rbp-28h] BYREF

  v11 = &v7;
  v1 = (_DWORD *)*a1;
  v2 = a1[1];
  v3 = (int *)a1[3];
  v9 = 0i64;
  v4 = (void **)((unsigned __int64)&v9 & -(__int64)((_DWORD)v1 != 0));
  v8 = Wow64ShallowThunkAllocObjectAttributes32TO64_FNC((_DWORD *)a1[2], (__int64 *)&ObjectAttributes);
  if ( v8 < 0 )
  {
    local_unwind_0(v11, &loc_18000BADF);
  }
  else if ( (_DWORD)v3 )
  {
    v5 = &ClientId;
    ClientId.UniqueThread = (HANDLE)v3[1];
    ClientId.UniqueProcess = (HANDLE)*v3;
    goto LABEL_4;
  }
  v5 = 0i64;
LABEL_4:
  result = NtOpenProcess(v4, v2, ObjectAttributes, v5);
  if ( (_DWORD)v1 )
    *v1 = *(_DWORD *)v4;
  return result;
}

나도 아직 정확히 모든 분석을 끝내지는 못하였지만 a1은 Ntxxxxxxx 함수의 인자가 담겨있는 스택의 주소인 것으로 추정된다.

x86 ntdll.dll에서 호출된 커널함수의 인자는 x86 아키텍쳐에 맞춰 정렬되어 있기 때문에 해당 구조(체)를 x64 아키텍쳐 맞춰서 변환하는 작업을 하는 것으로 보인다.

결론적으로 whNtxxxxxxx 함수는 x86 아키텍쳐에 맞춰진 인자들을 실제 커널 함수(Ntxxxxxxx)를 호출하기 전에 x64 아키텍쳐에 맞춰 세팅하고 커널 함수를 호출하는 것으로 확인된다.

WoW 프로세스의 커널 함수 호출 과정

1. Ntxxxxxxxxx (ntdll.dll x86)
2. Wow64SystemServiceCall -> Wow64Transition 참조 (wow64cpu.dll)
3. KiFastSystemCall (wow64cpu.dll)
4. CpupReturnFromSimulatedCode (wow64cpu.dll)
5. TurboDispatchJumpAddressStart (wow64cpu.dll)
6. TurboDispatchJumpAddressEnd(ServiceNoTurbo) (wow64cpu.dll)
7. Wow64SystemServiceEx (wow64.dll)
8. whNtxxxxxxxxx (wow64.dll)
9. Ntxxxxxxxxx (ntdll.dll x64)

[WoW] Windbg를 이용해 WoW 프로세스 디버깅하기

미친해커 — Mon, 13 Jun 2022 07:13:06 +0900

나는 지금까지 WoW(Windows on Windows) 프로세스를 완벽하게 디버깅하기 위해서는 CheatEngine을 사용해야 한다고 생각했다. 왜냐하면 CS 레지스터의 값이 바뀌면서 모드가 변경되면 일반적인 디버거들은 오류를 일으키거나 해당 부분을 건너뛰어서 디버깅을 했다. 그렇기 때문에 CheatEngine을 사용해야한다고 생각했는데 해당 CheatEngine도 불편해서 사실상 제대로된 디버깅은 해본적이 없다. 그런데 Windbg를 이용하면 정상적으로 디버깅이 가능하다는 글을 보게되었다. 당연한 사실이지만 생각보다 지원되는 기능들이 많아서 너무 편하다.

How to Debug for WoW Process use Windbg

딱히 특별한 방법이 있는건 아니다. 아래 페이지에서 설치관리자를 다운받고 실행하면 된다.

Windows SDK - Windows 앱 개발

Windows 11 Windows SDK에는 Windows 실행되는 앱을 만들 때 사용할 수 있는 헤더, 라이브러리 및 도구가 포함되어 있습니다.

developer.microsoft.com

설치관리자에 보면 Windbg를 설치하는 부분에 체크하고 Next를 진행하면 된다.

WoW 프로세스를 디버깅하기 위해서는 WinDbg (X64) 버전을 사용해야한다.

개인적으로 WinDbg Preview 버전이 깔끔하고 멋지기 때문에 선호하지만 제대로 WoW 프로세스에 대해서 디버깅이 되지 않는 것같다.

위 사진처럼 Windbg를 실행했으면 [File]에서 여러 디버깅 방법들을 확인할 수 있다. 필자는 [Attach to a Process] 보다는 [Open Executable] 기능을 더 많이 사용한다.

Windbg's WoW commands

!load wow64exts	디버거 확장 로드
!wow64exts.sw	x86과 x64간 모드를 전환한다.
!wow64exts.k count	32/64 비트 스택 추적을 덤프한다. count 를 지정하면 지정된 개수의 주소를 덤프한다.
!wow64exts.info	프로세스의 PEB, 현재 스레드의 TEB 및 WOW64에서 사용하는 스레드 TLS 슬롯에 대한 기본 정보를 덤프한다.
!wow64exts.r address	지정된 주소에 대한 컨텍스트를 덤프한다. address를 지정하지 않으면 프로세서에 대한 컨텍스트를 덤프한다.

마무리

간단하게 Windbg를 이용해 WoW 프로세스를 디버깅하는 방법을 살펴보았다. 그리고 !wow64exts.sw 명령을 사용하지 않더라도 디버거가 자동으로 모드를 전환해준다.

[WoW] Far와 Near 어셈블리 명령의 차이점

미친해커 — Wed, 1 Jun 2022 01:30:51 +0900

[WoW] 32Bit 모드에서 64Bit 모드로 전환하기

[WoW] 32Bit 응용 프로그램에서의 Kernel 함수 호출 Windows 64Bit에서 32Bit 응용 프로그램을 실행하고 디버거로 커널 함수의 어셈블리를 확인하면 대부분 다음과 같은 형식을 띄게 된다. mov eax, 0x00000026 #

crazyhacker.tistory.com

이전 포스팅에서 jmp far 라고하는 처음보는 형태의 어셈블리를 확인했었다. 그리고 해당 far 어셈블리는 CS 레지스터의 값을 변경하는 어셈블리였으며 32Bit 모드에서 64Bit 모드로 변경하기 위해서는 CS 레지스터의 값을 변경해야 한다는 것도 알았다. 이번 포스팅에서는 Far 어셈블리와 Near 어셈블리의 차이점을 알아보려고 한다.

jmp instruction

Opcode 0xE9 (Relative jump instruction, Near jump)

Opcode 0xE9를 사용한 상대거리를 이용한 점프 어셈블리 명령이다.

상대 거리를 사용하는 opcode 0xE9 어셈블리 명령어

opcode인 0xE9가 존재하고 상대거리인 0x00000010이 operand로 들어가 있다. 해당 어셈블리 명령의 동작과정은 EIP(IP)에 operand를 더하는 방식으로 계산된다. (혹시라도 0x77F20FE5 주소로 점프하는지 이해가 안된다면 아래 접은 글을 확인하자)

EIP는 다음에 실행할 명령의 주소를 갖고 있기 때문에 0x77F20FD0 주소의 명령어를 실행하는 동안의 EIP의 값은 0x77F20FD5가 되기 때문에 해당 주소에 0x00000010을 더한 0x77F20FE5로 점프하게 되는 원리이다.

Opcode 0xEA (Static jump and change CS register instruction, Far jump)

Opcode 0xEA를 사용한 점프할 주소의 Code Segment를 지정하고 해당 주소로 점프하는 어셈블리 명령이다.

왼쪽은 어셈블리 명령, 오른쪽은 32Bit 에서의 Segment Register의 값

opcode 0xEA(jmp far) 어셈블리 명령은 다른 jmp 어셈블리 명령들과는 큰 차이가 존재한다.

2개의 Operand를 가진다
점프(이동)할 주소를 절댓값(static)으로 받는다.
점프(이동)할 주소가 존재하는 Code Segment를 받는다.

즉 위 어셈블리에서 이동할 주소인 0x77F20FE5가 상대적으로 계산되어 있지 않다. 그리고 두번째 Operand로 해당 주소가 존재하는 Code Segment를 받았다. 해당 주소는 CS 0x0023에 존재하는 주소이기 때문에 0x0023으로 설정했다. 위 어셈블리를 실행하게 되면 CS Register의 값이 0x0023으로 변경되고 0x77F20FE5로 EIP가 이동하게 된다.

ret instruction

Opcode 0xC3 (Near Return)

Opcode 0xC3를 사용한 리턴 어셈블리 명령이다.

ret 어셈블리는 모두가 알다시피 return 하는 어셈블리이다. 기본적으로 현재 스택의 최상단에서 4 Byte를 꺼내 해당 주소로 점프하는 어셈블리이다. ret 어셈블리를 풀어 써보자면 다음과 같다.

pop eip
jmp eip

Opcode 0xCB (Change CS register instruction, Far Return)

Opcode 0xCB를 사용하는 리턴 어셈블리이다. 해당 어셈블리는 CS 레지스터를 변경한다.

해당 어셈블리는 똑같이 ret 어셈블리의 기능도 갖고 있으면서 동시에 CS 레지스터의 값을 변경할 수 있다. 그런데 이 CS 레지스터의 값을 변경하는 방식이 기존의 jmp 어셈블리와는 큰 차이가 있다. ret far 어셈블리의 동작 방식은 다음과 같다.

스택에서 4Byte를 꺼내 CS 레지스터의 넣는다. (pop cs)
스택에서 4Byte를 꺼내 ret 한다. (ret 또는 pop eip; jmp eip)

즉 총 8Byte를 꺼내게 되는데 처음 4Byte는 CS 레지스터에 들어가고 그 다음 4Byte의 주소로 리턴하게 되는 원리이다.

[WoW] 32Bit 모드에서 64Bit 모드로 전환하기

미친해커 — Tue, 31 May 2022 23:23:33 +0900

[WoW] 32Bit 응용 프로그램에서의 Kernel 함수 호출

Windows 64Bit에서 32Bit 응용 프로그램을 실행하고 디버거로 커널 함수의 어셈블리를 확인하면 대부분 다음과 같은 형식을 띄게 된다. mov eax, 0x00000026 # Windows System Call Number mov edx, Wow64SystemSe..

crazyhacker.tistory.com

이전 포스팅

이전 포스팅에서 jmp 0033:wow64cpu.dll+7009 라고 적힌 처음보는 jmp instrcution을 볼수 있었다.

해당 어셈블리를 Cheat Engine이 아닌 일반적인 디버거(OllyDbg, x64dbg)에서는 다르게 표시된다.

jmp far라는 instrcution으로 해석되는 것을 확인할 수 있는데 열심히 서치해본 결과 far 류의 어셈블리들은 절대주소 그리고 CS(Code Segment) 레지스터의 값을 변경한다는 사실을 알게 되었다.

해당 어셈블리는 CS 레지스터의 값을 변경하고 0x77DF7009의 주소로 점프한다. 그리고 해당 주소의 어셈블리를 확인해보면 jmp qword ptr [r15+0xF8] 으로 64Bit에서 사용되는 레지스터를 사용하는 것을 확인할 수 있다.

마무리

어셈블리를 분석해봤을 때 CS 레지스터의 값을 0x0033으로 변경하고 64Bit 어셈블리를 실행하는 것으로 보아 CS 레지스터의 값이 0x0033 이라면 64Bit 모드 0x0023 이라면 32Bit 모드 인것으로 생각된다.

[WoW] 32Bit 응용 프로그램에서의 Kernel 함수 호출

미친해커 — Wed, 4 May 2022 00:35:44 +0900

Windows 64Bit에서 32Bit 응용 프로그램을 실행하고 디버거로 커널 함수의 어셈블리를 확인하면 대부분 다음과 같은 형식을 띄게 된다.

mov    eax, 0x00000026              # Windows System Call Number
mov    edx, Wow64SystemServiceCall  # 64비트 모드 전환 함수
call   edx                          # 모드 전환 함수 호출
ret                                 # 리턴

우리가 알고 있는 커널 함수의 호출은 syscall 어셈블리를 사용해 커널에 호출하게 된다. 하지만 Windows on Windows로 돌아가고 있는 32Bit 응용 프로그램은 syscall이 아닌 Wow64SystemServiceCall 이라는 함수를 호출하고 있다. 해당 함수는 Windows 64Bit 운영체제의 32Bit용 ntdll.dll에 존재하는 함수로써 32Bit 응용 프로그램이 커널 함수를 호출하면 해당 호출을 가로채게 된다.

그 이유는 응용 프로그램은 32비트이지만 커널은 64비트로 동작하기 때문에 32Bit 응용 프로그램이 직접적으로 커널에 요청하지 못하도록 한다. 대신 Wow64SystemServiceCall 함수를 통하여 64비트 모드로 변경 후에 syscall 수행하고 다시 32비트 모드로 변경해 해당 반환값을 전달해준다.

jmp dword ptr ds:[Wow64Transition] # Wow64Transition = wow64cpu.dll + 0x6000

Wow64SystemServiceCall은 x86 ntdll.dll의 Wow64Transition이라는 전역변수의 값을 참조하여 wow64cpu.dll의 어느 공간으로 점프한다. 해당 주소는 wow64cpu.dll + 0x6000 주소로 점프한다. 치트엔진으로 해당 주소를 가보면 다음과 같은 어셈블리어를 볼수 있다.

해당 어셈블리를 확인해보면 처음보는 jmp insturction과 x64 시스템의 레지스터와 어셈블리어를 사용하는 것을 확인할 수 있었다.

이로써 32Bit 응용 프로그램은 64Bit로 모드를 전환하여 무언가를 수행한다는 것을 확인할 수 있었다.

[WoW] WoW64(Windows on Windows 64-Bit)란?

미친해커 — Tue, 3 May 2022 14:34:30 +0900

WoW64란?

WoW64는 Windows 64Bit 운영체제에서 Windows 32Bit 응용 프로그램을 실행할 수 있는 Windows 운영 체제의 하위 시스템이다. 과거 Windows 32Bit 운영체제에서는 Windows 16Bit 와의 호환성을 위해 Windows on Windows 라는 이름으로 등장시켰다. 하지만 현재 Windows 64Bit 운영체제에서는 Windows 16Bit 응용 프로그램은 동작하지 않는다. 해당 이유는 Windows 64Bit의 시스템 핸들의 크기 때문이라고 한다.

구현 세부 정보

wow64.dll - 포인터 및 호출 스택 조작과 32비트와 64비트 호출 간 변환하는 Windows NT 커널에 대한 핵신 인터페이스
wow64cpu.dll - 32비트 애플리케이션(win32k thunk)에 적절한 진입점을 제공
wow64win.dll - 프로세서를 32비트에서 64비트 모드로 전환하는 작업을 처리한다.

마무리

다른거 잘 모르겠고 오래전부터 64비트 운영체제에서 32비트 응용 프로그램이 동작하는 것을 신기하게 생각했고 또 어셈블리 공부를 위해 주로 32비트를 위주로 공부하다보니 64비트 커널 함수와 32비트 커널 함수의 차이점을 발견하게 되었다. 여기서 더 나아가 치트엔진으로 리버싱을 진행하다 32비트 응용 프로그램에서 64비트 레지스터와 어셈블리를 보게 되었고 이를 통해 32비트에서 64비트로 모드를 변경하는 방법이 있다는 것을 깨달았다. 그리고 그것을 Heaven's Gate라고 부르는 것을 알게되었다. 해당 카테고리에는 이 Heaven's Gate (WoW64) 에 대해 서술에 보려고 한다.

[Reversing] Trampoline(Inline) Hooking x64 Step 2

미친해커 — Tue, 3 May 2022 13:02:59 +0900

How to patch the top 12 bytes of the API

이제 후킹하고 싶은 API의 상위 12 바이트를 패치하는 것만 남았다. 기본적으로 DLL의 함수들은 .text 섹션에 존재한다. 해당 섹션의 메모리 보호 옵션은 보통 ER--- 로 쓰기 권한이 빠져있다. 그렇기 때문에 먼저 쓰기 권한을 부여해야만 한다. Windows API 중 특정 영역의 메모리 보호 옵션을 수정하는 함수는 VirtualProtect 함수가 있다.

VirtualProtectEx function (memoryapi.h) - Win32 apps

Changes the protection on a region of committed pages in the virtual address space of a specified process.

docs.microsoft.com

#include <stdio.h>
#include <windows.h>

int main(int argc, char *argv[])
{
    // GetModuleHandleA 함수로 hModule을 구한다.
    HMODULE hModule = GetModuleHandleA("user32.dll");
    
    // 만약 GetModuleHandleA 함수로 구하지 못하였다면 LoadLibraryA 함수로 DLL을 로드한다.
    if (hModule == NULL)
        hModule = LoadLibraryA("user32.dll");
    
    // GetProcAddress 함수를 이용해 주소를 가져옴
    PVOID pMessageBoxA = (PVOID)GetProcAddress(hModule, "MessageBoxA");
    
    // 원본 메모리 보호 옵션을 저장할 변수
    DWORD OldProtect;
    
    /*
    VirtualProtect 함수를 사용해 MessageBoxA 주소로부터 12바이트 만큼의 메모리 보호 옵션을
    PAGE_EXECUTE_READWRITE(ERW--)로 변경한다.
    */
    if (VirtualProtect(pMessageBoxA, 12, PAGE_EXECUTE_READWRITE, &OldProtect) == FALSE)
    {
        printf("VirtualProtect Failed\n");
        return -1;
    }
    
    printf("Changed the top 12 bytes memory protection option in MessageBoxA to ERW--\n");
}

Changed the top 12 bytes memory protection option in MessageBoxA to ERW--

위 문자열이 출력되면 정상적으로 MessageBoxA 함수의 상위 12 바이트의 메모리 보호 옵션이 수정된 것이다. 수정된 이후에는 해당 영역의 데이터를 수정할 수 있게 된다. 이제 본격적으로 후킹을 시도해보자.

Let's try Trampoline Hooking!!

후킹 함수가 호출되었을 때 원본 함수를 호출하기 위해서는 꼭 다시 원본 코드로 복원 후 호출해야 하고 호출이 끝난 후에는 다시 후킹 코드로 패치해줘야 후킹이 유지될 수 있다.

#include <stdio.h>
#include <windows.h>

BYTE HookCode[12] = { 0x48, 0xB8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0 };
BYTE OriginCode[12] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

int __stdcall NewMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType)
{
    // 상위 5 바이트를 원본 코드로 패치
    memcpy(MessageBoxA, OriginCode, 12);
    // lpText 변수를 조작해 함수를 정상적으로 실행
    int ret = MessageBoxA(hWnd, "Hooked..!", lpCaption, uType);
    // 다시 후킹 코드로 패치
    memcpy(MessageBoxA, HookCode, 12);

    // 반환값 전달
    return ret;
}

int main(int argc, char *argv[])
{
    // GetModuleHandleA 함수로 hModule을 구한다.
    HMODULE hModule = GetModuleHandleA("user32.dll");
    
    // 만약 GetModuleHandleA 함수로 구하지 못하였다면 LoadLibraryA 함수로 DLL을 로드한다.
    if (hModule == NULL)
        hModule = LoadLibraryA("user32.dll");

    if (hModule == NULL)
    {
        printf("[-] user32.dll not found\n");
        return -1;
    }

    printf("[+] user32.dll found!\n");

    // GetProcAddress 함수를 이용해 주소를 가져옴
    PVOID pMessageBoxA = (PVOID)GetProcAddress(hModule, "MessageBoxA");
    
    if (pMessageBoxA == NULL)
    {
        printf("[-] MessageBoxA not found\n");
        return -1;
    }

    printf("[+] MessageBoxA found!\n");

    // 원본 메모리 보호 옵션을 저장할 변수
    DWORD OldProtect;
    
    /*
    VirtualProtect 함수를 사용해 MessageBoxA 주소로부터 5바이트 만큼의 메모리 보호 옵션을
    PAGE_EXECUTE_READWRITE(ERW--)로 변경한다.
    */
    if (VirtualProtect(pMessageBoxA, 12, PAGE_EXECUTE_READWRITE, &OldProtect) == FALSE)
    {
        printf("VirtualProtect Failed\n");
        return -1;
    }
    
    printf("[*] Changed the top 12 bytes memory protection option in MessageBoxA to ERW--\n");

    // 점프할 주소를 저장
    *(ULONGLONG *)(HookCode + 2) = (ULONGLONG)NewMessageBoxA;

    printf("[*] Patch code :    ");
    
    for (int i = 0; i < 12; i++)
    	printf("0x%02X ", HookCode[i]);
    
    putchar('\n');
    
    // 원본 12이트 백업
    memcpy(OriginCode, pMessageBoxA, 12);
    printf("[*] Original code : ");
    
    for (int i = 0; i < 12; i++)
    	printf("0x%02X ", OriginCode[i]);

	putchar('\n');

    // 후킹 코드로 패치
    memcpy(pMessageBoxA, HookCode, 12);

    printf("[+] Trampoline Hooking Success!\n");
    printf("Press the any key...");
    getchar();

    // 후킹된 MessageBoxA 함수 호출
    MessageBoxA(NULL, "Not Hooked...!", "Trampoline Hook", 0);

    return 0;
}

Trampoline Hook x64.exe

0.05MB

[+] user32.dll found!
[+] MessageBoxA found!
[*] Changed the top 12 bytes memory protection option in MessageBoxA to ERW--
[*] Patch code :    0x48 0xB8 0x50 0x15 0x40 0x00 0x00 0x00 0x00 0x00 0xFF 0xE0 
[*] Original code : 0x48 0x83 0xEC 0x38 0x45 0x33 0xDB 0x44 0x39 0x1D 0x02 0x61 
[+] Trampoline Hooking Success!
Press the any key...

정상적으로 실행되었다면 Press the any key가 출력되었을 때 아무 키를 입력하게 되면 코드와 다르게 Not Hooked...! 가 아닌 Hooked...! 라는 메시지를 출력한다.

[Reversing] Trampoline(Inline) Hooking x64 Step 1

미친해커 — Tue, 3 May 2022 12:49:56 +0900

[Reversing] Trampoline(Inline) Hooking x86 Step 1

[Reversing] Trampoline(Inline) Hooking x86 Step 0 Trampoline Hooking Trampoline Hooking 이란 타겟 API의 상위 n바이트를 jmp 어셈블리로 패치하여 후킹하는 기법을 말한다. Trampoline Hooking은 x86과 x64..

crazyhacker.tistory.com

사실 Trampoline Hooking x64 Step 1은 존재하지 않는다. 기존의 Trampoline Hooking x86 Step 1의 내용과 같기 때문에 위 포스팅을 보고 진행하되 64비트 컴파일러를 사용하길 바란다.

그럼 Trampoline Hooking x64 Step 2에서 봐요~~~ ㅎㅅㅎ

~~포스팅 하나 덜었네...~~

[Reversing] Trampoline(Inline) Hooking x64 Step 0

미친해커 — Tue, 3 May 2022 12:47:59 +0900

해당 글을 읽기 전에 리버싱 또는 후킹에 대한 기본적이 지식이 없으신 분들이라면 아래 글을 모두 숙지 후에 와주세요.

[Reversing] Trampoline(Inline) Hooking x86 Step 0

Trampoline Hooking Trampoline Hooking 이란 타겟 API의 상위 n바이트를 jmp 어셈블리로 패치하여 후킹하는 기법을 말한다. Trampoline Hooking은 x86과 x64에서의 기술 구현 방법이 미세하게 다르다. 그렇기 때..

crazyhacker.tistory.com

Trampoline Hooking

Trampoline Hooking 이란 타겟 API의 상위 n바이트를 jmp 어셈블리로 패치하여 후킹하는 기법을 말한다.

Trampoline Hooking은 x86과 x64에서의 기술 구현 방법이 미세하게 다르다. 그렇기 때문에 위 설명에서 n바이트라고 하였다.

How to Trampoline Hooking from x64 system

x64 시스템에서의 후킹 방법은 다음과 같다.

타겟 API의 상위 12바이트를 mov and jmp 어셈블리로 패치하여 후킹한다. 여기서 12바이트인 이유는 x64 시스템은 주소체계가 8바이트이기 때문에 기존의 x86의 후킹 방식으로는 4바이트 이상의 범위에 있는 주소로는 점프하지 못한다는 단점이 존재한다.

예를 들어 8바이트 주소 체계에서 계산한 상대 주소가 4바이트를 초과한다면 기존의 5바이트를 이용한 jmp 어셈블리로는 타겟 주소까지 이동할 수 없는 일이 생기게 된다. 그렇기 때문에 x64 시스템에서 안정적으로 후킹을 하기 위해서는 8바이트 주소로 점프할 수 있는 레지스터를 사용한 간접 점프(Indirect jump)를 이용한다면 된다.

How to Trampoline Hooking using Indirect Jump from x64 system

위에서 말했던 것처럼 12바이트를 이용한 mov and jmp 어셈블리 패치를 이용하면 된다. x64 시스템으로 넘어옴에 따라 레지스터도 기존 4바이트에서 8바이트로 드러났음을 알 수 있다. 이를 이용해 레지스터를 이용한 간접 점프를 활용해 x64 시스템에서 안정적인 후킹을 진행할 수 있다. x64 시스템에서의 후킹 방법은 다음과 같다.

x86 시스템과 다르게 바로 해당 주소로 점프하지 않고 레지스터에 주소를 넣은 후에 점프를 시도한다. (rax 레지스터를 사용하는 이유는 시스템에서 rax 레지스터의 값은 언제든 변경될 수 있기 때문에 중요한 값을 저장하지 않고 해당 값을 보존해 주지 않아도 되기 때문이다.) 또한 점프할 주소까지의 상대거리를 구하지 않아도 된다는 장점이 존재한다. 다만 후킹하는 코드가 2배 이상 늘어났다...

마무리

이번 포스팅에서 x64 시스템의 후킹 방법에 대해서 간단하게 알아봤으며 x86 시스템의 후킹 방법을 채용할 수 없는 이유 또한 설명했다.

[Reversing] Trampoline(Inline) Hooking x86 Step 2

미친해커 — Fri, 29 Apr 2022 22:46:57 +0900

How to patch the top 5 bytes of the API

이제 후킹하고 싶은 API의 상위 5 바이트를 패치하는 것만 남았다. 기본적으로 DLL의 함수들은 .text 섹션에 존재한다. 해당 섹션의 메모리 보호 옵션은 보통 ER--- 로 쓰기 권한이 빠져있다. 그렇기 때문에 먼저 쓰기 권한을 부여해야만 한다. Windows API 중 특정 영역의 메모리 보호 옵션을 수정하는 함수는 VirtualProtect 함수가 있다.

VirtualProtectEx function (memoryapi.h) - Win32 apps

Changes the protection on a region of committed pages in the virtual address space of a specified process.

docs.microsoft.com

#include <stdio.h>
#include <windows.h>

int main(int argc, char *argv[])
{
    // GetModuleHandleA 함수로 hModule을 구한다.
    HMODULE hModule = GetModuleHandleA("user32.dll");
    
    // 만약 GetModuleHandleA 함수로 구하지 못하였다면 LoadLibraryA 함수로 DLL을 로드한다.
    if (hModule == NULL)
        hModule = LoadLibraryA("user32.dll");
    
    // GetProcAddress 함수를 이용해 주소를 가져옴
    PVOID pMessageBoxA = (PVOID)GetProcAddress(hModule, "MessageBoxA");
    
    // 원본 메모리 보호 옵션을 저장할 변수
    DWORD OldProtect;
    
    /*
    VirtualProtect 함수를 사용해 MessageBoxA 주소로부터 5바이트 만큼의 메모리 보호 옵션을
    PAGE_EXECUTE_READWRITE(ERW--)로 변경한다.
    */
    if (VirtualProtect(pMessageBoxA, 5, PAGE_EXECUTE_READWRITE, &OldProtect) == FALSE)
    {
        printf("VirtualProtect Failed\n");
        return -1;
    }
    
    printf("Changed the top 5 bytes memory protection option in MessageBoxA to ERW--\n");
}

Changed the top 5 bytes memory protection option in MessageBoxA to ERW--

위 문자열이 출력되면 정상적으로 MessageBoxA 함수의 상위 5바이트의 메모리 보호 옵션이 수정된 것이다. 수정된 이후에는 해당 영역의 데이터를 수정할 수 있게 된다. 이제 본격적으로 후킹을 시도해보자.

Let's try Trampoline Hooking!!

#include <stdio.h>
#include <windows.h>

BYTE HookCode[5] = { 0xE9, 0x00, 0x00, 0x00, 0x00 };
BYTE OriginCode[5] = { 0x00, 0x00, 0x00, 0x00, 0x00 };

int __stdcall NewMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType)
{
    // 상위 5 바이트를 원본 코드로 패치
    memcpy(MessageBoxA, OriginCode, 5);
    // lpText 변수를 조작해 함수를 정상적으로 실행
    int ret = MessageBoxA(hWnd, "Hooked..!", lpCaption, uType);
    // 다시 후킹 코드로 패치
    memcpy(MessageBoxA, HookCode, 5);

    // 반환값 전달
    return ret;
}

int main(int argc, char *argv[])
{
    // GetModuleHandleA 함수로 hModule을 구한다.
    HMODULE hModule = GetModuleHandleA("user32.dll");
    
    // 만약 GetModuleHandleA 함수로 구하지 못하였다면 LoadLibraryA 함수로 DLL을 로드한다.
    if (hModule == NULL)
        hModule = LoadLibraryA("user32.dll");

    if (hModule == NULL)
    {
        printf("[-] user32.dll not found\n");
        return -1;
    }

    printf("[+] user32.dll found!\n");

    // GetProcAddress 함수를 이용해 주소를 가져옴
    PVOID pMessageBoxA = (PVOID)GetProcAddress(hModule, "MessageBoxA");
    
    if (pMessageBoxA == NULL)
    {
        printf("[-] MessageBoxA not found\n");
        return -1;
    }

    printf("[+] MessageBoxA found!\n");

    // 원본 메모리 보호 옵션을 저장할 변수
    DWORD OldProtect;
    
    /*
    VirtualProtect 함수를 사용해 MessageBoxA 주소로부터 5바이트 만큼의 메모리 보호 옵션을
    PAGE_EXECUTE_READWRITE(ERW--)로 변경한다.
    */
    if (VirtualProtect(pMessageBoxA, 5, PAGE_EXECUTE_READWRITE, &OldProtect) == FALSE)
    {
        printf("VirtualProtect Failed\n");
        return -1;
    }
    
    printf("[*] Changed the top 5 bytes memory protection option in MessageBoxA to ERW--\n");

    printf("[+] Calculate relative jump length\n");
    // 점프할 상대거리 계산후 변수에 저장
    *(DWORD *)(HookCode + 1) = (ULONG_PTR)NewMessageBoxA - (ULONG_PTR)pMessageBoxA - 5;

    printf("[*] Patch code :    0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n", 
        HookCode[0],
        HookCode[1],
        HookCode[2],
        HookCode[3],
        HookCode[4]
    );
    
    // 원본 5 바이트 백업
    memcpy(OriginCode, pMessageBoxA, 5);
    printf("[*] Original code : 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",
        OriginCode[0],
        OriginCode[1],
        OriginCode[2],
        OriginCode[3],
        OriginCode[4]
    );

    // 후킹 코드로 패치
    memcpy(pMessageBoxA, HookCode, 5);

    printf("[+] Trampoline Hooking Success!\n");
    printf("Press the any key...");
    getchar();

    // 후킹된 MessageBoxA 함수 호출
    MessageBoxA(NULL, "Not Hooked...!", "Trampoline Hook", 0);

    return 0;
}

Trampoline Hook x86.exe

0.05MB

[+] user32.dll found!
[+] MessageBoxA found!
[*] Changed the top 5 bytes memory protection option in MessageBoxA to ERW--
[+] Calculate relative jump length
[*] Patch code :     0xE9 0x1B 0x09 0xAD 0x8A
[*] Original code :  0x8B 0xFF 0x55 0x8B 0xEC
[+] Trampoline Hooking Success!
Press the any key...

[Reversing] Trampoline(Inline) Hooking x86 Step 1

미친해커 — Wed, 27 Apr 2022 14:49:49 +0900

[Reversing] Trampoline(Inline) Hooking x86 Step 0

crazyhacker.tistory.com

저번 포스팅에서 간단히 Trampoline Hooking의 원리에 대해 공부했다. 이번 포스팅부터는 본격적으로 후킹을 하기 위해 사용할 함수들을 알아볼 생각이다.

How to get MessageBoxA address

#include <stdio.h>
#include <windows.h>

int main(int argc, char *argv[])
{
    PVOID pMessageBoxA = (PVOID)GetProcAddress(GetModuleHandleA("user32.dll"), "MessageBoxA");
    
    // IAT에서 주소를 가져옴
    printf("MessageBoxA : 0x%p\n", MessageBoxA);
    
    // GetProcAddress 함수를 이용해 주소를 가져옴
    printf("GetProcAddress MessageBoxA : 0x%p\n", pMessageBoxA);
    
    return 0;
}

main.exe

0.05MB

위 소스코드를 컴파일 해 실행해보면 다음과 같은 결과를 확인할 수 있다.

MessageBoxA : 0x74E00CA0
GetProcAddress MessageBoxA : 0x74E00CA0

이제 위 소스코드를 다음과 같이 변경하고 다시 실행해보자

#include <stdio.h>
#include <windows.h>

int main(int argc, char *argv[])
{
    PVOID pMessageBoxA = (PVOID)GetProcAddress(GetModuleHandleA("user32.dll"), "MessageBoxA");
    
    // GetProcAddress 함수를 이용해 주소를 가져옴
    printf("GetProcAddress MessageBoxA : 0x%p\n", pMessageBoxA);
    
    return 0;
}

main2.exe

0.05MB

이번에는 다음과 같은 결과를 확인할 수 있다.

GetProcAddress MessageBoxA : 0x00000000

왜 이런 경우가 발생할까? GetProcAddress는 HMODULE을 사용해 함수의 주소를 가져오는 함수이다. 하지만 이번에는 함수의 주소를 정상적으로 가져오지 못했다. 위와 같은 결과가 나오는 원인은 GetModuleHandleA 함수에 있다. 먼저 GetProcAddress의 문서를 읽어보면 이렇게 설명되어있다.

GetProcAddress function (libloaderapi.h) - Win32 apps

Retrieves the address of an exported function or variable from the specified dynamic-link library (DLL).

docs.microsoft.com

hModule은 함수 또는 변수를 포함하는 DLL 모듈에 대한 핸들이라고 설명되어 있고 LoadLibrary, GetModuleHandle 등의 함수들이 이 핸들은 반환한다고 한다. 우리는 여기서 GetModuleHandle 류의 함수를 사용했다. 이제 해당 함수의 문서를 읽어보자

GetModuleHandleA function (libloaderapi.h) - Win32 apps

Retrieves a module handle for the specified module. The module must have been loaded by the calling process.

docs.microsoft.com

lpModuleName으로 로드된 모듈의 이름을 입력받는다.라고 되어있다. 여기서 공부를 좀 한 사람이라면 눈치를 챘을 것이라고 생각한다. 바로 첫 번째 코드는 MessageBoxA를 정적으로 사용했기 때문에 IAT에 user32.dll이 등록되어 있어 프로세스가 실행됐을 때 user32.dll이 로드되었을 것이다. 그렇기에 GetModuleHandleA 함수를 사용했을 때 정상적으로 호출되었지만, 두 번째 코드에서는 MessageBoxA 함수를 사용하지 않았다. 그렇기 때문에 IAT에 user32.dll이 등록되어 있지 않아 프로세스가 실행됐을 때 user32.dll이 로드되지 않았던 것이다. 그래서 GetModuleHandleA 함수가 NULL 반환한 것이며 그로인해 GetProcAddress 역시 NULL을 반환한 것이다.

How to fixed source code?

GetModuleHandleA와 거의 동일한 LoadLibraryA 함수가 존재한다. 해당 함수는 인자로 들어온 DLL이 로드되어 있다면 HMODULE을 반환하고 로드되어 있지 않다면 해당 DLL을 로드하고 HMODULE을 반환한다. 이 함수를 사용하면 해당 문제를 해결할 수 있다.

#include <stdio.h>
#include <windows.h>

int main(int argc, char *argv[])
{
    // GetModuleHandleA 함수로 hModule을 구한다.
    HMODULE hModule = GetModuleHandleA("user32.dll");
    
    // 만약 GetModuleHandleA 함수로 구하지 못하였다면 LoadLibraryA 함수로 DLL을 로드한다.
    if (hModule == NULL)
    	hModule = LoadLibraryA("user32.dll");
    
    // GetProcAddress 함수를 이용해 주소를 가져옴
    PVOID pMessageBoxA = (PVOID)GetProcAddress(hModule, "MessageBoxA");
    
    printf("GetProcAddress MessageBoxA : 0x%p\n", pMessageBoxA);
    
    return 0;
}

main3.exe

0.05MB

이번엔 정상적으로 실행된 것을 확인할 수 있다.

GetProcAddress MessageBoxA : 0x74E00CA0

마무리

이번 포스팅에서는 Trampoline Hooking을 하기위해 해당 함수의 원본(IAT가 아닌) 주소를 구하는 방법을 알아보았다. 다음 포스팅에서는 드디어 Trampoline Hooking의 예제가 나온다.

[Reversing] Trampoline(Inline) Hooking x86 Step 0

미친해커 — Wed, 27 Apr 2022 01:00:45 +0900

Trampoline Hooking

Trampoline Hooking 이란 타겟 API의 상위 n바이트를 jmp 어셈블리로 패치하여 후킹하는 기법을 말한다.

Trampoline Hooking은 x86과 x64에서의 기술 구현 방법이 미세하게 다르다. 그렇기 때문에 위 설명에서 n바이트라고 하였다.

How to Trampoline Hooking from x86 system

x86 시스템에서의 후킹 방법은 다음과 같다.

타겟 API의 상위 5바이트를 jmp 어셈블리로 패치하여 후킹한다. 여기서 5바이트인 이유는 x86 시스템은 주소체계가 4바이트이기 때문에 1바이트는 opcode 나머지 4바이트는 점프할 주소이다. (4바이트 jmp 어셈블리의 opcode는 0xE9 이다)

그렇다면 만약 우리가 점프하고 싶은 주소가 0x11223344 라면 다음과 같이 패치를 한다고 생각할 수 있다.

하지만 위와 같이 코드 패치를 진행한다면 프로그램은 정상적으로 동작하지 않는다. 왜냐하면 opcode 0xE9는 jmp 할 주소를 상대 주소로 계산하기 때문이다. 즉 현재 주소로부터 점프할 주소까지의 상대적인 거리를 구해서 operand를 설정해줘야 한다.

How to calculate relative address for use opcode 0xE9

opcode 0xE9의 operand로 사용되는 상대 주소를 구하는 방법은 다음과 같다.

operand = TargetAddress - CurrentAddress - 5

혹시라도 왜 5를 빼는지가 궁금하다면 이유는 opcode 0xE9의 총길이가 5바이트이기 때문에 그래서 해당 길이만큼 빼주는 것이다.

마무리

이번 포스팅에서는 Trampoline Hooking의 대해서 간단하게 알아봤다. 필자는 IAT Hooking보다 Trampoline Hooking이 훨씬 구현하기 쉬우며 또 알아야 하는 배경지식도 더 적다고 생각한다. ~~그렇기 때문에 필자는 IAT Hooking은 한 번도 해본 적이 없으며 블로그를 쓰기 위해서 처음 공부하고 구현해봤다 ㅋㅋㅋㅋㅋ~~

[Reversing] Code Injection + Trampoline(Inline) Hooking x86

미친해커 — Mon, 25 Apr 2022 13:46:32 +0900

트램펄린(인라인) 후킹이란?

트램펄린 후킹이란 이름처럼 점프(뛴다)라는 이름에 걸맞은 후킹 방법이다.

후킹 할 API 함수의 상위 5 Byte를 jmp 0x00000000 형태로 패치하여 해당 함수가 호출되었을 때 EIP(PC) 레지스터가 다른 함수의 주소로 변경되어 해당 함수로 점프하여 제어권을 가로채는 기술이다.

필자가 트램펄린 후킹을 공부했을 때(2019년도)에는 트램펄린 후킹 기술에 대해 검색을 하여도 x86 기반의 설명밖에 찾지 못하였다. 또 x86과 x64 간의 트램폴린 후킹 기술의 구현 방법이 미세하게 다르다. 하지만 x64 시스템에서의 트램펄린 후킹 기술은 많이 알려지지 않은 것으로 보이며 찾을 수도 없었다. 그렇기에 필자는 독자적으로 방법을 구현하여(아닐 수도 있다) 사용하고 있었다. 그렇기 때문에 트램펄린 후킹에 대한 포스팅은 x86과 x64 2개로 나누기로 했다.

위에서 설명한 방법은 x86과 x64 시스템에서 모두 사용가능한 방법이며 x64 시스템에서는 약간의 제약이 걸린다.

코드 인젝션과 트램펄린 후킹의 조합

코드 인젝션은 Fileless 형식의 임의의 코드 주입 공격이다. 그리고 트램펄린 후킹은 프로세스의 타겟 함수의 상위 5 바이트를 조작하여 특정 API의 제어권을 가로채는 기법이다.

이 두개의 기법을 적절히 활용하면 Fileless 형식의 트램펄린 후킹을 할수 있다.

예제 코드

GitHub - jungjin0003/Code-Injection: Code Injection + Hooking sample

Code Injection + Hooking sample. Contribute to jungjin0003/Code-Injection development by creating an account on GitHub.

github.com

Code Injector

소스코드는 아래 더보기에 있다.

#include <stdio.h>
#include <windows.h>
#include <winternl.h>
#include "../Library/Rlibloaderapi.h"

WINBOOL CodePatch(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize)
{
    SIZE_T lpNumberOfBytesWritten = 0;
    return WriteProcessMemory(hProcess, lpBaseAddress, lpBuffer, nSize, &lpNumberOfBytesWritten) && nSize == lpNumberOfBytesWritten;
}

PVOID CodeInjection(HANDLE hProcess, PVOID lpBuffer, SIZE_T nSize)
{
    // Allocate memory in target process
    PVOID BufferAddress = VirtualAllocEx(hProcess, NULL, nSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);

    if (BufferAddress == NULL)
    {
        return NULL;
    }

    SIZE_T NumberOfBytesWritten;

    // Write the lpBuffer in allocated memory
    if (WriteProcessMemory(hProcess, BufferAddress, lpBuffer, nSize, &NumberOfBytesWritten) == FALSE || nSize > NumberOfBytesWritten)
    {
        VirtualFreeEx(hProcess, BufferAddress, 0, MEM_DECOMMIT);
        VirtualFreeEx(hProcess, BufferAddress, 0, MEM_RELEASE);
        return NULL;
    }

    return BufferAddress;
}

DWORD SearchCodePatchOffset(PVOID lpFunctionAddress, SIZE_T FunctionSize)
{
    for (int i = 0; i < FunctionSize - 8; i++)
    {
        // x86
        if (__SIZEOF_POINTER__ == 4 && *(ULONG_PTR *)((ULONG_PTR)lpFunctionAddress + i) == 0x11223344)
            return i;
        // x64
        else if (__SIZEOF_POINTER__ == 8 && *(ULONG_PTR *)((ULONG_PTR)lpFunctionAddress + i) == 0x1122334455667788)
            return i;
    }

    return -1;
}

int WINAPI NewMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType)
{
    /*
    An error occurs in the following ways:
    return OriMessageBox(hWnd, "Hooked..!", lpCaption. uType);
    The compiled "Hooked..!" in this code points to a section of the process with a pointer, 
    so another process Occur EXCEPTION_ACCESS_VIOLATION.
    Therefore, you must store all the strings in the stack.
    */
    // All strings should be used as follows
    char Text[] = "Hooked..!";

    // Top 5 Bytes of MessageBoxA in user32.dll
    BYTE OriginCode[5] = { 
        0x8B, 0xFF, // mov edi, edi
        0x55,       // push ebp
        0x8B, 0xEC  // mov ebp, esp
    };
    
    // Variables to back up hook code
    BYTE HookCode[5];
    
    // 0x11223344 is code patched to original MessageBoxA address after Code Injection
    volatile int (WINAPI *OriMessageBox)(HWND, LPCSTR, LPCSTR, UINT) = 0x11223344;

    for (int i = 0; i < 5; i++)
    {
        // Backup hook code
        HookCode[i] = *(BYTE *)((ULONG_PTR)OriMessageBox + i);
        
        // Overwrite Top 5 Bytes of MessageBoxA to original code.
        // Trampoline(Inline) Hook code to Original code
        *(BYTE *)((ULONG_PTR)OriMessageBox + i) = OriginCode[i];
    }

    // call after Manipulate lpText parameter and save return value
    int ret = OriMessageBox(hWnd, Text, lpCaption, uType);

    // Overwrite with hook code again when function ends
    for (int i = 0; i < 5; i++)
        *(BYTE *)((ULONG_PTR)OriMessageBox + i) = HookCode[i];

    return ret;
}

BOOL Trampoline_Hook(HANDLE hProcess, LPCSTR lpModuleName, LPCSTR lpProcName, PVOID lpNewApiAddress, SIZE_T NewApiSize)
{
    SIZE_T NumberOfBytesRead;

    // Code Injection of NewAPI(HOOK Function)
    PVOID NewApiAddress = CodeInjection(hProcess, lpNewApiAddress, NewApiSize);

    if (NewApiAddress == NULL)
        return FALSE;

    // Find address of target api
    PVOID ProcAddress = GetRemoteProcAddress(hProcess, GetRemoteModuleHandleA(hProcess, lpModuleName), lpProcName);

    if (ProcAddress == NULL)
    {
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_DECOMMIT);
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_RELEASE);
        return FALSE;
    }

    DWORD OldProtect;

    // Change memory protection option of Top 5 byte of target api (PAGE_EXECUTE_READ to PAGE_EXECUTE_READWRITE)
    if (VirtualProtectEx(hProcess, ProcAddress, 5, PAGE_EXECUTE_READWRITE, &OldProtect) == FALSE)
    {
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_DECOMMIT);
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_RELEASE);
        return FALSE;
    }

    // Assembly Code
    BYTE JmpCode[5] = { 
        0xE9, 0x00, 0x00, 0x00, 0x00 // jmp 0x00000000 (4Byte Relative jump)
    };

    // Calculate relative jump address
    // Relative Address = Target Address - Hook Address - 5 (5Byte is assembly length)
    // jmp NewApiAddress
    *(DWORD *)(JmpCode + 1) = (ULONG_PTR)NewApiAddress - (ULONG_PTR)ProcAddress - 5; 

    // Code patch 0x11223344 in new api
    if (CodePatch(hProcess, (ULONG_PTR)NewApiAddress + SearchCodePatchOffset(NewMessageBoxA, NewApiSize), &ProcAddress, 4) == FALSE)
    {
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_DECOMMIT);
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_RELEASE);
        return FALSE;
    }

    // Top 5 bytes code patch of target process
    if (CodePatch(hProcess, ProcAddress, JmpCode, 5) == FALSE)
    {
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_DECOMMIT);
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_RELEASE);
        return FALSE;
    }

    // Trampline(Inline) Hooking success!!
    return TRUE;
}

int main(int argc, char *argv[])
{
    DWORD PID = 0;
    printf("PID : ");
    scanf("%d", &PID);

    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
    if (Trampoline_Hook(hProcess, "user32.dll", "MessageBoxA", NewMessageBoxA, (ULONG_PTR)Trampoline_Hook - (ULONG_PTR)NewMessageBoxA))
        printf("Trampoline Hooking Success\n");
    else
        printf("Trampoline Hooking Failed\n");
}

main.exe

0.06MB

타겟 프로그램

소스코드는 아래 더보기에 있다.

#include <windows.h>

#define SHOW_MESSAGEBOX 1

int (WINAPI *lpMessageBoxA)(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType);

VOID AddButton(HWND hWnd);
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    RECT wr = { 0, 0, 500, 500};

    AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);

    WNDCLASSA wc = { 0, };

    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
    wc.hCursor = LoadCursorA(NULL, IDC_ARROW);
    wc.hInstance = hInstance;
    wc.lpszClassName = "WindowsClass";
    wc.lpfnWndProc = WndProc;

    if (RegisterClassA(&wc) == 0)
        return -1;

    HWND hWnd = CreateWindowA("WindowsClass", "Code Injection", WS_OVERLAPPEDWINDOW | WS_VISIBLE, GetSystemMetrics(SM_CXSCREEN) / 2 - 250, GetSystemMetrics(SM_CYSCREEN) / 2 - 250, wr.right - wr.left, wr.bottom - wr.top, NULL, NULL, NULL, NULL);
    lpMessageBoxA = GetProcAddress(GetModuleHandleA("user32.dll"), "MessageBoxA");

    MSG msg = { 0, };

    while (GetMessageA(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
    switch (Msg)
    {
    case WM_COMMAND:
        if (wParam == SHOW_MESSAGEBOX)
            lpMessageBoxA(hWnd, "Not Hooked..!", "Click Me!", 0);
    case WM_CREATE:
        AddButton(hWnd);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProcA(hWnd, Msg, wParam, lParam);
    }
}

VOID AddButton(HWND hWnd)
{
    CreateWindowA("Button", "Click Me!", WS_VISIBLE | WS_CHILD, 200, 225, 100, 50, hWnd, SHOW_MESSAGEBOX, NULL, NULL);
}

target.exe

0.05MB

결과 확인

[Reversing] Code Injection + IAT Hooking

미친해커 — Fri, 22 Apr 2022 05:07:40 +0900

코드 인젝션과 IAT 후킹의 조합

코드 인젝션은 Fileless 형식의 임의의 코드 주입 공격이다. 그리고 IAT 후킹은 프로세스의 Import Address Table을 조작하여 특정 API의 제어권을 가로채는 기법이다.

이 두개의 기법을 적절히 활용하면 Fileless 형식의 IAT 후킹을 할수 있다.

예제 코드

GitHub - jungjin0003/Code-Injection: Code Injection + Hooking sample

Code Injection + Hooking sample. Contribute to jungjin0003/Code-Injection development by creating an account on GitHub.

github.com

Code Injector

소스코드는 아래 더보기에 있다.

#include <stdio.h>
#include <windows.h>
#include <winternl.h>

#define IFREE(HeapBase) (RtlFreeHeap(_get_heap_handle(), 0, (HeapBase)) || 1)
#define Upper(s1)       (s1 >= 65 && s1 <= 90 ? (char)s1 + 32 : s1)

WINBOOL CodePatch(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize)
{
    SIZE_T lpNumberOfBytesWritten = 0;
    return WriteProcessMemory(hProcess, lpBaseAddress, lpBuffer, nSize, &lpNumberOfBytesWritten) && nSize == lpNumberOfBytesWritten;
}

LPVOID FindIATAddress(HANDLE hProcess, LPCSTR lpModuleName, LPCSTR lpProcName)
{
    PROCESS_BASIC_INFORMATION pbi = { 0, };
    // NtQueryInformationProcess 함수로 타겟 프로세스의 PEB 주소를 구한다.
    NtQueryInformationProcess(hProcess, ProcessBasicInformation, &pbi, sizeof(PROCESS_BASIC_INFORMATION), NULL);
    
    PVOID BaseAddress;
    // PEB 구조체에서 ImageBase를 읽어온다.
    if (ReadProcessMemory(hProcess, (ULONG_PTR)pbi.PebBaseAddress + 0x10, &BaseAddress, sizeof(ULONG_PTR), NULL) == FALSE)
    {
        return NULL;
    }

    IMAGE_DOS_HEADER *DOS = malloc(sizeof(IMAGE_DOS_HEADER));
    // 타겟 프로세스의 IMAGE_DOS_HEADER를 읽어온다.
    if (ReadProcessMemory(hProcess, BaseAddress, DOS, sizeof(IMAGE_DOS_HEADER), NULL) == FALSE && IFREE(DOS))
    {
        return NULL;
    }

    IMAGE_NT_HEADERS *NT = malloc(sizeof(IMAGE_NT_HEADERS));
    // 타겟 프로세스의 IMAGE_NT_HEADER를 읽어온다.
    if (ReadProcessMemory(hProcess, (ULONG_PTR)BaseAddress + DOS->e_lfanew, NT, sizeof(IMAGE_NT_HEADERS), NULL) == FALSE && IFREE(DOS) && IFREE(NT))
    {
        return NULL;
    }

    free(DOS);

    IMAGE_IMPORT_DESCRIPTOR *IMPORT = malloc(NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size);
    PVOID *FirstImport = IMPORT;
    // NT Header에서 IMAGE_IMPORT_DESCRIPTOR를 읽어온다.
    if (ReadProcessMemory(hProcess, (ULONG_PTR)BaseAddress + NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress, IMPORT, NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size, NULL) == FALSE && IFREE(NT) && IFREE(IMPORT))
    {
        return NULL;
    }

    free(NT);
    // 타겟 DLL의 IMAGE_IMPORT_DESCRIPTOR를 찾는다.
    for (; IMPORT->OriginalFirstThunk != NULL; IMPORT++)
    {
        // 현재 IMAGE_IMPORT_DESCRIPTOR의 DLL 이름과 타겟 DLL이름을 비교
        for (char ch, i = 0; ReadProcessMemory(hProcess, (ULONG_PTR)BaseAddress + IMPORT->Name + i, &ch, 1, NULL); i++)
        {
            if (Upper(ch) != Upper(lpModuleName[i]))
                break;
            else if (ch == NULL && lpModuleName[i] == NULL)
                goto FOUND_MODULE;
        }
        continue;
FOUND_MODULE:
        break;
    }

    if (IMPORT->OriginalFirstThunk == NULL)
        return NULL;

    PVOID IATAddress = NULL;

    IMAGE_THUNK_DATA *THUNK = malloc(sizeof(IMAGE_THUNK_DATA));
    // 타겟 API의 IAT 주소를 구한다.
    for (int i = 0; ReadProcessMemory(hProcess, (ULONG_PTR)BaseAddress + IMPORT->OriginalFirstThunk + i * sizeof(void *), THUNK, sizeof(IMAGE_THUNK_DATA), NULL) && THUNK->u1.AddressOfData != NULL; i++)
    {
        if (THUNK->u1.Ordinal >= 0x80000000)
            continue;
        // Compare api name of current IMPORT->OriginalFirstThunk to target api name
        for (char ch, j = 0; ReadProcessMemory(hProcess, (ULONG_PTR)BaseAddress + THUNK->u1.AddressOfData + j + 2, &ch, 1, NULL); j++)
        {
            if (ch != lpProcName[j])
                break;
            else if (ch == NULL && lpProcName[j] == NULL)
            {
                IATAddress = (ULONG_PTR)BaseAddress + IMPORT->FirstThunk + i * sizeof(void *);
                goto FOUND_IAT;
            }
        }
    }
FOUND_IAT:
    free(THUNK);
    free(FirstImport);
    return IATAddress;
}

PVOID CodeInjection(HANDLE hProcess, PVOID lpBuffer, SIZE_T nSize)
{
    // 타겟 프로세스의 공간에 메모리 할당
    PVOID BufferAddress = VirtualAllocEx(hProcess, NULL, nSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);

    if (BufferAddress == NULL)
    {
        return NULL;
    }

    SIZE_T NumberOfBytesWritten;
    // 할당한 공간에 lpBuffer의 데이터를 작성
    if (WriteProcessMemory(hProcess, BufferAddress, lpBuffer, nSize, &NumberOfBytesWritten) == FALSE || nSize > NumberOfBytesWritten)
    {
        VirtualFreeEx(hProcess, BufferAddress, 0, MEM_DECOMMIT);
        VirtualFreeEx(hProcess, BufferAddress, 0, MEM_RELEASE);
        return NULL;
    }

    return BufferAddress;
}

DWORD SearchCodePatchOffset(PVOID lpFunctionAddress, SIZE_T FunctionSize)
{
    for (int i = 0; i < FunctionSize - 8; i++)
    {
        // x86
        if (__SIZEOF_POINTER__ == 4 && *(ULONG_PTR *)((ULONG_PTR)lpFunctionAddress + i) == 0x11223344)
            return i;
        // x64
        else if (__SIZEOF_POINTER__ == 8 && *(ULONG_PTR *)((ULONG_PTR)lpFunctionAddress + i) == 0x1122334455667788)
            return i;
    }

    return -1;
}

int WINAPI NewMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType)
{
    /*
    다음과 같은 방법으로 호출하면 에러가 발생한다.
    return OriMessageBox(hWnd, "Hooked..!", lpCaption. uType);
    해당 코드가 컴파일 될때 "Hooked..!" 문자열은 포인터이기 때문에 다른 섹션에 저장되고
    해당 섹션에서 포인터로 파라미터를 전달하기 때문에 다른 프로세스에서
    해당 코드가 실행되면 다음과 같은 오류가 발생한다. EXCEPTION_ACCESS_VIOLATION.
    그렇기 때문에 모든 문자열을 스택에 저장되도록 프로그래밍 해야한다.
    */
    // 모든 문자열은 다음과 같은 방식으로 선언해야 한다.
    char Text[] = "Hooked..!";
    // 0x1122334455667788은 코드 인젝션 후에 원본 MessageBoxA 주소로 패치된다. 
    volatile int (WINAPI *OriMessageBox)(HWND, LPCSTR, LPCSTR, UINT) = 0x1122334455667788;
    // x86 시스템에서 사용한다면 다음과 같이 선언한다.
    // volatile int (WINAPI *OriMessageBox)(HWND, LPCSTR, LPCSTR, UINT) = 0x11223344; 

    // lpText 변수를 조작하여 함수 실행
    return OriMessageBox(hWnd, Text, lpCaption, uType);
}

BOOL IAT_Hook(HANDLE hProcess, LPCSTR lpModuleName, LPCSTR lpProcName, PVOID lpNewApiAddress, SIZE_T NewApiSize)
{
    SIZE_T NumberOfBytesRead;
    // Code Injection of NewAPI(HOOK Function)
    PVOID NewApiAddress = CodeInjection(hProcess, lpNewApiAddress, NewApiSize);

    if (NewApiAddress == NULL)
        return FALSE;
    // Find IAT address of target api
    PVOID IATAddress = FindIATAddress(hProcess, lpModuleName, lpProcName);

    if (IATAddress == NULL)
    {
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_DECOMMIT);
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_RELEASE);
        return FALSE;
    }
    
    PVOID OriAPIAddress = NULL;
    // Read original api address from IAT
    if (ReadProcessMemory(hProcess, IATAddress, &OriAPIAddress, sizeof(PVOID), &NumberOfBytesRead) == FALSE || NumberOfBytesRead != 8)
    {
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_DECOMMIT);
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_RELEASE);
        return FALSE;
    }
    // Code patch 0xFFFFFFFFFFFFFFFF in new api
    if (CodePatch(hProcess, (ULONG_PTR)NewApiAddress + SearchCodePatchOffset(NewMessageBoxA, NewApiSize), &OriAPIAddress, sizeof(ULONG_PTR)) == FALSE)
    {
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_DECOMMIT);
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_RELEASE);
        return FALSE;
    }
    // IAT code patch of target process
    if (CodePatch(hProcess, IATAddress, &NewApiAddress, sizeof(ULONG_PTR)) == FALSE)
    {
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_DECOMMIT);
        VirtualFreeEx(hProcess, NewApiAddress, 0, MEM_RELEASE);
        return FALSE;
    }
    // IAT Hooking success!!
    return TRUE;
}

int main(int argc, char *argv[])
{
    DWORD PID = 0;
    printf("PID : ");
    scanf("%d", &PID);

    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
    if (IAT_Hook(hProcess, "user32.dll", "MessageBoxA", NewMessageBoxA, (ULONG_PTR)IAT_Hook - (ULONG_PTR)NewMessageBoxA))
    {
        printf("IAT Hooking Success\n");
    }
    else
    {
        printf("IAT Hooking Failed\n");
    }
}

main.exe

0.06MB

타겟 프로그램

소스코드는 아래 더보기에 있다.

#include <windows.h>

#define SHOW_MESSAGEBOX 1

VOID AddButton(HWND hWnd);
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    RECT wr = { 0, 0, 500, 500};

    AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);

    WNDCLASSA wc = { 0, };

    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
    wc.hCursor = LoadCursorA(NULL, IDC_ARROW);
    wc.hInstance = hInstance;
    wc.lpszClassName = "WindowsClass";
    wc.lpfnWndProc = WndProc;

    if (RegisterClassA(&wc) == 0)
        return -1;

    HWND hWnd = CreateWindowA("WindowsClass", "Code Injection", WS_OVERLAPPEDWINDOW | WS_VISIBLE, GetSystemMetrics(SM_CXSCREEN) / 2 - 250, GetSystemMetrics(SM_CYSCREEN) / 2 - 250, wr.right - wr.left, wr.bottom - wr.top, NULL, NULL, NULL, NULL);

    MSG msg = { 0, };

    while (GetMessageA(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
    switch (Msg)
    {
    case WM_COMMAND:
        if (wParam == SHOW_MESSAGEBOX)
            MessageBoxA(hWnd, "Not Hooked..!", "Click Me!", 0);
    case WM_CREATE:
        AddButton(hWnd);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProcA(hWnd, Msg, wParam, lParam);
    }
}

VOID AddButton(HWND hWnd)
{
    CreateWindowA("Button", "Click Me!", WS_VISIBLE | WS_CHILD, 200, 225, 100, 50, hWnd, SHOW_MESSAGEBOX, NULL, NULL);
}

target.exe

0.06MB

결과 확인

[Nintendo 3DS] hello-world 예제 코드분석(주석설명)

미친해커 — Thu, 21 Apr 2022 22:45:23 +0900

hello-world 예제

hello-world 예제는 devkitPro를 설치하면 함께 다운로드되는 Nintendo 사의 게임기들의 예제 코드(프로젝트)중 하나 이다. 기본적으로 검은색 콘솔 중앙에 'Hello World!' 를 출력한다. 코드는 다음과 같다.

/*
	Hello World example made by Aurelio Mannara for libctru
	This code was modified for the last time on: 12/12/2014 21:00 UTC+1
*/

#include <3ds.h>
#include <stdio.h>

int main(int argc, char **argv)
{
	gfxInitDefault();

	//상단 화면을 콘솔 초기화합니다. 두 번째 인자로 NULL을 사용하면 기본 콘솔을 사용합니다.
	consoleInit(GFX_TOP, NULL);

	//커서를 15행과 19열로 이동한 다음 "Hello World!"를 출력합니다.
	//커서를 이동하려면 "\x1b[r;cH"를 출력해야합니다. 여기서 r과 c는
	//각각 커서를 이동할 행과 열입니다.
	//상단 화면에는 30개의 행과 50개의 열이 있습니다.
	//하단 화면에는 30개의 행과 40개의 열이 있습니다.
	printf("\x1b[16;20HHello World!");

	printf("\x1b[30;16HPress Start to exit.");

	// 메인 루프
	while (aptMainLoop())
	{
		//모든 입력을 스캔합니다. 이 작업은 프레임 마다 한 번 수행해야 합니다.
		hidScanInput();

		//hidKeysDown 은 방금 누른 버튼에 대한 정보를 반환합니다.
		u32 kDown = hidKeysDown();

		if (kDown & KEY_START) break; // 메뉴로 돌아가기 위해 메인 루프를 중단합니다.

		// 프레임 버퍼 플러시 및 스왑
		gfxFlushBuffers();
		gfxSwapBuffers();

		//Wait for VBlank
		gspWaitForVBlank();
	}

	gfxExit();
	return 0;
}

[Nintendo 3DS] 닌텐도 3DS 예제 컴파일하기

미친해커 — Wed, 20 Apr 2022 04:07:17 +0900

닌텐도 3DS 예제 파일

닌텐도 3DS의 예제 파일은 우리가 설치한 devkitPro 폴더에 들어가 있다. 경로는 다음과 같다.

C:\devkitPro\examples\3ds

위 경로에 들어가면 3DS와 관련된 예제 파일들을 볼수 있다. 우리는 여기서 graphics\printing\hello-world 경로에 들어가면 예제가 존재한다. cmd를 열고 해당경로로 이동하자.

컴파일하기

해당 폴더에 이동했다면 make 명령어를 실행해보자

위와 같이 main.c 파일이 컴파일되어 hello-world.elf, hello-world.smdh, hello-world.3dsx 이렇게 3개의 파일이 나오게 된다. 여기서 나오는 3dsx 파일이 citra 에뮬레이터 돌아가는 파일이다. 이 파일은 3ds의 Homebrew라는 써드파티 앱?에서도 돌아가는 파일이다. 하지만 만약 커펌된 3DS가 없다면 citra를 실행해 해당 파일을 불러오면 실행할 수 있다.

citra에서 3dsx 실행하기

커펌된 3DS에서 실행하기

1. 3DS의 SD 카드를 PC와 연결

2. 폴더에 3dsx 파일 복사/붙여넣기

3. Homebrew 에서 hello-world 실행하기

이렇게 우리가 기본적인 예제를 컴파일하여 실행해보았다. 다음 포스팅에서는 hello-world의 코드분석을 해볼 예정이다.

[Nintendo 3DS] 닌텐도 3DS 개발환경 구축하기

미친해커 — Tue, 19 Apr 2022 02:16:57 +0900

닌텐도 3DS 개발에 도전하게된 이유

이유는 없다. 필자가 지금까지 무언가에 도전하는데에는 큰 이유가 있지 않다. 그냥 단순히 재밌어보이고 해보고 싶기 때문이다. 이번에도 닌텐도 3DS의 시스템에 관심이 생겨 한번 도전하게 되었다.

닌텐도 3DS 개발환경 구축

1. devkitPro Install

devkitPro는 GCC 툴체인 기반의 ARM을 지원하는 컴파일러이다. 닌텐도 3DS는 ARM 기반의 시스템이기 때문에 ARM 컴파일러가 필요하다. 이를 위해 devkiPro를 이용해 크로스 컴파일(다른 환경의 바이너리로 컴파일 하는 것)을 한다. 다음 링크에서 Installer를 다운한다.

Releases · devkitPro/installer

Contribute to devkitPro/installer development by creating an account on GitHub.

github.com

devkitProUpdater-3.0.3.exe

0.19MB

위 과정을 따라오면 3DS 개발용 컴파일러가 설치되고 환경변수도 설정된다.

2. Visual Studio Code 컴파일 설정

make를 사용해 컴파일을 할 수도 있지만 나는 따로 설정했다.

// c_cpp_properties.json
{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceFolder}/**",
                "C:/devkitPro/libctru/include/**",
                "C:/devkitPro/devkitARM/arm-none-eabi/include/**"
            ],
            "defines": [
                "_DEBUG",
                "UNICODE",
                "_UNICODE"
            ],
            "compilerPath": "C:/devkitPro/devkitARM/bin/arm-none-eabi-gcc.exe"
        }
    ],
    "version": 4
}

// tasks.json
{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "arm-none-eabi-gcc Nintendo 3DS Compile",
            "type": "process",
            "command": "cmd",
            "args": [
                "/c",
                "C:\\devkitPro\\devkitARM\\bin\\arm-none-eabi-gcc.exe",
                "-MMD",
                "-MP",
                "-MF",
                "${fileDirname}\\${fileBasenameNoExtension}.d",
                "-g",
                "-Wall",
                "-O2",
                "-mword-relocations",
                "-ffunction-sections",
                "-march=armv6k",
                "-mtune=mpcore",
                "-mfloat-abi=hard",
                "-mtp=soft",
                "-I",
                "${fileDirname}",
                "-I",
                "C:\\devkitPro\\libctru\\include",
                "-D__3DS__",
                "-c",
                "${file}",
                "-o",
                "${fileDirname}\\${fileBasenameNoExtension}.o",
                "&&",
                "C:\\devkitPro\\devkitARM\\bin\\arm-none-eabi-gcc.exe",
                "-specs=3dsx.specs",
                "-g",
                "-march=armv6k",
                "-mtune=mpcore",
                "-mfloat-abi=hard",
                "-mtp=soft",
                "-Wl,-Map,${fileDirname}\\${fileBasenameNoExtension}.map",
                "${fileDirname}\\${fileBasenameNoExtension}.o",
                "-LC:\\devkitPro\\libctru\\lib",
                "-lctru",
                "-lm",
                "-o",
                "${fileDirname}\\${fileBasenameNoExtension}.elf",
                "&&",
                "C:\\devkitPro\\devkitARM\\bin\\arm-none-eabi-gcc-nm.exe",
                "-CSn",
                "${fileDirname}\\${fileBasenameNoExtension}.elf",
                "&&",
                "C:\\devkitPro\\tools\\bin\\smdhtool.exe",
                "--create",
                "패키지 이름",
                "프로그램 이름",
                "제작자",
                "C:\\devkitPro\\libctru\\default_icon.png",
                "${fileDirname}\\${fileBasenameNoExtension}.smdh",
                "&&",
                "C:\\devkitPro\\tools\\bin\\3dsxtool.exe",
                "${fileDirname}\\${fileBasenameNoExtension}.elf",
                "${fileDirname}\\${fileBasenameNoExtension}.3dsx",
                "--smdh=${fileDirname}\\${fileBasenameNoExtension}.smdh"
            ],
            "options": {
                "cwd": "${workspaceFolder}"
            },
            "group": "build",
            "detail": "컴파일러: arm-none-eabi-gcc"
        }
    ]
}

위 두개의 파일을 각각 저장해 VS Code의 Workspace 폴더 최상위에 .vscode 폴더를 만들어 넣어주면 된다.

3. Nintendo 3DS 에뮬레이터 설치

실제로 커펌(커스텀 펌웨어)된 닌텐도 3DS가 없는 경우에는 닌텐도 3DS 개발을 하더라도 해당 바이너리를 실행시킬 수 없다. 그렇기에 다음과 같이 에뮬레이터를 설치해주자

Download Citra · Citra

The nightly build of Citra contains already reviewed and tested features. If you require support with the installation or use of Citra, or you want to report bugs you should use this version. This version is still in development, so expect crashes and bugs

citra-emu.org

citra-setup-windows.exe

18.79MB

4. 셋팅 확인

이렇게 cmd를 열고 where make 명령어를 했을 때 정상적으로 잡히면 성공이다. 잡히지 않는다면 따로 환경변수 셋팅을 해주도록 하자.

[Reversing] Code Injection Step 2

미친해커 — Thu, 7 Apr 2022 22:59:01 +0900

해당 포스팅은 이전 포스팅에서 이어집니다.

[Reversing] Code Injection Step 1

Code Injection 기법은 사실상 ShellCode Injection 이라고 불러도 될 만큼 동작 방식이 매우 비슷하다. 하지만 우리는 주입할 코드를 ShellCode가 아닌 C언어 함수로 작성해 주입할 것이다. 1. 주입할 함수 작

crazyhacker.tistory.com

Why did the error occur?

에러가 발생되는 원인은 다음과 같다.

주입된 어셈블리(코드)를 확인해보면 0x1E54A422AB0를 첫번째 인자로 넘기고 0x1E54A426D8C에서 WinExec의 주소를 rax로 가져와 call 하게 된다. 하지만 해당 2개의 주소는 존재하지(사용되지) 않는 것을 확인할 수 있다.

0x1E54A422AB0는 "calc.exe" 문자열을 가르킨다. 그리고 0x1E54A426D8C에는 WinExec의 주소가 들어있다. 하지만 타겟 프로세스의 공간에는 해당 문자열("calc.exe")과 IAT(WinExec의 주소)가 존재하지 않는다. 따라서 우리는 타겟 프로세스에 인자로 들어가는 문자열(실행시킬 프로그램 이름)과 WinExec의 주소를 전달해줘야한다.

소스코드 수정

typedef UINT (*WINAPI WINEXEC)(LPCSTR, UINT);

typedef struct _INJECT_DATA
{
    WINEXEC pWinExec; // WinExec 함수의 주소를 담을 함수 포인터
    char string[12];  // 실행시킬 프로그램 이름
} INJECT_DATA;

// 인자의 유형을 INJECT_DATA의 포인터로 변경
DWORD WINAPI ThreadProc(INJECT_DATA *lpParameter)
{
    lpParameter->pWinExec(lpParameter->string, SW_SHOW);
    // WinExec("calc.exe", SW_SHOW);
}

BOOL CodeInjection(DWORD PID)
{
    // 타겟 프로세스의 핸들 획득 
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);

    if (hProcess == NULL)
    {
        printf("OpenProcess Failed!\n");
        return FALSE;
    }

    // 주입할 함수의 사이즈를 계산
    SIZE_T ThreadProcSize = (ULONGLONG)AtherFunc - (ULONGLONG)ThreadProc;

    // 타겟 프로세스에 공간 할당
    PVOID ThreadProcAddress = VirtualAllocEx(hProcess, NULL, ThreadProcSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    PVOID InjectDataAddress = VirtualAllocEx(hProcess, NULL, sizeof(INJECT_DATA), MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    // 할당된 공간에 ThreadProc 함수 작성
    if (WriteProcessMemory(hProcess, ThreadProcAddress, (LPCVOID)ThreadProc, ThreadProcSize, NULL) == FALSE)
    {
        printf("WriteProcessMemory Failed!\n");
        return FALSE;
    }

    // 구조체 생성
    INJECT_DATA InjectData;
    // WinExec API는 Kernel32.dll에 존재한다. GetProcAddress와 GetModuleHandle API를 이용하여 함수의 주소를 알아낼 수 있다.
    InjectData.pWinExec = (WINEXEC)GetProcAddress(GetModuleHandleA("kernel32.dll"), "WinExec");
    // INJECT_DATA 구조체의 string에 실행시킬 파일의 문자열을 입력한다.
    strcpy(InjectData.string, "calc.exe");

    // 할당된 공간에 InjectData 작성
    if (WriteProcessMemory(hProcess, InjectDataAddress, (LPCVOID)&InjectData, sizeof(INJECT_DATA), NULL) == FALSE)
    {
        printf("WriteProcessMemory Failed!\n");
        return FALSE;
    }

    // 쓰레드 생성 및 실행
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProcAddress, (LPVOID)InjectDataAddress, 0, NULL);

    if (hThread == NULL)
    {
        printf("CreateRemoteThread Failed\n");
        return FALSE;
    }

    printf("Code Injection Success!\n");
    return TRUE;
}

완성된 코드

#include <stdio.h>
#include <windows.h>

typedef UINT (*WINAPI WINEXEC)(LPCSTR, UINT);

typedef struct _INJECT_DATA
{
    WINEXEC pWinExec;
    char string[12];
} INJECT_DATA;

// 인자의 유형을 INJECT_DATA의 포인터로 변경
DWORD WINAPI ThreadProc(INJECT_DATA *lpParameter)
{
    lpParameter->pWinExec(lpParameter->string, SW_SHOW);
    // WinExec("calc.exe", SW_SHOW);
}
int AtherFunc() {}

BOOL CodeInjection(DWORD PID)
{
    // 타겟 프로세스의 핸들 획득 
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);

    if (hProcess == NULL)
    {
        printf("OpenProcess Failed!\n");
        return FALSE;
    }

    // 주입할 함수의 사이즈를 계산
    SIZE_T ThreadProcSize = (ULONGLONG)AtherFunc - (ULONGLONG)ThreadProc;

    // 타겟 프로세스에 공간 할당
    PVOID ThreadProcAddress = VirtualAllocEx(hProcess, NULL, ThreadProcSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    PVOID InjectDataAddress = VirtualAllocEx(hProcess, NULL, sizeof(INJECT_DATA), MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    // 할당된 공간에 ThreadProc 함수 작성
    if (WriteProcessMemory(hProcess, ThreadProcAddress, (LPCVOID)ThreadProc, ThreadProcSize, NULL) == FALSE)
    {
        printf("WriteProcessMemory Failed!\n");
        return FALSE;
    }

    // 인자로 전달할 데이터 셋팅
    INJECT_DATA InjectData;
    InjectData.pWinExec = (WINEXEC)GetProcAddress(GetModuleHandleA("kernel32.dll"), "WinExec");
    strcpy(InjectData.string, "calc.exe");

    // 할당된 공간에 InjectData 작성
    if (WriteProcessMemory(hProcess, InjectDataAddress, (LPCVOID)&InjectData, sizeof(INJECT_DATA), NULL) == FALSE)
    {
        printf("WriteProcessMemory Failed!\n");
        return FALSE;
    }

    // 쓰레드 생성 및 실행
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProcAddress, (LPVOID)InjectDataAddress, 0, NULL);

    if (hThread == NULL)
    {
        printf("CreateRemoteThread Failed\n");
        return FALSE;
    }

    printf("Code Injection Success!\n");
    return TRUE;
}

int main(int argc, char *argv[])
{
    DWORD PID = 0;
    printf("PID : ");
    scanf("%d", &PID);

    CodeInjection(PID);
}

빌드 후에 프로그램을 실행해 타겟 프로세스의 PID를 입력한다. 그럼 정상적으로 계산기 프로그램이 실행되는 것을 확인할 수 있다.

[Reversing] Code Injection Step 1

미친해커 — Tue, 5 Apr 2022 17:44:31 +0900

Code Injection 기법은 사실상 ShellCode Injection 이라고 불러도 될 만큼 동작 방식이 매우 비슷하다. 하지만 우리는 주입할 코드를 ShellCode가 아닌 C언어 함수로 작성해 주입할 것이다.

1. 주입할 함수 작성

/*
주입되는 코드는 CreateRemoteThread API를 통해 실행되기 때문에
아래와 같은 형식을 반드시 지켜줘야 한다. (함수명은 관계 없음)
*/
DWORD WINAPI ThreadProc(LPVOID lpParameter)
{
    // 계산기를 실행
    WinExec("calc.exe", SW_SHOW);
}

2. 코드 인젝션 함수 작성

BOOL CodeInjection(DWORD PID)
{
    // 타겟 프로세스의 핸들 획득 
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);

    if (hProcess == NULL)
    {
        printf("OpenProcess Failed!\n");
        return FALSE;
    }

    // 주입할 함수의 사이즈를 계산
    SIZE_T ThreadProcSize = (ULONGLONG)AtherFunc - (ULONGLONG)ThreadProc;

    // 타겟 프로세스에 공간 할당
    PVOID ThreadProcAddress = VirtualAllocEx(hProcess, NULL, ThreadProcSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    // 할당된 공간에 ThreadProc 함수 작성
    if (WriteProcessMemory(hProcess, ThreadProcAddress, (LPCVOID)ThreadProc, ThreadProcSize, NULL) == FALSE)
    {
        printf("WriteProcessMemory Failed!\n");
        return -1;
    }

    // 쓰레드 생성 및 실행
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProcAddress, NULL, 0, NULL);

    if (hThread == NULL)
    {
        printf("CreateRemoteThread Failed\n");
        return FALSE;
    }

    printf("Code Injection Success!\n");
    return TRUE;
}

완성된 코드

#include <stdio.h>
#include <windows.h>

/*
주입되는 코드는 CreateRemoteThread API를 통해 실행되기 때문에
아래와 같은 형식을 반드시 지켜줘야 한다. (함수명은 관계 없음)
*/
DWORD WINAPI ThreadProc(LPVOID lpParameter)
{
    // 계산기를 실행
    WinExec("calc.exe", SW_SHOW);
}
int AtherFunc() {} // ThreadProc 함수의 사이즈를 구하기 위해 아무런 기능을 하지 않는 함수를 정의

BOOL CodeInjection(DWORD PID)
{
    // 타겟 프로세스의 핸들 획득 
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);

    if (hProcess == NULL)
    {
        printf("OpenProcess Failed!\n");
        return FALSE;
    }

    // 주입할 함수의 사이즈를 계산
    SIZE_T ThreadProcSize = (ULONGLONG)AtherFunc - (ULONGLONG)ThreadProc;

    // 타겟 프로세스에 공간 할당
    PVOID ThreadProcAddress = VirtualAllocEx(hProcess, NULL, ThreadProcSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    // 할당된 공간에 ThreadProc 함수 작성
    if (WriteProcessMemory(hProcess, ThreadProcAddress, (LPCVOID)ThreadProc, ThreadProcSize, NULL) == FALSE)
    {
        printf("WriteProcessMemory Failed!\n");
        return -1;
    }

    // 쓰레드 생성 및 실행
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProcAddress, NULL, 0, NULL);

    if (hThread == NULL)
    {
        printf("CreateRemoteThread Failed\n");
        return FALSE;
    }

    printf("Code Injection Success!\n");
    return TRUE;
}

int main(int argc, char *argv[])
{
    DWORD PID = 0;
    printf("PID : ");
    scanf("%d", &PID);

    CodeInjection(PID);
}

위 코드를 빌드하기 전 다음과 같은 설정을 해준다.

빌드 최적화 옵션 해제
Release 모드로 빌드

빌드 후에 프로그램을 실행해 타겟 프로세스의 PID를 입력한다. 그럼 계산기가 뜨지 않고 타겟 프로세스가 오류를 띄우며 종료된다. 그게 정상이다.

타겟 프로세스로 삼은 메모장이 EXCEPTION_ACCESS_VIOLATION 에러를 띄우며 디버거를 띄운 모습

왜 이런 현상이 발생할까? 그 이유는 다음 포스팅에서 알아보자

[Reversing] Code Injection Step 0

미친해커 — Mon, 4 Apr 2022 18:52:00 +0900

코드 인젝션 (Code Injection) 정의

Code Injection이란 실행 가능한 코드를 대상 메모리 영역으로 삽입하여 실행하는 것을 말한다.

코드 인젝션 활용 영역

프로그램의 기능 개선 및 버그 패치
API 후킹
일반 응용 프로그램에 특별한 목적의 코드를 추가
악성코드에서의 활용

코드 인젝션 주요 동작 흐름

Windows API / Kernel Function

프로세스 권한 획득 : OpenProcess() / NtOpenProcess()
메모리 공간 할당 : VirtualAllocEx() / NtAllocateVirtualMemory()
코드 삽입 : WriteProcessMemory() / NtWriteVirtualMemory()
코드 실행 : CreateRemoteThread() / NtCreateThreadEx()

코드 인젝션 관련 주요 API

OpenProcess function (processthreadsapi.h) - Win32 apps

Opens an existing local process object.

docs.microsoft.com

VirtualAllocEx function (memoryapi.h) - Win32 apps

Reserves, commits, or changes the state of a region of memory within the virtual address space of a specified process. The function initializes the memory it allocates to zero.

docs.microsoft.com

VirtualProtectEx function (memoryapi.h) - Win32 apps

Changes the protection on a region of committed pages in the virtual address space of a specified process.

docs.microsoft.com

WriteProcessMemory function (memoryapi.h) - Win32 apps

Writes data to an area of memory in a specified process. The entire area to be written to must be accessible or the operation fails.

docs.microsoft.com

CreateRemoteThread function (processthreadsapi.h) - Win32 apps

Creates a thread that runs in the virtual address space of another process.

docs.microsoft.com

공격 원리

[C] Rlibloaderapi.h - GetRemoteModuleFileName

미친해커 — Thu, 17 Feb 2022 16:16:47 +0900

GetModuleFileName

GetModuleFileName 함수는 인자로 들어온 HMODULE의 전체 경로를 반환해주는 함수이다. 즉 HMODULE(ImageBase)는 가지고 있지만 해당 HMODULE이 어떤 DLL인지 모를때 사용하면 유용한 함수이다.

GetRemoteModuleFileName

DWORD GetRemoteModuleFileNameA(HANDLE ProcessHandle, HMODULE hModule, LPSTR lpFilename, DWORD nSize)
{
    ZeroMemory(lpFilename, nSize);
    wchar_t Filename[MAX_PATH];
    DWORD Size = GetRemoteModuleFileNameW(ProcessHandle, hModule, Filename, MAX_PATH);
    int FilenameLength = WideCharToMultiByte(CP_ACP, 0, Filename, -1, NULL, 0, NULL, NULL);
    WideCharToMultiByte(CP_ACP, 0, Filename, -1, lpFilename, FilenameLength <= nSize ? FilenameLength : nSize, NULL, NULL);
    return FilenameLength <= nSize ? FilenameLength : nSize;
}

DWORD GetRemoteModuleFileNameW(HANDLE ProcessHandle, HMODULE hModule, LPWSTR lpFilename, DWORD nSize)
{
#ifdef _WIN64
    BOOL bWow64Process;
    IsWow64Process(ProcessHandle, &bWow64Process);
    size_t SizeOfPointer = bWow64Process ? 4 : 8;
#else
    size_t SizeOfPointer = 4;
#endif
    nSize -= 2;
    DWORD Size = 0;
    PVOID PebBaseAddress = GetRemotePeb(ProcessHandle);

    if (PebBaseAddress == NULL)
        return Size;

    PVOID PebLdrData = NULL;

    if (ReadProcessMemory(ProcessHandle, 
#ifdef _WIN64
            (ULONG_PTR)PebBaseAddress + (bWow64Process ? Peb_LdrOffset32 : Peb_LdrOffset64), 
#else
            (ULONG_PTR)PebBaseAddress + Peb_LdrOffset32,
#endif
            &PebLdrData, 
            SizeOfPointer, 
            NULL) == FALSE)
        return hModule;

#ifdef _WIN64
    PVOID LdrDataTableEntry = (ULONG_PTR)PebLdrData + (bWow64Process ? PebLdrData_LOMLOffset32 : PebLdrData_LOMLOffset64);
#else
    PVOID LdrDataTableEntry = (ULONG_PTR)PebLdrData + PebLdrData_LOMLOffset32;
#endif

    for (; ReadProcessMemory(ProcessHandle, LdrDataTableEntry, &LdrDataTableEntry, SizeOfPointer, NULL) 
            && 
#ifdef _WIN64
            (ULONG_PTR)PebLdrData + (bWow64Process ? PebLdrData_LOMLOffset32 : PebLdrData_LOMLOffset64) != LdrDataTableEntry
#else
            (ULONG_PTR)PebLdrData + PebLdrData_LOMLOffset32 != LdrDataTableEntry
#endif
        ;)
    {
        PVOID DllBase;

        if (ReadProcessMemory(ProcessHandle, 
#ifdef _WIN64
                (ULONG_PTR)LdrDataTableEntry + (bWow64Process ? LdrDataTableEntry_DllBase32 : LdrDataTableEntry_DllBase64),
#else
                (ULONG_PTR)LdrDataTableEntry + LdrDataTableEntry_DllBase32, 
#endif
                &DllBase, 
                SizeOfPointer, 
                NULL) == FALSE)
            return Size;
        
        if (DllBase != hModule)
            continue;

#ifdef _WIN64
        size_t SizeOfUnicodeString = bWow64Process ? sizeof(UNICODE_STRING32) : sizeof(UNICODE_STRING64);
#else
        size_t SizeOfUnicodeString = sizeof(UNICODE_STRING);
#endif
        BYTE *UnicodeString = calloc(1, SizeOfUnicodeString);

        if (ReadProcessMemory(ProcessHandle, 
#ifdef _WIN64
                (ULONG_PTR)LdrDataTableEntry + (bWow64Process ? LdrDatatableEntry_FullDllName32 : LdrDatatableEntry_FullDllName64), 
#else
                (ULONG_PTR)LdrDataTableEntry + LdrDatatableEntry_FullDllName32, 
#endif
                UnicodeString, 
                SizeOfUnicodeString, 
                NULL) == FALSE)
            return Size;

        ZeroMemory(lpFilename, nSize + 2);

        if (ReadProcessMemory(ProcessHandle, 
#ifdef _WIN64
                bWow64Process ? ((UNICODE_STRING32 *)UnicodeString)->Buffer : ((UNICODE_STRING64 *)UnicodeString)->Buffer, 
                lpFilename, 
                bWow64Process ? ((UNICODE_STRING32 *)UnicodeString)->Length <= nSize ? ((UNICODE_STRING32 *)UnicodeString)->Length : nSize : ((UNICODE_STRING64 *)UnicodeString)->Length <= nSize ? ((UNICODE_STRING64 *)UnicodeString)->Length : nSize, // UnicodeString.Length <= nSize ? UnicodeString.Length : nSize, 
#else
                ((UNICODE_STRING *)UnicodeString)->Buffer,
                lpFilename,
                ((UNICDOE_STRING *)UnicodeString)->Length <= nSize ? ((UNICDOE_STRING *)UnicodeString)->Length : nSize,
#endif
                &Size) == FALSE && (RtlFreeHeap(_get_heap_handle(), 0, UnicodeString) || 1))
            return Size;

        free(UnicodeString);
        break;
    }

    return Size;
}

사용예시

#include <stdio.h>
#include "Rlibloaderapi.h"

int main()
{
    DWORD PID;
    printf("PID : ");
    scanf("%d", &PID);
    
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
    
    if (hProcess == NULL)
    {
    	printf("OpenProcess Failed\n");
        printf("GetLastError : %d\n", GetLastError());
        return -1;
    }
    
    char buffer[MAX_PATH];
    
    HMODULE hModule = GetRemoteModuleHandleA(hProcess, "kernel32.dll");
    GetRemoteModuleFileNameA(hProcess, hModule, buffer, MAX_PATH);
    
    printf("%s\n", buffer);
    
    return 0;
}

[C] Rlibloaderapi.h - GetRemoteProcAddress

미친해커 — Thu, 17 Feb 2022 14:00:47 +0900

GetProcAddress

GetProcAddress 함수는 kernel32.dll에 정의되어 있는 함수이다. 인자로 HMODULE과 함수의 이름을 주고 호출하게되면 해당 DLL에서 Export 하는 함수들 중 인자로 넣은 함수의 이름과 같은 이름의 함수의 주소를 반환해준다.

이 함수도 마찬가지로 현재 프로세스를 기준으로 하게된다. 하지만 굳이 이 함수까지 구현한 이유는 DLL Injection과 같은 기술을 사용할 때 혹시라도 kernel32.dll의 ImageBase가 다르거나 특정 함수의 주소를 알아야할 때가 있을 것같아 해당 함수도 Remote 버전을 구현하게 되었다.

GetRemoteProcAddress

FARPROC GetRemoteProcAddress(HANDLE ProcessHandle, HMODULE hModule, LPCSTR lpProcName)
{
#ifdef _WIN64
    BOOL bWow64Process;
    IsWow64Process(ProcessHandle, &bWow64Process);
    size_t SizeOfPointer = bWow64Process ? 4 : 8;
#else
    size_t SizeOfPointer = 4;
#endif
    FARPROC Proc = NULL;
    ULONG_PTR ImageBase = hModule;
    IMAGE_DOS_HEADER DOS;

    if (ReadProcessMemory(ProcessHandle, hModule, &DOS, sizeof(IMAGE_DOS_HEADER), NULL) == FALSE)
        return Proc;
#ifdef _WIN64
    BYTE *NT = malloc(bWow64Process ? sizeof(IMAGE_NT_HEADERS32) : sizeof(IMAGE_NT_HEADERS64));
#else
    IMAGE_NT_HEADERS32 *NT = malloc(sizeof(IMAGE_NT_HEADERS32));
#endif

    if (ReadProcessMemory(ProcessHandle, ImageBase + DOS.e_lfanew, NT, _msize(NT), NULL) == FALSE && IFREE(NT))
        return Proc;

    if (
#ifdef _WIN64
        (bWow64Process ? 
        ((IMAGE_NT_HEADERS32 *)NT)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress 
        :
        ((IMAGE_NT_HEADERS64 *)NT)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress) 
#else
        NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress
#endif
         == NULL && IFREE(NT))
        return Proc;

    IMAGE_EXPORT_DIRECTORY EXPORT;

    if (ReadProcessMemory(ProcessHandle, 
            ImageBase 
            + 
#ifdef _WIN64
            (bWow64Process ? 
            ((IMAGE_NT_HEADERS32 *)NT)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress 
            :
            ((IMAGE_NT_HEADERS64 *)NT)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress), 
#else
            NT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress, 
#endif
            &EXPORT, 
            sizeof(IMAGE_EXPORT_DIRECTORY), 
            NULL) == FALSE && IFREE(NT))
        return Proc;

    free(NT);

    for (DWORD i = 0; i < EXPORT.NumberOfNames; i++)
    {
        ULONG64 FunctionName = 0;
        char ch;

        if (ReadProcessMemory(ProcessHandle, ImageBase + EXPORT.AddressOfNames + i * 4, &FunctionName, 4, NULL) == FALSE)
            return Proc;
        
        FunctionName += ImageBase;

        for (DWORD j = 0; ReadProcessMemory(ProcessHandle, FunctionName + j, &ch, 1, NULL); j++)
        {
            if (ch != *(lpProcName + j))
                break;

            if (ch == NULL && *(lpProcName + j) == NULL)
            {
                WORD Ordinal;
                if (ReadProcessMemory(ProcessHandle, ImageBase + EXPORT.AddressOfNameOrdinals + i * 2, &Ordinal, sizeof(WORD), NULL) == FALSE)
                    return Proc;

                if (ReadProcessMemory(ProcessHandle, ImageBase + EXPORT.AddressOfFunctions + Ordinal * 4, &Proc, SizeOfPointer, NULL) == FALSE)
                    return Proc;

                Proc += ImageBase;
                break;
            }
            else if (ch == NULL || *(lpProcName + j) == NULL)
                break;
        }

        if (Proc)
            break;
    }

    return Proc;
}

사용예시

#include <stdio.h>
#include "Rlibloaderapi.h"

int main()
{
    DWORD PID;
    printf("PID : ");
    scanf("%d", &PID);
    
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
    
    if (hProcess == NULL)
    {
    	printf("OpenProcess Failed\n");
        printf("GetLastError : %d\n", GetLastError());
        return -1;
    }
    
    HMODULE hModule = GetRemoteModuleHandleA(hProcess, "kernel32.dll");
    FARPROC pLoadLibraryA = GetRemoteProcAddress(hProcess, hModule, "LoadLibraryA");
    
    printf("LoadLibraryA : %p\n", pLoadLibraryA);
    
    return 0;
}

#include <stdio.h>
#include "Rlibloaderapi.h"

int main()
{
    DWORD PID;
    printf("PID : ");
    scanf("%d", &PID);
    
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
    
    if (hProcess == NULL)
    {
    	printf("OpenProcess Failed\n");
        printf("GetLastError : %d\n", GetLastError());
        return -1;
    }
    
    char Modulename[MAX_PATH];
    char Functionname[64];
    
    printf("Module name : ");
    scanf("%s", Modulename);
    
    HMODULE hModule = GetRemoteModuleHandleA(hProcess, Modulename);
    
    if (hModule == NULL)
    {
    	printf("%s not found!\n");
        return -1;
    }
    
    printf("Function name : ");
    scanf("%s", Function);
    
    FARPROC Functions = GetRemoteProcAddress(hProcess, hModule, Function);
    
    printf("%s : %p\n", Function, Functions);
    
    return 0;
}

[C] Rlibloaderapi.h - GetModuleHandle

미친해커 — Thu, 17 Feb 2022 13:40:53 +0900

GetModuleHandle

GetModuleHandle 함수는 kernel32.dll와 kernelbase.dll에 정의되어있는 함수이다. 해당 함수는 현재 프로세스에 로드된 DLL 중 인자로 넣은 DLL 이름의 HMODULE을 반환하는 함수이다.

HMODULE은 과거 윈도우에서 다른 용도로 만들어졌지만 현재 윈도우에서는 DLL의 ImageBase를 담는 자료형이 되었다. 실제로 GetModuleHandle 함수를 이용해 특정 DLL의 HMODULE을 반환 받으면 해당 값은 해당 DLL의 ImageBase 인 것을 확인할 수 있다. 이 또한 현재 프로세스가 아닌 다른 프로세스에 로드된 DLL의 ImageBase를 구하기 위해 Remote 버전을 구현하게 되었다.

GetRemoteModuleHandle

HMODULE GetRemoteModuleHandleA(HANDLE ProcessHandle, LPCSTR lpModuleName)
{
    HMODULE hModule = NULL;
    LPWSTR ModuleName = NULL;
    int ModuleNameLength = MultiByteToWideChar(CP_ACP, 0, lpModuleName, -1, NULL, 0);
    ModuleName = calloc(ModuleNameLength, sizeof(wchar_t));
    MultiByteToWideChar(CP_ACP, 0, lpModuleName, -1, ModuleName, ModuleNameLength);
    hModule = GetRemoteModuleHandleW(ProcessHandle, ModuleName);
    free(ModuleName);
    return hModule;
}

HMODULE GetRemoteModuleHandleW(HANDLE ProcessHandle, LPCWSTR lpModuleName)
{
#ifdef _WIN64
    BOOL bWow64Process;
    IsWow64Process(ProcessHandle, &bWow64Process);
    size_t SizeOfPointer = bWow64Process ? 4 : 8;
#else
    size_t SizeOfPointer = 4;
#endif
    
    HMODULE hModule = NULL;
    PVOID PebBaseAddress = GetRemotePeb(ProcessHandle);

    if (PebBaseAddress == NULL)
        return hModule;

    PVOID PebLdrData = NULL;

    if (ReadProcessMemory(ProcessHandle, 
#ifdef _WIN64
            (ULONG_PTR)PebBaseAddress + (bWow64Process ? Peb_LdrOffset32 : Peb_LdrOffset64), 
#else
            (ULONG_PTR)PebBaseAddress + Peb_LdrOffset32,
#endif
            &PebLdrData, 
            SizeOfPointer, 
            NULL) == FALSE)
        return hModule;

#ifdef _WIN64
    PVOID LdrDataTableEntry = (ULONG_PTR)PebLdrData + (bWow64Process ? PebLdrData_LOMLOffset32 : PebLdrData_LOMLOffset64);
    size_t SizeOfUnicodeString = bWow64Process ? sizeof(UNICODE_STRING32) : sizeof(UNICODE_STRING64);
#else
    PVOID LdrDataTableEntry = (ULONG_PTR)PebLdrData + PebLdrData_LOMLOffset32;
    size_t SizeOfUnicodeString = sizeof(UNICODE_STRING);
#endif

    BYTE *UnicodeString = calloc(1, SizeOfUnicodeString);

    for (LPWSTR ModuleName = NULL; ReadProcessMemory(ProcessHandle, LdrDataTableEntry, &LdrDataTableEntry, SizeOfPointer, NULL) 
            && 
#ifdef _WIN64
            (ULONG_PTR)PebLdrData + (bWow64Process ? PebLdrData_LOMLOffset32 : PebLdrData_LOMLOffset64) != LdrDataTableEntry
#else
            (ULONG_PTR)PebLdrData + PebLdrData_LOMLOffset32 != LdrDataTableEntry
#endif
        ; free(ModuleName))
    {
        if (ReadProcessMemory(ProcessHandle, 
#ifdef _WIN64
                (ULONG_PTR)LdrDataTableEntry + (bWow64Process ? LdrDataTableEntry_BaseDllName32 : LdrDataTableEntry_BaseDllName64), 
#else
                (ULONG_PTR)LdrDataTableEntry + LdrDataTableEntry_BaseDllName32,
#endif
                UnicodeString, 
                SizeOfUnicodeString, 
                NULL) == FALSE)
            return hModule;

#ifdef _WIN64
        ModuleName = malloc(bWow64Process ? ((UNICODE_STRING32 *)UnicodeString)->Length + 2 : ((UNICODE_STRING64 *)UnicodeString)->Length + 2);
#else
        ModuleName = malloc(sizeof(UNICODE_STRING));
#endif
        if (ReadProcessMemory(ProcessHandle, 
#ifdef _WIN64
                bWow64Process ? ((UNICODE_STRING32 *)UnicodeString)->Buffer : ((UNICODE_STRING64 *)UnicodeString)->Buffer, 
                ModuleName,
                bWow64Process ? ((UNICODE_STRING32 *)UnicodeString)->Length + 2 : ((UNICODE_STRING64 *)UnicodeString)->Length + 2,
#else
                ((UNICODE_STRING *)UnicodeString)->Buffer,
                ModuleName, 
                ((UNICODE_STRING *)UnicodeString)->Length,
#endif
                NULL) == FALSE)
            return hModule;

        if (wcsicmp(lpModuleName, ModuleName))
            continue;

        if (ReadProcessMemory(ProcessHandle, 
#ifdef _WIN64
                (ULONG_PTR)LdrDataTableEntry + (bWow64Process ? LdrDataTableEntry_DllBase32 : LdrDataTableEntry_DllBase64), 
#else
                (ULONG_PTR)LdrDataTableEntry + LdrDataTableEntry_DllBase32,
#endif
                &hModule, 
                SizeOfPointer, // sizeof(HMODULE), 
                NULL) == FALSE && (RtlFreeHeap(_get_heap_handle(), 0, ModuleName) || TRUE))
            return hModule;

        free(ModuleName);
        break;
    }

    free(UnicodeString);
    return hModule;
}

사용예시

#include <stdio.h>
#include "Rlibloaderapi.h"

int main()
{
    DWORD PID;
    printf("PID : ");
    scanf("%d", &PID);
    
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
    
    if (hProcess == NULL)
    {
    	printf("OpenProcess Failed\n");
        printf("GetLastError : %d\n", GetLastError());
        return -1;
    }
    
    char Modulename[MAX_PATH];
    printf("Module name : ");
    scanf("%s", Modulename);
    
    printf("%s : 0x%p", Modulename, GetRemoteModuleHandleA(hProcess, Modulename));
    
    return 0;
}

[C] Rlibloaderapi.h - GetRemotePeb

미친해커 — Thu, 17 Feb 2022 13:33:12 +0900

RtlGetCurrentPeb

RtlGetCurrentPeb 함수는 ntdll.dll의 함수이다. 해당 함수는 현재 프로세스의 PEB 구조체의 주소를 반환해준다. 해당 함수 또한 현재 프로세스의 PEB 주소만 구할 수 있고 다른 프로세스의 PEB 구조체의 주소를 구하기 위해서는 NtQueryInformationProcess 라고 하는 커널 함수를 사용해야한다. (물론 해당 커널 함수를 사용해 PEB 구조체의 주소를 구해주는 다른 WINAPI도 존재한다. 하지만 내부적으로는 대부분 해당 커널 함수를 사용한다.)

물론 여기까지 윈도우 시스템에 대해서 공부한 사람이랑 그냥 커널 함수를 쓰고 말겠지만 해당 커널 함수를 사용하면 다른 정보도 같이 구해지기 때문에 불필요한 공간을 사용하게 된다. 그렇기에 해당 함수를 사용하여 정확하게 PEB 구조체의 주소만 구해주는 함수를 제작하였다.

GetRemotePeb

PVOID GetRemotePeb(HANDLE ProcessHandle)
{
    PROCESS_BASIC_INFORMATION pbi = { 0, };
    NtQueryInformationProcess(ProcessHandle, ProcessBasicInformation, &pbi, sizeof(PROCESS_BASIC_INFORMATION), NULL);
#ifdef _WIN64
    BOOL bWow64Process;
    IsWow64Process(ProcessHandle, &bWow64Process);
    return bWow64Process ? (ULONG_PTR)pbi.PebBaseAddress + 0x1000 : pbi.PebBaseAddress;
    // WOW64로 돌아가는 32bit 프로세스의 PEB 구조체의 주소는 0x1000을 더해줘야 한다. 원인은 모르겠다.
#else
    return pbi.PebBaseAddress;
#endif
}

사용예시

#include <stdio.h>
#include "Rlibloaderapi.h"

int main()
{
    DWORD PID;
    printf("PID : ");
    scanf("%d", &PID);
    
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
    
    if (hProcess == NULL)
    {
    	printf("OpenProcess Failed\n");
        printf("GetLastError : %d\n", GetLastError());
        return -1;
    }
    
    printf("PEB : 0x%p", GetRemotePeb(hProcess));
    
    return 0;
}

[C] Remote libloaderapi.h 는 무엇인가...

미친해커 — Thu, 17 Feb 2022 12:23:19 +0900

libloaderapi.h

Remote liblaoderapi.h 를 설명하기 전에 libloaderapi.h가 무엇인지 알아야한다. 아래 링크는 MSDN 공식 설명이다.

Libloaderapi.h header - Win32 apps

Table of contents Article 11/23/2021 3 minutes to read Is this page helpful? In this article --> This header is used by multiple technologies. For more information, see: libloaderapi.h contains the following programming interfaces: Functions AddDllDirec

docs.microsoft.com

간단하게 설명해서 마이크로소프트의 libloaderapi.h 파일은

와 관련된 프로그래밍 인터페이스(API)가 정의되어 있다. 이 중 시스템 서비스에 해당하는 함수들은 다음과 같다.

libloaderapi.h의 시스템 서비스 함수

위 함수들 중 대부분의 함수들은 현재 프로세스의 DLL과 관련되어 있는 함수들이다. 예를 들어 GetModuleHandleA는 로드된 DLL들 중 특정 DLL의 HMODULE을 반환하는 함수이다. 하지만 여기있는 모든 함수들은 현재 프로세스(해당 함수를 호출하는 프로세스)를 대상으로 동작하는 함수들이다.

필자는 여기서 다른 프로세스에 로드되어 있는 DLL들의 정보를 가져오고 싶었다. 물론 해당 동작을 해주는 함수들이 공식적으로 존재하지만 함수들의 동작방식이나 호출 방법 등이 마음에 들지 않아서 위의 몇몇 함수들을 직접 Remote 버전 즉 다른 프로세스를 대상으로 같은 기능을 하는 함수들을 구현하기로 결정했다.

Rlibloaderapi.h (Remote libloaderapi.h)

GitHub - jungjin0003/Remote-libloaderapi: This library is a remote version of Windows API libloaderapi.h

This library is a remote version of Windows API libloaderapi.h - GitHub - jungjin0003/Remote-libloaderapi: This library is a remote version of Windows API libloaderapi.h

github.com

Rmote 버전이 구현된 libloaderapi.h의 시스템 서비스 함수

GetModuleHandleA -> GetRemoteModuleHandleA
GetModuleHandleW -> GetRemoteModuleHandleW
GetModuleFileNameA -> GetRemoteModuleFileNameA
GetModuleFileNameW -> GetRemoteModuleFileNameW
GetProcAddress -> GetRemoteProcAddress

그 외 구현한 함수

RtlGetCurrentPeb -> GetRemotePeb
GetModuleBaseNameA -> GetRemoteModuleBaseNameA
GetModuleBaseNameW -> GetRemoteModuleBaseNameW

해당 카테고리에서는 이렇게 새롭게 구현한 함수들의 사용 예시를 올릴 예정이다.