이는 `75 tokens/sec`를 산출하며, 로컬 AI에서 꽤 빠른 속도입니다.

## 하드웨어가 없으세요? 문제없습니다

하드웨어를 사용할 수 없거나 설정에 어려움이 있지만, 이 튜토리얼을 따라가고 싶다면 OpenRouter 로그인을 받아 무료 API 중 하나를 사용할 수 있습니다:
https://openrouter.ai/models/?q=free

Google은 현재 (한정된 기간 동안) `Gemma 4 31B`와 `Gemma 4 26B-A4B`를 무료로 제공하고 있습니다:
https://openrouter.ai/google/gemma-4-31b-it:free
https://openrouter.ai/google/gemma-4-26b-a4b-it:free

... 다만 이러한 무료 API는 느리고 신뢰할 수 없으며, 보내는 모든 데이터가 내부 분석에 기록되어 다음 학습 실행에 사용될 가능성이 높다는 점을 명심하세요. 그래도 이 튜토리얼의 목적상, 이 API를 사용하면 따라갈 수 있을 것입니다.

Ghidra 플러그인이 OpenRouter 로그인을 사용하도록 구성하려면 플러그인 설정을 열고 다음을 입력하십시오:```
Base URL: https://openrouter.ai/api/
API Key: <your OpenRouter API Key>
Model Name: qwen/qwen3-235b-a22b-2507

`ghidraRun.bat`을 실행하여 Ghidra를 엽니다. 툴바에서 `File -> New Project`를 선택하고, `Non-Shared Project`를 선택한 상태로 두고 `Next >>`를 클릭한 다음, 빈 프로젝트 디렉터리를 선택하고 프로젝트 이름을 지정합니다. 그런 다음 `Finish`를 클릭합니다.

다음으로, `File -> Import File`을 클릭한 다음 `crackmepls.exe`를 선택하여 프로젝트에 추가합니다. Ghidra가 파일에 대한 세부 정보를 팝업으로 표시하며, 파일이 `windows`용 `x86:LE:64:default:windows`용 `Portable Executable (PE)` 파일임을 알려줍니다. 아무것도 변경하지 않고 `OK`를 클릭하여 수락합니다. 잠시 지연된 후 파일에 대한 추가 세부 정보가 다시 팝업되며, 다시 `OK`를 클릭하여 수락합니다. 마지막으로 프로젝트에서 `crackmepls.exe`를 더블 클릭하여 Code Browser를 열고 디스어셈블을 시작합니다.

가장 처음에 Ghidra가 `crackmepls.exe가 아직 분석되지 않았습니다. 지금 분석하시겠습니까?`라는 메시지를 표시합니다. `예`를 클릭한 다음 다음 창에서 `Analyze` 버튼을 클릭하고, Ghidra가 바이너리의 모든 함수를 찾아 디스어셈블하고 디컴파일할 때까지 기다립니다. 분석 중 PDB 파일을 찾을 수 없다는 오류가 한두 번 발생할 수 있습니다. `확인`을 클릭하고 무시하면 됩니다.

Ghidra가 파일 분석을 완료하면 아래와 같은 화면이 표시됩니다:

![alt text](https://assets.kitploit.com/production/public/readmes/13760/2be69c6e539fa74e1ac31eec4304bcd7e8952ba96b91fab51add36ed6c1440ee.png "Program Entry")

이것은 일반적인 MSVC 진입점입니다. `FUN_14000200c`를 더블 클릭하고 아래로 스크롤합니다.

디컴파일러 창에서 `__p___argv`, `__p___argc`에 대한 참조와 이들을 매개변수로 받는 함수 호출 `FUN_140001290`이 표시됩니다. 이는 크랙미의 `main()` 함수일 가능성이 높으므로 더블 클릭합니다.

![alt text](https://assets.kitploit.com/production/public/readmes/13760/577b01a818727ee43010a24d03236157d22a69f94599f4117420436a641745ac.png "Finding Main")

함수 `FUN_140001290`에 들어가면 디컴파일러 창에서 아래로 약간 스크롤합니다. 문자열 `User:` 및 `Pass:`에 대한 문자열 참조와 함께 `basic_istream` (입력 스트림) 및 `basic_ostream` (출력 스트림)에 대한 참조가 표시됩니다.

![alt text](https://assets.kitploit.com/production/public/readmes/13760/dda6baaa2d284402bd8ce61c776810a0c154c6861e0012a56391fccbeb71a0c5.png "Print and inputs")

이 문자열들은 크랙미를 처음 실행했을 때 본 출력 및 입력 문과 일치하므로, 우리는 크랙미의 `main()` 함수에 있다는 것을 알 수 있습니다.

이 시점에서 우리는 실제로 앉아서 모든 변수 이름과 함수 호출을 의미 있는 이름으로 바꾸고, 바이너리가 무엇을 하는지 분석하여 크랙미를 풀어야 하는 지루한 작업이 시작됩니다. 리버스 엔지니어들은 예전에는 디스어셈블리에서 이 작업을 수동으로 해야 했지만, 다행히도 기술과 세금 덕분에 AI와 함께 스크립팅할 수 있는 편리한 디컴파일러가 생겼습니다.

따라서 실제 작업을 하는 대신 편안히 앉아 뇌를 끄고 로컬 AI가 모든 작업을 대신하도록 합시다.

이 튜토리얼 설정 중에 함수 및 변수 이름 바꾸기를 돕는 Ghidra 플러그인을 설치했어야 합니다. 이제 이 플러그인을 사용할 때입니다. Ghidra의 상단 툴바에서 `Window`를 클릭한 다음 `Fast AI Renamer`를 클릭하여 플러그인을 엽니다.

![alt text](https://assets.kitploit.com/production/public/readmes/13760/7511b88d33bb13e45a830295f42d1fceda2eb5897beffbec6ca5e6a3bd52f46e.png "Open Fast AI Renamer")

플러그인 UI가 표시됩니다. 여러 버튼과 텍스트 영역이 있습니다. "Config" 버튼을 클릭하여 시작한 다음, 로컬 AI와 통신하기 위해 모든 것이 올바르게 구성되었는지 확인합니다. 제 컴퓨터에서의 설정은 다음과 같습니다:

![alt text](https://assets.kitploit.com/production/public/readmes/13760/4807636497952b764fc6dad362d0defc2804df0d5ba353c6938e266864c676cc.png "Config")

"Save"를 클릭하여 구성 창을 닫은 다음 `Rename Variables` 버튼을 클릭합니다. 용이 있는 진행 창이 팝업되고, 컴퓨터가 로컬 AI 모델을 실행하여 디컴파일러 창의 모든 변수 이름을 바꾸기 위해 작업하면서 힘을 내는 소리가 들릴 수 있습니다:

![alt text](https://assets.kitploit.com/production/public/readmes/13760/1f9e6ac902cce19f63319621adaabef504ad5a94fa84db2ec39782b74e2f18f6.png "Rename Variables")

AI가 완료되면 (제 컴퓨터에서 약 10~20초 소요) 플러그인의 텍스트 영역에 이름이 바뀐 변수에 대한 설명이 표시되고, 디컴파일러 창에서 변수 이름이 변경되어 표시됩니다:

![alt text](https://assets.kitploit.com/production/public/readmes/13760/3454e5e42d7a4d84dffffbc6343e9579d33b3241b42e0be06bdb068eb91ed1e3.png "Rename Results")

모든 AI 모델, 특히 작은 로컬 모델은 본질적으로 신뢰할 수 없으므로 이 마지막 단계에서 오류가 발생할 수 있습니다. 이에 대해서는 나중에 다시 다루겠습니다. 그동안 `Rename Variables` 버튼을 다시 클릭하여 AI를 다시 실행할 수 있으며, 오류 없이 만족스러운 결과가 나올 때까지 실행할 수 있습니다.

## 크랙미 풀기

이 시점에서 우리는 모든 변수 이름이 의미 있는 이름으로 변경된 깔끔한 디컴파일러 출력을 얻었습니다. 전통적으로 리버스 엔지니어는 이제 이 코드를 읽고 크랙미에 대한 해결책을 작성하기 시작할 수 있습니다. 그러나 로컬 AI가 우리 대신 크랙미를 풀도록 시도하는 것이 흥미로울 것 같다고 생각했습니다. 기억하세요, 오늘은 우리의 두뇌를 사용하지 않을 것입니다.

먼저, AI가 `Rename ALL Functions and Variables` 버튼을 클릭하여 전체 바이너리에 대한 마크업을 완료하도록 했습니다. 이렇게 하면 이 크랙미 함수에서 사용되는 모든 함수 호출에 이름이 할당되어 디컴파일러 출력이 더욱 깔끔해집니다. 제 컴퓨터에서 이 작업은 약 15분이 걸립니다.

`로컬 AI 설정` 아래에 나열된 CLI 매개변수와 함께 `llama.cpp`를 사용하는 경우, 브라우저에서 [http://localhost:8090/](http://localhost:8090/)로 이동하여 로컬 모델에 대한 채팅 UI를 열 수 있습니다.

여기에서 크랙미 함수의 디컴파일러 출력을 입력했습니다 (플러그인 UI에서 "Decompile Function" 버튼을 클릭하거나 오른쪽 디컴파일러 창에서 직접 복사하여 얻을 수 있음) 그리고 AI에게 우리를 위한 해결책을 코딩해 달라고 요청했습니다:

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


크랙미 해결책 작성을 도와주세요. 아래는 크랙미의 함수 디컴파일러 목록입니다. 사용자가 사용자 이름과 암호를 입력한 후 올바른 암호를 제공하면 액세스가 허용됩니다. 암호는 함수 내에서 계산됩니다.```


/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
/* **Reasoning:**
   The function takes user input (a username/input and a password) via standard input. It processes
   the user input by calculating a complex, custom checksum/hash. It then compares the provided
   password input against a target buffer (likely a stored hash or secret). Finally, it determines
   and outputs whether "Access granted" or "Access denied," indicating the function serves as an
   authentication routine. */

undefined8 authenticate_user(undefined8 param_1,undefined8 param_2,undefined8 max_len)

{
  uint user_checksum;
  int iVar1;
  undefined8 ****temp_free_ptr;
  ulonglong user_input_byte_index;
  char *result_message;
  undefined1 *status_buffer;
  undefined8 ****data_buffer_ptr;
  ulonglong pass_input_length_1;
  bool access_granted;
  undefined8 uStack_d0;
  undefined1 status_buffer_small [8];
  undefined1 status_buffer_large [32];
  undefined8 ***allocated_ptrs [2];
  size_t compare_length;
  ulonglong ptr_metadata_size;
  undefined8 ***user_input_buffer;
  undefined8 uStack_78;
  ulonglong user_input_length;
  ulonglong user_input_length_param;
  undefined8 ***pass_input_buffer;
  undefined8 uStack_58;
  size_t pass_input_length;
  ulonglong pass_input_length_param;
  ulonglong checksum_seed;
  code *code_pointer;
  undefined8 ***pass_input_buffer_ptr;
  undefined8 ***user_input_buffer_ptr;
  ulonglong user_input_length_1;
  
  status_buffer = status_buffer_small;
  checksum_seed = MAGIC_VALUE_1 ^ (ulonglong)status_buffer_small;
  user_input_byte_index = 0;
  uStack_78 = 0;
  user_input_length = 0;
  user_input_length_param = 0xf;
  user_input_buffer = (undefined8 ****)0x0;
  uStack_58 = 0;
  pass_input_length = 0;
  pass_input_length_param = 0xf;
  pass_input_buffer = (undefined8 ****)0x0;
  formatted_string_output((basic_ostream<char,struct_std::char_traits<char>_> *)cout_exref,"User: ");
  extract_token_from_stream((basic_istream<char,struct_std::char_traits<char>_> *)cin_exref,
                (longlong *)&user_input_buffer,max_len);
  formatted_string_output((basic_ostream<char,struct_std::char_traits<char>_> *)cout_exref,"Pass: ");
  extract_token_from_stream((basic_istream<char,struct_std::char_traits<char>_> *)cin_exref,
                (longlong *)&pass_input_buffer,max_len);
  user_input_length_1 = user_input_length_param;
  user_input_buffer_ptr = user_input_buffer;
  user_checksum = 0;
  pass_input_length_1 = user_input_byte_index;
  if (user_input_length != 0) {
    do {
      temp_free_ptr = &user_input_buffer;
      if (0xf < user_input_length_param) {
        temp_free_ptr = (undefined8 ****)user_input_buffer;
      }
      user_checksum =
           ((int)user_input_byte_index + 1) *
           (int)*(char *)((longlong)temp_free_ptr + user_input_byte_index) +
           (int)pass_input_length_1;
      user_checksum = user_checksum * 8 ^ user_checksum;
      user_input_byte_index = user_input_byte_index + 1;
      pass_input_length_1 = (ulonglong)user_checksum;
    } while (user_input_byte_index < user_input_length);
  }
  int_to_string_dynamic(allocated_ptrs,user_checksum * 0x539 ^ 0x5a5a);
  pass_input_length_1 = pass_input_length_param;
  pass_input_buffer_ptr = pass_input_buffer;
  temp_free_ptr = &pass_input_buffer;
  if (0xf < pass_input_length_param) {
    temp_free_ptr = (undefined8 ****)pass_input_buffer;
  }
  data_buffer_ptr = allocated_ptrs;
  if (0xf < ptr_metadata_size) {
    data_buffer_ptr = (undefined8 ****)allocated_ptrs[0];
  }
  if (compare_length == pass_input_length) {
    if (compare_length == 0) {
      access_granted = true;
    }
    else {
      iVar1 = memcmp(data_buffer_ptr,temp_free_ptr,compare_length);
      access_granted = iVar1 == 0;
    }
  }
  else {
    access_granted = false;
  }
  if (0xf < ptr_metadata_size) {
    temp_free_ptr = (undefined8 ****)allocated_ptrs[0];
    status_buffer = status_buffer_small;
    if (0xfff < ptr_metadata_size + 1) {
      temp_free_ptr = (undefined8 ****)allocated_ptrs[0][-1];
      data_buffer_ptr =
           (undefined8 ****)((longlong)allocated_ptrs[0] + (-8 - (longlong)temp_free_ptr));
      status_buffer = status_buffer_small;
      if ((undefined8 ****)0x1f < data_buffer_ptr) {
        code_pointer = (code *)swi(0x29);
        (*code_pointer)(5);
        temp_free_ptr = data_buffer_ptr;
        status_buffer = status_buffer_large;
      }
    }
    *(undefined8 *)(status_buffer + -8) = 0x140001424;
    free(temp_free_ptr);
  }
  result_message = "Access granted\n";
  if (!access_granted) {
    result_message = "Access denied\n";
  }
  *(undefined8 *)(status_buffer + -8) = 0x140001443;
  formatted_string_output((basic_ostream<char,struct_std::char_traits<char>_> *)cout_exref,result_message);
  if (0xf < pass_input_length_1) {
    temp_free_ptr = (undefined8 ****)pass_input_buffer_ptr;
    if (0xfff < pass_input_length_1 + 1) {
      temp_free_ptr = (undefined8 ****)pass_input_buffer_ptr[-1];
      data_buffer_ptr =
           (undefined8 ****)((longlong)pass_input_buffer_ptr + (-8 - (longlong)temp_free_ptr));
      if ((undefined8 ****)0x1f < data_buffer_ptr) {
        code_pointer = (code *)swi(0x29);
        (*code_pointer)(5);
        status_buffer = status_buffer + 8;
        temp_free_ptr = data_buffer_ptr;
      }
    }
    *(undefined8 *)(status_buffer + -8) = 0x14000147d;
    free(temp_free_ptr);
  }
  if (0xf < user_input_length_1) {
    temp_free_ptr = (undefined8 ****)user_input_buffer_ptr;
    if (0xfff < user_input_length_1 + 1) {
      temp_free_ptr = (undefined8 ****)user_input_buffer_ptr[-1];
      data_buffer_ptr =
           (undefined8 ****)((longlong)user_input_buffer_ptr + (-8 - (longlong)temp_free_ptr));
      if ((undefined8 ****)0x1f < data_buffer_ptr) {
        code_pointer = (code *)swi(0x29);
        (*code_pointer)(5);
        status_buffer = status_buffer + 8;
        temp_free_ptr = data_buffer_ptr;
      }
    }
    *(undefined8 *)(status_buffer + -8) = 0x1400014b7;
    free(temp_free_ptr);
  }
  *(undefined8 *)(status_buffer + -8) = 0x1400014c9;
  return 0;
}

uint32_t password_value = 0;

std::cout << "Pass: " << password_value << "\n";
return 0;

## 생성된 해결책

처음에 해결책을 생성했을 때는 올바르지 않았습니다. 이것을 이 저장소의 [tut1.txt](https://github.com/markoglasgow/gemma_crackme_tutorial/blob/master/tut1.txt)에 포함시켰습니다. 언뜻 보기에는 해결책이 _올바르게_ 보이지만, 실제로 시도해보면 실패합니다. AI는 근본적으로 신뢰할 수 없으며, 이것이 그 완벽한 예입니다.

괜찮습니다. 새 채팅을 열고 위의 프롬프트를 복사하여 붙여넣은 후 AI가 새 해결책을 생성하도록 하면 됩니다. 제 경우에는 두 번째 시도에서 작동하는 해결책을 얻었습니다:```
#include <cstdio>
#include <cstdint>
#include <string>
#include <iostream>
#include <sstream>
#include <iomanip>

/**
 * @brief Simulates the custom checksum calculation defined in the crackme function.
 *
 * @param username The input string (username).
 * @return int The final calculated user_checksum.
 */
int calculate_username_checksum(const std::string& username) {
    // user_checksum is treated as an 'int' (32-bit signed integer) during the core calculation.
    int user_checksum = 0;

    // pass_input_length_1 acts as the state variable and is a ulonglong (64-bit).
    // It starts at 0, as pass_input_length_1 = user_input_byte_index (which is 0) initially.
    uint64_t state_pass_length_1 = 0;

    for (size_t i = 0; i < username.length(); ++i) {
        // i = user_input_byte_index

        // Step 1: Calculate the intermediate value T1.
        // The decompiler implies this calculation happens using standard int math 
        // (truncating/wrapping if intermediate values exceed 32 bits).
        // (int)user_input_byte_index + 1
        int index_term = (int)(i + 1);

        // (int)*(char *)((longlong)temp_free_ptr + user_input_byte_index)
        // This is just the ASCII value of the character.
        int char_term = (int)username[i];

        // (int)pass_input_length_1
        // The state is cast down to an int for this arithmetic operation.
        int state_term = (int)state_pass_length_1;

        // T1 = ((int)user_input_byte_index + 1) * (int)char + (int)state
        int intermediate_t1 = index_term * char_term + state_term;

        // Step 2: Apply the XOR/Multiplication hash function.
        // user_checksum = user_checksum * 8 ^ user_checksum;
        // Note: The original code structure suggests the update happens here, 
        // but since we are recalculating the hash step-by-step, we use the definition:
        // user_checksum = T1 * 8 ^ T1; 

        // Since the original code overwrites user_checksum completely with the hash 
        // of the current character, we use the T1 derived above.

        int current_checksum = intermediate_t1;
        current_checksum = current_checksum * 8 ^ current_checksum;

        // Update the final running checksum
        user_checksum = current_checksum;

        // Step 3: Update the state variable for the next iteration.
        state_pass_length_1 = (uint64_t)user_checksum;
    }

    return user_checksum;
}


int main()
{
    std::string username;
    std::cout << "User: ";
    std::cin >> username;

    // 1. Calculate the final checksum using the username
    int final_user_checksum = calculate_username_checksum(username);

    // 2. Calculate the final hash/secret value
    // FinalHashValue = user_checksum * 0x539 ^ 0x5a5a
    // Note: The arithmetic here is done on the final 32-bit 'int' checksum.
    uint32_t final_hash_value = (uint32_t)final_user_checksum * 0x539 ^ 0x5a5a;

    // 3. Convert the final hash value into a string (as implied by int_to_string_dynamic)
    // Since the password needs to match the memory contents (memcmp), it must be the string representation.
    std::stringstream ss;
    ss << final_hash_value;
    std::string required_password = ss.str();


    // We output the required password string.
    std::cout << "Pass: " << required_password << "\n";
    return 0;
}