これにより `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

Ghidraを開くには、`ghidraRun.bat`を実行してください。ツールバーで`File -> New Project`を選択し、`Non-Shared Project`が選択されたまま`Next >>`をクリックし、空のプロジェクトディレクトリを選択してプロジェクト名を入力します。その後`Finish`をクリックします。

次に、`File -> Import File`をクリックし、`crackmepls.exe`を選択してプロジェクトに追加します。Ghidraがファイルの詳細をポップアップ表示し、それが`x86:LE:64:default:windows`向けの`Portable Executable (PE)`ファイルであることを通知します。何も変更せずに`OK`をクリックして受け入れます。しばらく待つと、さらにファイルの詳細がポップアップ表示されるので、再度`OK`をクリックして受け入れます。最後に、プロジェクト内の`crackmepls.exe`をダブルクリックしてコードブラウザを開き、逆アセンブルを開始します。

最初に、Ghidraが「crackmepls.exe has not been analyzed. Would you like to analyze it now?」というメッセージを表示します。`Yes`をクリックし、次のウィンドウで`Analyze`ボタンをクリックし、Ghidraがバイナリ内のすべての関数を特定、逆アセンブル、逆コンパイルするのを待ちます。分析中にPDBファイルが見つからないといったエラーが1～2件表示されることがありますが、`Ok`をクリックして無視してください。

Ghidraによるファイルの分析が完了すると、以下のような画面が表示されるはずです。

![alt text](https://assets.kitploit.com/production/public/readmes/13760/2be69c6e539fa74e1ac31eec4304bcd7e8952ba96b91fab51add36ed6c1440ee.png "プログラムエントリポイント")

これは標準的なMSVCエントリポイントです。`FUN_14000200c`をダブルクリックし、スクロールダウンします。

逆コンパイラウィンドウに`__p___argv`、`__p___argc`への参照があり、それらをパラメータとして受け取る関数呼び出し`FUN_140001290`が表示されるはずです。これがcrackmeの`main()`関数と思われるので、ダブルクリックします。

![alt text](https://assets.kitploit.com/production/public/readmes/13760/577b01a818727ee43010a24d03236157d22a69f94599f4117420436a641745ac.png "main関数の特定")

関数`FUN_140001290`内に入ったら、逆コンパイラウィンドウで少しスクロールダウンします。文字列`User:`と`Pass:`への参照、および`basic_istream`（入力ストリーム）と`basic_ostream`（出力ストリーム）への参照が表示されます。

![alt text](https://assets.kitploit.com/production/public/readmes/13760/dda6baaa2d284402bd8ce61c776810a0c154c6861e0012a56391fccbeb71a0c5.png "出力と入力")

これらの文字列は、最初にcrackmeを実行したときに表示されたprint文と入力文と一致するため、crackmeの`main()`関数内にいることがわかります。

ここからが、従来のリバースエンジニアリングの面倒な作業の始まりです。バイナリが何をしているのかを分析し、crackmeを解くために、すべての変数名と関数呼び出しを意味のある名前に変更していく必要があります。かつてリバースエンジニアは逆アセンブリ上で手作業でこれを行っていましたが、幸いなことにテクノロジーと税金によって、スクリプト化してAIと連携できる便利な逆コンパイラが手に入りました。

そこで、実際の作業をする代わりに、楽をして、頭を休めて、ローカルAIにすべての作業を任せることにしましょう。

このチュートリアルのセットアップ中に、関数や変数の名前変更を支援するGhidraプラグインをインストールしているはずです。今こそそれを使う時です。Ghidraの上部ツールバーで`Window`をクリックし、`Fast AI Renamer`を選択してプラグインを開きます。

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

プラグインのUIが表示されます。これはいくつかのボタンとテキストエリアで構成されています。まず`Config`ボタンをクリックし、ローカルAIと通信するための設定が正しく行われていることを確認します。私のコンピュータでの設定は以下の通りです。

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

`Save`をクリックして設定ウィンドウを閉じ、次に`Rename Variables`ボタンをクリックします。ドラゴンが表示された進行状況ウィンドウがポップアップし、コンピュータがローカルAIモデルを実行して逆コンパイラウィンドウ内のすべての変数の名前を変更するため、少し負荷がかかる音が聞こえるかもしれません。

![alt text](https://assets.kitploit.com/production/public/readmes/13760/1f9e6ac902cce19f63319621adaabef504ad5a94fa84db2ec39782b74e2f18f6.png "変数の名前変更")

AIの処理が完了すると（私のマシンでは約10～20秒）、プラグインのテキストエリアに名前変更された変数の説明が表示され、逆コンパイラウィンドウ内の変数名が実際に変更されます。

![alt text](https://assets.kitploit.com/production/public/readmes/13760/3454e5e42d7a4d84dffffbc6343e9579d33b3241b42e0be06bdb068eb91ed1e3.png "名前変更の結果")

すべてのAIモデル、特に小型のローカルモデルは本質的に信頼性が低いため、この最後のステップでエラーが発生する可能性があります。これについては後ほど再度触れます。それまでは、`Rename Variables`ボタンを再度クリックしてAIを再実行し、エラーがなく満足のいく結果が得られるまで続けることができます。

## Crackmeを解く

ここまでで、逆コンパイラの出力は見やすくマークアップされ、すべての変数名が意味のあるものに変更されています。従来であれば、リバースエンジニアはこのコードを読み、Crackmeの解決策の草案を作成することができました。しかし、今回はローカルAIにcrackmeを解かせてみようと思います。今日は頭を使わないことにしたのですから。

まず、`Rename ALL Functions and Variables`ボタンをクリックして、AIにバイナリ全体のマークアップを完了させました。これにより、このcrackme関数内で使用されているすべての関数呼び出しに名前が割り当てられ、逆コンパイラの出力がさらにきれいになります。私のマシンではこれに約15分かかりました。

`Local AI Setup`で記載したCLIパラメータで`llama.cpp`を使用している場合、ブラウザで[http://localhost:8090/](http://localhost:8090/)にアクセスすると、ローカルモデルとのチャットUIを開くことができます。

ここで、crackmeの関数の逆コンパイラ出力を入力し（プラグインUIの`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/master/tut1.txt) にその結果を含めています。一見すると、そのソリューションは _正しい_ ように見えますが、試してみると失敗します。AIは基本的に信頼性が低く、これはその完璧な例です。

とはいえ、新しいチャットを開き、上記のプロンプトをコピー＆ペーストして、AIに新しいソリューションを生成させるよう試みることはできます。私の場合、2回目の試行で動作するソリューションを得ることができました。```
#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;
}