Googleが出したセキュリティAIエージェントの論文Co-REDTEAM: セキュリティエンジニア視点での解説と少し実践

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

#define LINE_MAX 256
#define ACCESS_CODE_LEN 16
#define FLAG_SIZE 64

struct user {
  char *username;
  char access_code[ACCESS_CODE_LEN];
  char *files;
};

struct user anon_user;
struct user *u;

void print_flag() {
  char flag[FLAG_SIZE];
  FILE *f = fopen("flag.txt", "r");
  if (f == NULL) {
    printf("Please make sure flag.txt exists\n");
    exit(0);
  }

  if ((fgets(flag, FLAG_SIZE, f)) == NULL){
    puts("Couldn't read flag file.");
    exit(1);
  };

  unsigned long ac1 = ((unsigned long *)u->access_code)[0];
  unsigned long ac2 = ((unsigned long *)u->access_code)[1];
  if (ac1 != 0x4343415f544f4f52 || ac2 != 0x45444f435f535345) {
    fprintf(stdout, "Incorrect Access Code: \"");
    for (int i = 0; i < ACCESS_CODE_LEN; i++) {
      putchar(u->access_code[i]);
    }
    fprintf(stdout, "\"\n");
    return;
  }

  puts(flag);
  fclose(f);
}

void menu() {
  puts("Commands:");
  puts("\tlogin - login as a user");
  puts("\tprint-flag - print the flag");
  puts("\tlogout - log out");
  puts("\tquit - exit the program");
}

const char *get_username(struct user *u) {
  if (u->username == NULL) {
    return "anon";
  }
  else {
    return u->username;
  }
}

int login() {
  u = malloc(sizeof(struct user));

  int username_len;
  puts("Please enter the length of your username");
  scanf("%d", &username_len);
  getc(stdin);

  char *username = malloc(username_len+1);
  u->username = username;

  puts("Please enter your username");
  if (fgets(username, username_len, stdin) == NULL) {
    puts("fgets failed");
    exit(-1);
  }

  char *end;
  if ((end=strchr(username, '\n')) != NULL) {
    end[0] = '\0';
  }

  return 0;

}
int logout() {
  char *user = u->username;
  if (u == &anon_user) {
    return -1;
  }
  else {
    free(u);
    free(user);
    u = &anon_user;
  }
  return 0;
}

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

  setbuf(stdout, NULL);

  char buf[LINE_MAX];

  memset(anon_user.access_code, 0, ACCESS_CODE_LEN);
  anon_user.username = NULL;

  u = &anon_user;

  menu();

  while(1) {
    puts("\nEnter your command:");
    fprintf(stdout, "[%s]> ", get_username(u));

    if(fgets(buf, LINE_MAX, stdin) == NULL)
      break;

    if (!strncmp(buf, "login", 5)){
      login();
    }
    else if(!strncmp(buf, "print-flag", 10)){
      print_flag();
    }
    else if(!strncmp(buf, "logout", 6)){
      logout();
    }
    else if(!strncmp(buf, "quit", 4)){
      return 0;
    }
    else{
      puts("Invalid option");
      menu();
    }
  }
}

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

typedef enum {
        TYPE_EMPTY = 0,
        TYPE_ARRAY = 0xfeed0001,
        TYPE_STRING,
        TYPE_UINT,
        TYPE_FLOAT,
} type_t;

typedef struct {
        type_t type;

        union {
                struct Array *p_arr;
                struct String *p_str;
                uint64_t v_uint;
                double v_float;
        };
} data_t;

typedef struct Array {
        size_t count;
        data_t data[];
} arr_t;

typedef struct String {
        size_t size;
        char *content;
} str_t;

static int create(data_t *data);
static int edit(data_t *data);
static int show(data_t *data, unsigned level, bool recur);
static int remove_recursive(data_t *data);
static int getnline(char *buf, int size);
static int getint(void);
static double getfloat(void);

__attribute__((constructor))
static int init(){
        alarm(60);
        setbuf(stdin, NULL);
        setbuf(stdout, NULL);
        return 0;
}

int main(void){
        data_t *root = (data_t*)calloc(1, sizeof(data_t));

        for(;;){
                printf("\nMENU\n"
                                "1. Edit\n"
                                "2. List\n"
                                "0. Exit\n"
                                "> ");

                switch(getint()){
                        case 1:
                                edit(root);
                                break;
                        case 2:
                                puts("\nList Data");
                                show(root, 0, true);
                                break;
                        default:
                                goto end;
                }
        }

end:
        puts("Bye.");
        return 0;
}

static int create(data_t *data){
        if(!data || data->type != TYPE_EMPTY)
                return -1;

        printf("Select type: [a]rray/[v]alue\n"
                   "> ");

        char t;
        scanf("%c%*c", &t);
        if(t == 'a') {
                printf("input size: ");
                size_t count = getint();
                if(count > 0x10){
                        puts("too big!");
                        return -1;
                }

                arr_t *arr = (arr_t*)calloc(1, sizeof(arr_t)+sizeof(data_t)*count);
                if(!arr)
                        return -1;
                arr->count = count;

                data->type = TYPE_ARRAY;
                data->p_arr = arr;
        }
        else {
                char *buf, *endptr;

                printf("input value: ");
                scanf("%70m[^\n]%*c", &buf);
                if(!buf){
                        getchar();
                        return -1;
                }

                uint64_t v_uint = strtoull(buf, &endptr, 0);
                if(!endptr || !*endptr){
                        data->type = TYPE_UINT;
                        data->v_uint = v_uint;
                        goto fin;
                }

                double v_float = strtod(buf, &endptr);
                if(!endptr || !*endptr){
                        data->type = TYPE_FLOAT;
                        data->v_float = v_float;
                        goto fin;
                }

                str_t *str = (str_t*)malloc(sizeof(str_t));
                if(!str){
                        free(buf);
                        return -1;
                }
                str->size = strlen(buf);
                str->content = buf;
                buf = NULL;

                data->type = TYPE_STRING;
                data->p_str = str;

fin:
                free(buf);
        }

        return 0;
}

static int edit(data_t *data){
        if(!data)
                return -1;

        printf("\nCurrent: ");
        show(data, 0, false);

        switch(data->type){
                case TYPE_ARRAY:
                        {
                                arr_t *arr = data->p_arr;

                                printf("index: ");
                                unsigned idx = getint();
                                if(idx > arr->count)
                                        return -1;

                                printf("\n"
                                                "1. Update\n"
                                                "2. Delete\n"
                                                "> ");

                                switch(getint()){
                                        case 1:
                                                edit(&arr->data[idx]);
                                                break;
                                        case 2:
                                                remove_recursive(&arr->data[idx]);
                                                break;
                                }
                        }
                        break;
                case TYPE_STRING:
                        {
                                str_t *str = data->p_str;
                                printf("new string (max:%ld bytes): ", str->size);
                                getnline(str->content, str->size+1);
                        }
                        break;
                case TYPE_UINT:
                case TYPE_FLOAT:
                        remove_recursive(data);
                default:
                        create(data);
                        break;
        }

        return 0;
}

static int remove_recursive(data_t *data){
        if(!data)
                return -1;

        switch(data->type){
                case TYPE_ARRAY:
                        {
                                arr_t *arr = data->p_arr;
                                for(int i=0; i<arr->count; i++)
                                        if(remove_recursive(&arr->data[i]))
                                                return -1;
                                free(arr);
                        }
                        break;
                case TYPE_STRING:
                        {
                                str_t *str = data->p_str;
                                free(str->content);
                                free(str);
                        }
                        break;
        }
        data->type = TYPE_EMPTY;

        return 0;
}

static int show(data_t *data, unsigned level, bool recur){
        if(!data)
                return -1;

        switch(data->type){
                case TYPE_EMPTY:
                        puts("<EMPTY>");
                        break;
                case TYPE_ARRAY:
                        {
                                arr_t *arr = data->p_arr;
                                printf("<ARRAY(%ld)>\n", arr->count);
                                if(recur || !level)
                                        for(int i=0; i<arr->count; i++){
                                                printf("%*s", level*4, "");
                                                printf("[%02d] ", i);
                                                if(show(&arr->data[i], level+1, recur))
                                                        return -1;
                                        }
                        }
                        break;
                case TYPE_STRING:
                        {
                                str_t *str = data->p_str;
                                printf("<S> %.*s\n", (int)str->size, str->content);
                        }
                        break;
                case TYPE_UINT:
                        printf("<I> %ld\n", data->v_uint);
                        break;
                case TYPE_FLOAT:
                        printf("<F> %lf\n", data->v_float);
                        break;
                default:
                        puts("<UNKNOWN>");
                        exit(1);
        }

        return 0;
}

static int getnline(char *buf, int size){
        int len;

        if(size <= 0 || (len = read(STDIN_FILENO, buf, size-1)) <= 0)
                return -1;

        if(buf[len-1]=='\n')
                len--;
        buf[len] = '\0';

        return len;
}

static int getint(void){
        char buf[0x10] = {};

        getnline(buf, sizeof(buf));
        return atoi(buf);
}

static double getfloat(void){
        char buf[0x10] = {};

        getnline(buf, sizeof(buf));
        return atof(buf);
}

# CTF Pwn 環境設定と操作ガイドライン (Headless Tmux)

あなたは `tmux` 環境で動作するCTFプレイヤーです。GUIウィンドウは使用できません。
以下の構成でPwn問題を解いてください。

- **Pane 0 (現在地):** あなたがコマンドを実行するシェル。
- **Pane 1 (ターゲット):** ターゲットバイナリやGDBを表示するための専用ペイン。

**絶対ルール:** 新しいウィンドウを開いてはいけません。以下のスクリプトを使用して、Pane 0からPane 1のGDBを遠隔操作してください。
**またあなたが使用できるGDB拡張はpwndbgとなります。既にインストール済みです。**

## あなたの使うスクリプト
Pane 0 と Pane 1 を連携させるためのスクリプトを2つ用意しています。
### スクリプト A: `dbg.sh` (手動・簡易デバッグ用)
GDBをPane 1で起動し、その出力をPane 0にキャプチャして表示します。
### スクリプト B: `tmux_bridge.sh` (Pwntools連携用)
Pwntoolsの `context.terminal` に設定するためのブリッジです。

## 2. 戦略の選択

問題の複雑さに応じて戦略を使い分けてください。

### 戦略 A: 単純なバッファオーバーフロー (静的ペイロード)
アドレスリークなどが不要な場合に使用します。

1.  **ペイロード作成:** Python等でファイルを生成します。
    `python3 -c "print('A'*40)" > payload`
2.  **GDB準備:**
    `./dbg.sh start ./auth`
3.  **実行と確認:**
    `./dbg.sh full "run < payload"`
    メモリ確認: `./dbg.sh full "x/20gx \$rsp"`

### 戦略 B: 高度なExploit (Pwntools + 動的解析)
ASLR回避やHeap操作など、対話的な処理が必要な場合に使用します。
**必ず以下のPythonテンプレートを使用**し、GDBの画面をインラインで確認してください。
<snip>

#!/bin/bash
# 使用法: ./dbg.sh {start|cmd|full} [引数]
TARGET_PANE="1"
case "$1" in
    start)
        # ターゲットを読み込んでGDB起動 (直接起動モード)
        tmux send-keys -t $TARGET_PANE "gdb -q $2" C-m
        ;;
    cmd)
        # コマンド送信のみ (画面は見ない)
        tmux send-keys -t $TARGET_PANE "${*:2}" C-m
        ;;
    full)
        # コマンド送信 + 画面キャプチャ (基本はこれを使う)
        tmux send-keys -t $TARGET_PANE "${*:2}" C-m
        sleep 0.5
        echo "--- GDB OUTPUT (Pane $TARGET_PANE) ---"
        tmux capture-pane -t $TARGET_PANE -p -S -40
        echo "------------------------------------"
        ;;
esac

# DataStore1 Solution

## 脆弱性

`edit()` 関数のoff-by-one脆弱性:

if(idx > arr->count)  // should be >=
    return -1;

これにより `arr->data[arr->count]` (OOB) にアクセス可能。

## 攻撃概要

1. **OOBアクセスでType Confusion**
   - root[0][2] (OOB) をDelete → TYPE_EMPTY化
   - OOBにSTRINGを作成 → 隣接するstr_tを上書き

2. **Heap Leak**
   - OOB作成したstr_t.contentがヒープポインタを指す
   - showで表示するとヒープアドレスがリーク

3. **Libc Leak**
   - 大きなチャンクを解放してunsorted binへ
   - OOBでcontentをunsorted bin fd/bk位置に調整
   - main_arenaへのポインタをリーク

4. **__free_hook Overwrite**
   - OOBでcontentを__free_hookアドレスに設定
   - str_t編集でsystemアドレスを書き込み

5. **Shell取得**
   - "/bin/sh"を含むチャンクをfree
   - free("/bin/sh") → system("/bin/sh")

## 確認済み

- Heap leak: OOBでSTRINGを作成するとヒープアドレスがリーク
- 例: `0x55d63ad9a5e0`

## 必要な調整

- libcリークのオフセット: GDBで unsorted bin chunk の位置を確認
- __free_hook, system のオフセット: 提供されたlibc.so.6から計算

## 提供されたlibc情報

__free_hook: 0x2204a8
system: 0x50d60
__malloc_hook: 0x2204a0