/1. ac_client.exe 핸들 얻기
//2. ReadProcessMemory()로 0x4637E9부터 2바이트만큼 읽기
//3. 읽은 메모리가 { 0xFF, 0x0E }이면 WriteProcessMemory()로 0x4637E9부터 2바이트를 { 0x90, 0x90 }로 쓰기
//4. 게임 상에서 어떠한 점이 달라졌는지 확인하기

음...그동안 내가 짰던 코드를 이것저것 떼어와서 붙였더니 끔찍한 혼종이 되어버려따...

그러므로 3주차 과제부터는 코드를 다 새로 짜서 업로드할 예정입니당..

대략 코드 설명을 하자면 Read함수는 메모리를 읽어서 쓰는 역할이고 

스크린 샷은 main함수에서 합니다.

그럼 이만ㅎㅅㅎ..!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
#include<stdio.h>
#include<stdlib.h>
#include<wchar.h>
#include<Windows.h>
#include<tlhelp32.h>
#include <psapi.h>
#pragma comment(lib, "psapi.lib")
 
 
void Read(PROCESSENTRY32 *sub) {
    HANDLE openPro;
    SIZE_T readSize;
    BYTE buf1[3] = { 0x90, 0x90 }, buf2[20] = { 0 };
    int errCode;
    openPro = OpenProcess(PROCESS_ALL_ACCESS, FALSE, sub->th32ProcessID);
 
    ReadProcessMemory(openPro, (LPCVOID)0x4637E9, buf2, 2, &readSize);
    if (buf2[0] == 0xFF && buf2[1] == 0x0E) {
        memset(buf2, 0, sizeof(buf2));
        printf("값 바꾼 후..\n");
        WriteProcessMemory(openPro, (LPVOID)0x4637E9, buf1, 2, &readSize);
        ReadProcessMemory(openPro, (LPCVOID)0x4637E9, buf2, 2, &readSize);
        printf("\n");
        errCode = GetLastError();
        printf("errCode : %d\n", errCode);
    }
    else
        printf("Error...?\n");
}
 
int main() {
    HANDLE hProcessSnap;
    PROCESSENTRY32 processinform, sub;
    processinform.dwSize = sizeof(PROCESSENTRY32);
    sub.dwSize = sizeof(PROCESSENTRY32);
 
    hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnap == INVALID_HANDLE_VALUE)
        printf("CreateToolhelp32Snapshot error \n");
 
    if (!Process32First(hProcessSnap, &processinform)) {
        printf("Process32First error ! \n");
        CloseHandle(hProcessSnap);
        return 0;
    }
    printf("LIST> \n");
    printf("\t\t[Process name \t[PID]\t[개수]\t[부모프로세스ID] \n");
 
    do {
        wprintf(L"%25s %8d %8d %16d \n", //유니코드 출려과 아스키코드 출력은 다르므로 유니코드를 출력하는 wprintf를 사용해야함
            processinform.szExeFile, processinform.th32ProcessID, processinform.cntThreads, processinform.th32ParentProcessID);
    } while (Process32Next(hProcessSnap, &processinform));
 
 
    printf("프로세스 이름 입력 :");
    memset(&sub, 0, sizeof(sub));
    wscanf(L"%[^\n]s", &sub.szExeFile);  //%[^\n]s : 개행이 오기전까지 입력받음
    CloseHandle(hProcessSnap);
    hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnap == INVALID_HANDLE_VALUE)
        printf("CreateToolhelp32Snapshot error \n");
 
    if (!Process32First(hProcessSnap, &processinform)) {
        printf("Process32First error ! \n");
        CloseHandle(hProcessSnap);
        return 0;
    }
    while (Process32Next(hProcessSnap, &processinform)) {
        if (!wcscmp(sub.szExeFile, processinform.szExeFile)) {
            sub.th32ProcessID = processinform.th32ProcessID;
            sub.cntThreads = processinform.cntThreads;
            sub.th32ParentProcessID = processinform.th32ParentProcessID;
            printf("\t\t[Process name] \t[PID]\t[개수]\t[부모프로세스 ID] \n");
            wprintf(L"%25s %8d %8d %16d \n", //유니코드 출려과 아스키코드 출력은 다르므로 유니코드를 출력하는 wprintf를 사용해야함
                sub.szExeFile, sub.th32ProcessID, sub.cntThreads, sub.th32ParentProcessID);
            Read(&sub);
        }
    }
    CloseHandle(hProcessSnap);
 
    return 0;
}
 
cs


'@안티치트' 카테고리의 다른 글

프로세스 메모리 읽고 쓰기(ASLR)  (0) 2018.10.05
다른 프로세스의 메모리 읽기  (0) 2018.10.05
프로세스 메모리 읽어오기  (0) 2018.10.05
START!  (0) 2018.10.05

-2018 - 10 - 6 ~(P3)-프로세스 메모리 읽고 쓰기


1. 프로세스 자기 자신의 base address(0x00400000)부터 10바이트만큼 읽어서 출력

2. TlHelp32.h 내부의 함수를 이용해 PID, base address를 얻는 함수 정의

3. ASLR 옵션이 적용된 프로세스의 base address + 0x108E부터 6바이트만큼 읽어서 출력

4. base address + 0x108E부터 2바이트를{ 0x00, 0xEB }로 쓰기

5. base address + 0x108E부터 6바이트만큼 읽어서 출력



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include<stdio.h>
#include<stdlib.h>
#include<wchar.h>
#include<Windows.h>
#include<tlhelp32.h>
#include <psapi.h>
#pragma comment(lib, "psapi.lib")
 
void GetBaseAddressByName(PROCESSENTRY32 *sub)
{
    unsigned char buf1[] = { 0x00, 0xEB };
    unsigned char buf2[20] = { 0 }, bs[10] = { 0 };
    int errCode;
    SIZE_T readSize;
 
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS,FALSE, sub->th32ProcessID);
 
    if (NULL != hProcess)
    {
        HMODULE hMod;
        //HINSTANCE 핸들은 보통 실행되고 있는 Win32 프로그램의 메모리 상에 올라가 있는 시작 주소값을 갖고 있음
        DWORD cbNeeded;
 
        if (EnumProcessModulesEx(hProcess, &hMod, sizeof(hMod),&cbNeeded,LIST_MODULES_64BIT))
            //EnumProcessModulesEx : 지정된 필터 조건을 충족시키는 지정된 프로세스의 각 모듈에 대한 핸들을 검색
        {
            GetModuleBaseName(hProcess, hMod, sub->szExeFile,sizeof(sub->szExeFile) / sizeof(TCHAR));
            //GetModuleBaseName : 지정된 모듈의 기본 이름을 검색
            //GetModuleBaseName 함수는 주로 디버거 및 다른 프로세스에서 모듈 정보를 추출해야하는 유사한 응용 프로그램에서 사용하도록 설계됨
                wprintf(TEXT("Base address : 0x%p\n"), hMod);
 
                printf("값 바꾸기 전..\n");
                ReadProcessMemory(hProcess, hMod + 0x108E, buf2, 6, &readSize);
                printf("%u byte read!\n", readSize);
                for (int i = 0; i < 6; i++) {
                    printf("%#02x ", buf2[i]);
                }
                printf("\n");
                memset(buf2, 0, sizeof(buf2));
 
                printf("값 바꾼 후..\n");
                WriteProcessMemory(hProcess, (LPVOID)((int)hMod + 0x108E), buf1, 2, &readSize);
                printf("WriteProcessMemory error code : %d\n", GetLastError());
 
                printf("%u byte write!\n", readSize);
                ReadProcessMemory(hProcess, (LPCVOID)((int)hMod + 0x108E), buf2, 6, &readSize);
                printf("ReadProcessMemory error code : %d\n", GetLastError());
                printf("%u byte read!\n", readSize);
                for (int i = 0; i < 6; i++) {
                    printf("%#02x ", buf2[i]);
                }
                printf("\n");
                errCode = GetLastError();
                printf("errCode : %d\n", errCode);
        }
    }
 
    CloseHandle(hProcess);
}
 
int main() {
    HANDLE hProcessSnap;
    PROCESSENTRY32 processinform, sub;
    processinform.dwSize = sizeof(PROCESSENTRY32);
    sub.dwSize = sizeof(PROCESSENTRY32);
 
    hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnap == INVALID_HANDLE_VALUE)
        printf("CreateToolhelp32Snapshot error \n");
 
    if (!Process32First(hProcessSnap, &processinform)) {
        printf("Process32First error ! \n");
        CloseHandle(hProcessSnap);
        return 0;
    }
    printf("LIST> \n");
    printf("\t\t[Process name \t[PID]\t[개수]\t[부모프로세스ID] \n");
 
    do {
        wprintf(L"%25s %8d %8d %16d \n", //유니코드 출려과 아스키코드 출력은 다르므로 유니코드를 출력하는 wprintf를 사용해야함
            processinform.szExeFile, processinform.th32ProcessID, processinform.cntThreads, processinform.th32ParentProcessID);
    } while (Process32Next(hProcessSnap, &processinform));
 
 
    printf("프로세스 이름 입력 :");
    memset(&sub, 0, sizeof(sub));
    wscanf(L"%[^\n]s", &sub.szExeFile);  //%[^\n]s : 개행이 오기전까지 입력받음
    CloseHandle(hProcessSnap);
    hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnap == INVALID_HANDLE_VALUE)
        printf("CreateToolhelp32Snapshot error \n");
 
    if (!Process32First(hProcessSnap, &processinform)) {
        printf("Process32First error ! \n");
        CloseHandle(hProcessSnap);
        return 0;
    }
    while (Process32Next(hProcessSnap, &processinform)) {
        if (!wcscmp(sub.szExeFile, processinform.szExeFile)) {
            sub.th32ProcessID = processinform.th32ProcessID;
            sub.cntThreads = processinform.cntThreads;
            sub.th32ParentProcessID = processinform.th32ParentProcessID;
            printf("\t\t[Process name] \t[PID]\t[개수]\t[부모프로세스 ID] \n");
            wprintf(L"%25s %8d %8d %16d \n", //유니코드 출려과 아스키코드 출력은 다르므로 유니코드를 출력하는 wprintf를 사용해야함
                sub.szExeFile, sub.th32ProcessID, sub.cntThreads, sub.th32ParentProcessID);
            GetBaseAddressByName(&sub);
        }
    }
    CloseHandle(hProcessSnap);
 
    return 0;
}
cs


ASLR가 걸려있는 프로그램은 계속 변하는 베이스 어드레스를 찾기위해 조금 다른 함수가 쓰였다...

코드에서 확인><

'@안티치트' 카테고리의 다른 글

실제 프로그램에 적용해보기(메모리 읽고 쓰기)  (0) 2018.11.05
다른 프로세스의 메모리 읽기  (0) 2018.10.05
프로세스 메모리 읽어오기  (0) 2018.10.05
START!  (0) 2018.10.05

  - 2018-03-17 ~ (P2) - 다른 프로세스의 메모리 읽기

1. 다른 프로세스(Cpp_AnotherProcess.exe)의 핸들 얻기

1-1 TlHelp32.h

1) CreateToolhelp32Snapshot(), Process32First(), Process32Next()로 pId 얻기

2) OpenProcess()로 핸들 얻기

※특정 프로세스의 핸들을 얻는 다른 방법 찾아보기

2. ReadProcessMemory()로 0x40108B부터 6바이트만큼 읽어서 버퍼에 저장

3. 버퍼 출력


프로그램의 기능은 이렇다

//1. 현재 돌아가는 프로그램의 모든 스냅샷 출력

//2. 메모리를 읽고싶은 프로그램 입력

//3. WriteProcessMemory()로 0x40108E부터 2바이트를 {0x00,0xEB}로 쓰기

//4. ReadProcessMemory()로 0x40108E부터 6바이트를 읽어서 버퍼에저장, 출력



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#include<stdio.h>
#include<stdlib.h>
#include<wchar.h>
#include<Windows.h>
#include<tlhelp32.h>
 
 
void Read(PROCESSENTRY32 *sub) {
    HANDLE openPro;
    SIZE_T readSize;
    int buf1[3] = { 0x00,0xEB }, buf2[20] = { 0 };
    int errCode;
    openPro = OpenProcess(PROCESS_ALL_ACCESS, FALSE, sub->th32ProcessID);
 
    printf("값 바꾸기 전..\n");
    ReadProcessMemory(openPro, (LPCVOID)0x40108E, buf2, 6, &readSize);
    for (int i = 0; i < 6; i++) {
        printf("%#02x ", buf2[i]);
    }
    printf("\n");
    memset(buf2, 0, sizeof(buf2));
 
    printf("값 바꾼 후..\n");
    WriteProcessMemory(openPro, (LPVOID)0x40108E, buf1, 2, &readSize);
    ReadProcessMemory(openPro, (LPCVOID)0x40108E, buf2, 6, &readSize);
    for (int i = 0; i < 6; i++) {
        printf("%#02x ", buf2[i]);
    }
    printf("\n");
    errCode = GetLastError();
    printf("errCode : %d\n", errCode);
}
 
int main() {
    HANDLE hProcessSnap;
    PROCESSENTRY32 processinform,sub;
    processinform.dwSize = sizeof(PROCESSENTRY32);
    sub.dwSize = sizeof(PROCESSENTRY32);
 
    hProcessSnap=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnap == INVALID_HANDLE_VALUE) 
        printf("CreateToolhelp32Snapshot error \n");
 
    if (!Process32First(hProcessSnap, &processinform)) {
        printf("Process32First error ! \n");
        CloseHandle(hProcessSnap);
        return 0;
    }
    printf("LIST> \n");
    printf("\t\t[Process name \t[PID]\t[개수]\t[부모프로세스ID] \n");
 
    do {
        wprintf(L"%25s %8d %8d %16d \n", //유니코드 출려과 아스키코드 출력은 다르므로 유니코드를 출력하는 wprintf를 사용해야함
            processinform.szExeFile, processinform.th32ProcessID, processinform.cntThreads, processinform.th32ParentProcessID);
    } while (Process32Next(hProcessSnap, &processinform));
 
 
    printf("프로세스 이름 입력 :");
    memset(&sub, 0, sizeof(sub));
    wscanf(L"%s",&sub.szExeFile);
    CloseHandle(hProcessSnap);
    //이미 앞에서 한번 더 읽어줬기 때문에 이전의 핸들을 반환하고 다시 새로운 핸들을 생성해야한다
    hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnap == INVALID_HANDLE_VALUE)
        printf("CreateToolhelp32Snapshot error \n");
 
    if (!Process32First(hProcessSnap, &processinform)) {
        printf("Process32First error ! \n");
        CloseHandle(hProcessSnap);
        return 0;
    }
    while (Process32Next(hProcessSnap, &processinform)) {
        if (!wcscmp(sub.szExeFile, processinform.szExeFile)) {
            sub.th32ProcessID = processinform.th32ProcessID;
            sub.cntThreads = processinform.cntThreads;
            sub.th32ParentProcessID = processinform.th32ParentProcessID;
            printf("\t\t[Process name] \t[PID]\t[개수]\t[부모프로세스 ID] \n");
            wprintf(L"%25s %8d %8d %16d \n", //유니코드 출려과 아스키코드 출력은 다르므로 유니코드를 출력하는 wprintf를 사용해야함
                sub.szExeFile, sub.th32ProcessID, sub.cntThreads, sub.th32ParentProcessID);
            Read(&sub);
        }
    }
    CloseHandle(hProcessSnap);
 
    return 0;
}
 
cs



CreateToolhelp32Snapshot()

지정된 프로세스뿐만 아니라 이러한 프로세스가 사용하는 힙, 모듈 및 스레드의 스냅 샷을 가져옵니다.

1
HANDLE CreateToolhelp32Snapshot( DWORD dwFlags, DWORD th32ProcessID );

cs


매개변수
DWORD dwFlags : 상황에 따라 많음

DWORD th32ProcessID :스냅 샷에 포함될 프로세스의 프로세스 식별자. 이 매개 변수는 현재 프로세스를 나타내는 0 일 수 있음

추가의 내용이 많으니 링크를 ! 

https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-createtoolhelp32snapshot



Process32First()

시스템 스냅 샷에서 발생한 첫 번째 프로세스에 대한 정보를 검색

1
BOOL Process32First( HANDLE hSnapshot, LPPROCESSENTRY32 lppe );

cs


매개변수

HANDLE hSnapshot : CreateToolhelp32Snapshot() 함수에 대한 이전 호출에서 반환 된 스냅 샷 핸들입니다.

LPPROCESSENTRY32 lppe :  processentry32 구조체에 대한 포인터. 실행 파일의 이름, 프로세스 식별자 및 상위 프로세스의 프로세스 ID와 같은 프로세스 정보를 포함합니다.( 구조체의 사이즈는 deSize로 해야함)

프로세스 목록의 첫 번째 항목이 버퍼에 복사 된 경우 TRUE를 반환하고 그렇지 않으면 FALSE를 반환


Process32Next()

시스템 스냅 샷에 기록 된 다음 프로세스에 대한 정보를 검색합니다.

1
BOOL Process32Next( HANDLE hSnapshot, LPPROCESSENTRY32 lppe );
cs
매개변수
Process32First()와 기능은 비슷 링크를 ! 
https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-process32next



ReadProcessMemory()

지정된 프로세스에서 메모리 영역에서 데이터를 읽습니다. 읽을 전체 영역에 액세스하거나 작업이 실패합니다.

1
2
3
4
5
6
7
8
BOOL WINAPI ReadProcessMemory(
  _In_  HANDLE  hProcess,
  _In_  LPCVOID lpBaseAddress,
  _Out_ LPVOID  lpBuffer,
  _In_  SIZE_T  nSize,
  _Out_ SIZE_T  *lpNumberOfBytesRead
);
 
cs

매개변수

hProcess : 읽히는 메모리가 있는 프로세스에 대한 핸들입니다. 핸들은 프로세스에 대한 PROCESS_VM_READ 액세스 권한이 있어야 합니다.


lpBaseAddress : 읽을 지정된 프로세스의 기본 주소에 대한 포인터 


IpBuffer :지정된 프로세스의 주소 공간으로부터 내용을 수신하는 버퍼에 대한 포인터


nSize : 지정된 프로세스에서 읽을 바이트 수


lpNumberOfBytesRead : 지정된 버퍼로 전송된 바이트 수를 수신하는 변수에 대한 포인터


링크 ! https://msdn.microsoft.com/ko-kr/library/windows/desktop/ms680553(v=vs.85).aspx


WriteProcessMemory()

지정된 프로세스의 메모리 영역에 데이터를 기록합니다. 기록할 전체 영역에 액세스해야 합니다. 그렇지 않으면 작업이 실패합니다.


1
2
3
4
5
6
7
BOOL WINAPI WriteProcessMemory(
  _In_  HANDLE  hProcess,
  _In_  LPVOID  lpBaseAddress,
  _In_  LPCVOID lpBuffer,
  _In_  SIZE_T  nSize,
  _Out_ SIZE_T  *lpNumberOfBytesWritten
);
cs

ReadProcessMemory()와 거의 비슷... 링크를!

https://msdn.microsoft.com/ko-kr/library/windows/desktop/ms681674(v=vs.85).aspx


'@안티치트' 카테고리의 다른 글

실제 프로그램에 적용해보기(메모리 읽고 쓰기)  (0) 2018.11.05
프로세스 메모리 읽고 쓰기(ASLR)  (0) 2018.10.05
프로세스 메모리 읽어오기  (0) 2018.10.05
START!  (0) 2018.10.05

- 2018-03-10 ~ (P1) - 프로세스 자신의 메모리 읽기

1. 프로세스 자기 자신의 핸들 얻기

1-1 GetCurrentProcess()로 핸들 얻기

1-2  1) GetCurrentProcessId()로 pId 얻기

         2) OpenProcess()로 핸들 얻기


2. ReadProcessMemory()로 base address(0x00400000)부터 10바이트만큼 읽어서 버퍼에 저장

3. 버퍼 출력

※ x86 빌드, ASLR off



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include<stdio.h>
#include<Windows.h>
#include<stdlib.h>
int main() {
    HANDLE handle1,openPro;
    int processId, buf[20] = { 0 };
    int errCode;
    SIZE_T readSize;
    DuplicateHandle(GetCurrentProcess(), GetCurrentProcess(), GetCurrentProcess(),
        &handle1, 0, TRUE, DUPLICATE_SAME_ACCESS);
    //DuplicateHandle : 현재 프로세스의 진짜 핸들을 얻는 함수 . handel1에 핸들이 들어가게 됨
    processId = GetCurrentProcessId(); //GetCurrentProcessId : 리턴 값은 호출 프로세스의 프로세스 ID
    openPro = OpenProcess(PROCESS_ALL_ACCESS,FALSE, processId); 
//OpenProcess : 프로세스 핸들 얻어오는 함수
    ReadProcessMemory(handle1,(LPCVOID)0x400000,buf,10,&readSize);
    //ReadProcessMemory()로 base address(0x00400000)부터 10바이트만큼 읽어서 버퍼에 저장
    errCode = GetLastError();
    printf("%d\n", errCode);
    printf("Handle(GetCurrentProcess): %d\n", handle1);
    printf("Handle(OpenProcess): %d\n", openPro);
    printf("ProcessId(GetCurrentProcessId): %d\n", processId);
    printf("ReadProcessMemory read size : %d \n", readSize);
    printf("읽은 10바이트: ");
    for (int i = 0; i < 10; i++) {
        printf("%#02x ", buf);
    }
    return 0;
}
cs


GetCurrentProcess()

HANDLE WINAPI GetCurrentProcess(void);

현재 실행되고 있는 프로세스(위의 함수를 호출한 프로세스)의 핸들을 반환값을 통해 얻을수있다.

GetCurrentProcess() 함수로 구하는 핸들은 가짜(Pseudo) 핸들이다.

핸들 테이블에 등록되지 않은 핸들이다. 이 함수에서 반환되는 핸들은 현재 실행중인 프로세스를 참조하기 위한 용도로

정의해 놓은 상수가 반환된다. 



DuplicateHandle()

현재 프로세스의 진짜 핸들을 얻고 싶다면 이 함수를 사용하면 된다.

1
2
3
4
5
6
7
8
9
10
11
BOOL WINAPI DuplicateHandle
( _In_   HANDLE hSourceProcessHandle, //복제할 핸들을 소유하는 프로세스
  _In_   HANDLE hSourceHandle, //복제할 핸들 _In_   
  HANDLE hTargetProcessHandle, //복제된 핸들을 소유할 프로세스
  _Out_  LPHANDLE lpTargetHandle, //복제된 핸들값을 저장한 변수의 주소 
  _In_   DWORD dwDesiredAccess, //복제할 핸들의 접근권한 
  _In_   BOOL bInheritHandle, //복제할 핸들의 상속여부 
  _In_   DWORD dwOptions //옵션 );
 
 
 
cs


사용법


1
2
3
4
5
HANDLE hProcess;
 
DuplicateHandle(GetCurrentProcess(),GetCurrentProcess(),GetCurrentProcess(),
 
&hProcess,0,TRUE,DUPLICATE_SAME_ACCESS);
cs


출처: http://hypen1117.tistory.com/entry/DuplicateHandle-현재-프로세스의-진짜-핸들을-얻는-함수 [For the]








'@안티치트' 카테고리의 다른 글

실제 프로그램에 적용해보기(메모리 읽고 쓰기)  (0) 2018.11.05
프로세스 메모리 읽고 쓰기(ASLR)  (0) 2018.10.05
다른 프로세스의 메모리 읽기  (0) 2018.10.05
START!  (0) 2018.10.05

솔직히...안티치트는 시작한지 오래되었다ㅎㅎ....

2018년도 초부터 시작했는데 그때에는 막 프로그래밍을 시작하고 고등학교 생활을 시작하던 시기여서 나에게 마음의 여유가 없었나 보다. 한달 정도 후에 연구회를 나왔고 2학기가 시작한 후 다시 들어가서 활동하게 되었다!

평소 리버싱과 같은 프로그램 분석하는 것을 흥미있어 했는데 안티치트에서 연구하는 것들이 나에게 잘 맞는거 같고 프로그래밍 실력에도 도움이 되는것 같아서 열심히 해볼 생각이다. 오늘은 늦었으니 이만--!

프로그램 짠것들은 내일부터 올려야지ㅎㅅㅎ

'@안티치트' 카테고리의 다른 글

실제 프로그램에 적용해보기(메모리 읽고 쓰기)  (0) 2018.11.05
프로세스 메모리 읽고 쓰기(ASLR)  (0) 2018.10.05
다른 프로세스의 메모리 읽기  (0) 2018.10.05
프로세스 메모리 읽어오기  (0) 2018.10.05

+ Recent posts

티스토리툴바