Это даёт `75 токенов/сек`, что довольно быстро для локального ИИ.

## Нет оборудования? Не проблема

Если у вас нет подходящего оборудования или возникли проблемы с настройкой, но вы всё же хотите следовать этому руководству, вы можете зарегистрироваться в 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

Откройте Ghidra, запустив `ghidraRun.bat`. На панели инструментов выберите `File -> New Project`, оставьте выбранным `Non-Shared Project` и нажмите `Next >>`, затем выберите пустой каталог проекта и дайте проекту имя. Затем нажмите `Finish`.

Затем нажмите `File -> Import File`, выберите `crackmepls.exe`, чтобы добавить его в проект. Ghidra отобразит некоторые сведения о файле, сообщая, что это `Portable Executable (PE)` файл для `x86:LE:64:default:windows`. Просто нажмите `OK`, чтобы принять это без изменений. После небольшой задержки появятся дополнительные сведения о файле, снова просто нажмите `OK`, чтобы принять. Наконец, дважды щелкните на `crackmepls.exe` в проекте, чтобы открыть Code Browser и начать дизассемблирование.

В самом начале Ghidra отобразит сообщение: `crackmepls.exe has not been analyzed. Would you like to analyze it now?`. Нажмите `Yes`, а затем кнопку `Analyze` в следующем окне, и подождите, пока Ghidra найдет, дизассемблирует и декомпилирует все функции в бинарном файле. Возможно, во время анализа возникнет одна или две ошибки о том, что файлы PDB не найдены, просто нажмите `Ok` и проигнорируйте их.

Когда 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()` crackme, поэтому дважды щелкните по ней.

![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")

Эти строки соответствуют операторам вывода и ввода, которые мы видели при первом запуске crackme, поэтому мы знаем, что находимся в функции `main()` crackme.

На данном этапе начинается утомительная работа, когда нам нужно сесть и переименовать каждое имя переменной и вызов функции во что-то осмысленное, анализируя, что делает бинарный файл, чтобы решить crackme. Раньше реверс-инженерам приходилось делать это вручную в дизассемблере, но, к счастью, технологии и налоги принесли нам этот удобный декомпилятор, который можно использовать с помощью скриптов и AI.

Поэтому вместо реальной работы давайте расслабимся, отключим голову и позволим нашему локальному AI сделать всю работу за нас.

Во время настройки этого руководства вы должны были установить плагин Ghidra для помощи с переименованием функций и переменных. Настало время его использовать. В Ghidra на панели инструментов вверху нажмите `Window`, затем `Fast AI Renamer`, чтобы открыть плагин.

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

Вы должны увидеть интерфейс плагина, который представляет собой набор кнопок и текстовую область. Начните с нажатия кнопки `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, особенно маленькие локальные, по своей сути ненадежны, поэтому на последнем шаге вы можете увидеть некоторые ошибки. Мы еще вернемся к этому позже. А пока вы всегда можете просто перезапустить AI, снова нажав кнопку `Rename Variables`, пока не получите результаты без ошибок, которые вас устраивают.

## Решение Crackme

На данный момент у нас есть красиво размеченный вывод декомпилятора, где все имена переменных переименованы во что-то осмысленное. Традиционно реверс-инженер мог бы сейчас прочитать этот код и начать разрабатывать решение для Crackme. Однако я подумал, что было бы здорово попробовать заставить локальный AI решить crackme за нас. Помните, сегодня мы не будем использовать свой мозг.

Сначала я попросил AI завершить разметку всего бинарного файла, нажав кнопку `Rename ALL Functions and Variables`. Это служит для присвоения имен всем вызовам функций, используемым в этой функции crackme, что еще больше очищает вывод декомпилятора. На моей машине это занимает около 15 минут.

Когда вы используете `llama.cpp` с параметрами CLI, которые я указал в разделе `Local AI Setup`, вы можете открыть чат-интерфейс для вашей локальной модели, перейдя в браузере по адресу [http://localhost:8090/](http://localhost:8090/)

Здесь я ввел вывод декомпилятора функции из crackme (вы можете получить его, нажав кнопку `Decompile Function` в интерфейсе плагина или просто скопировав из окна декомпилятора справа) и попросил AI написать решение для нас:

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

Я хочу, чтобы вы помогли мне написать решение для crackme. Ниже представлен листинг декомпилятора функции из crackme, где пользователь вводит имя пользователя и пароль, и доступ предоставляется, если пароль правильный. Пароль вычисляется в этой функции.```


/* 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/HEAD/tut1.txt) в этом репозитории. На первый взгляд решение _выглядит_ правильным, но при попытке его применить оно не работает. ИИ принципиально ненадёжны, и это отличный тому пример.

Ничего страшного, мы можем просто открыть новый чат, скопировать приведённый выше запрос и попросить ИИ сгенерировать для нас новое решение. В моём случае я получил работающее решение со второй попытки:```
#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;
}