---
title: การควบคุมการสั่นสะเทือนและการสั่นสะเทือน — REA
url: https://rea.tools/th/showcase/ctf/
---

[บ้าน](https://rea.tools/th/) / [โชว์เคส](https://rea.tools/th/showcase/) /ซีทีเอฟ

กรณีศึกษา·ดาวน์ดันเดอร์ซีเอฟ 2023

# หาธงใน ไบนารีซีทีเอฟ

ใช้ REA ในการตรวจสอบตัวตรวจสอบธงขนาดเล็ก,เปิดกฎของมันเป็นสมการและหาอินพุตที่ทำให้ก `Correct!`.

สี่เหลี่ยมสวมหน้ากากตรวจสอบธง\*ง่าย · Linux 86-64

[ดูความท้าทายเดิม](https://github.com/DownUnderCTF/Challenges_2023_Public/tree/b48f83db2984bc7fa2ec7879a32d7efb1be8d333/rev/masked-squares-flag-checker)

จากไบนารีถึงคำตอบที่ถูกตรวจสอบ

1. 01\*ค้นหาเช็ค

   **ฟังก์ชั่นการตรวจสอบสายอักขระ**

   REA ค้นหาพรอมต์การอ้างอิงและรหัสที่ยอมรับหรือปฏิเสธการป้อนข้อมูล
2. 02\*แยกกฎ

   **36 ตัวอักษร·26 ผลรวม**

   REA ส่งคืนคำแนะนำและข้อมูลที่อยู่เบื้องหลังการตรวจสอบแต่ละ เจ้าหน้าที่เปลี่ยนให้เป็นสมการ
3. 03\*แก้ปัญหาและเรียกใช้

   **กู้คืนธงยุคที่ถูกต้อง!**

   สคริปต์หลามแก้สมการ REA จับโปรแกรมต้นฉบับที่ยอมรับผลลัพธ์

ความท้าทายคือโจเซฟเผยแพร่ในพื้นที่เก็บข้อมูลอย่างเป็นทางการของดาวันเดอร์ซีฟ

## ค้นหารหัสตรวจสอบ

เอกสารประกอบคำบรรยายเป็น 15 กิโลไบต์ปฏิบัติการ มันขอให้ธงแล้วพิมพ์ `Correct!` หรือ `Incorrect!`. เริ่มต้นด้วยการร้องขออย่างง่ายๆกับตัวแทนของคุณ

ตัวแทนการเข้ารหัสของคุณ

ใช้ REA วิจัย,การเขียนทางเทคนิค,การเขียนรายงาน,การเขียนเชิงวิชาการ อธิบายวิธีการตรวจสอบการทำงานแล้วตรวจสอบคำตอบด้วยโปรแกรมต้นฉบับ

พร้อมท์ตัวอย่างกับความท้าทายดาวน์โหลดพร้อมใช้งานภายในและการวิเคราะห์ผู้ให้บริก

1. #### ทำตามพร้อมท์อินพุตไปยังฟังก์ชัน

   เจ้าหน้าที่→ REA

   ```
   open_binary
   {"path": "ms_flag_checker"}

   search_strings
   {"pattern": "flag|correct|wrong|input",
    "mode": "regex", "case_sensitive": false}

   xrefs
   {"address": "0x102004"}

   resolve_containing_procedure
   {"address": "0x10126d"}
   ```

   REA agent ตัวแทน·ผลลัพธ์ที่เลือกไว้

   ```
   0x102004  "What is the flag? "
   0x10201c  "Incorrect!"
   0x102027  "Correct!"

   Prompt referenced at: 0x10126d
   Containing function: 0x10124d
   ```

   การอ้างอิงให้ตัวแทนสถานที่ในการตรวจสอบแม้ว่าชื่อฟังก์ชันเดิมของปฏิบัติการได้ถูกลบออก
2. #### อ่านตรวจสอบและสองผู้ช่วย

   เจ้าหน้าที่→ REA

   ```
   analyze_function
   {"procedure": "0x10124d"}

   analyze_function
   {"procedure": "0x101189"}

   analyze_function
   {"procedure": "0x101217"}
   ```

   REA →ตัวแทน·คำแนะนำที่เลือกไว้

   ```
   0x1012c1: CMP EDI, 0x24
   0x1012c6: LEA RBX, [0x1040e0]
   0x1012cd: LEA RBP, [0x104060]
   0x1012d4: LEA R13, [RBX + 0x270]
   0x1012e1: CALL 0x00101189
   0x1012ec: CALL 0x00101217
   0x1012f1: CMP dword ptr [RBP], EAX
   0x1012f4: JNZ 0x00101335
   0x1012f6: ADD RBX, 0x18
   ```

   วงแรกคัดลอกรหัสอักขระ 36 ตัว ห่วงการตรวจสอบถอดรหัสหน้ากากรวมรหัสที่เลือกและเปรียบเทียบผลกับหมายเลขที่เก็บไว้ มัน `0x18`-ขั้นตอนไบต์ข้าม `0x270` ไบต์ให้ 26 มาสก์

เหล่านี้จะถูกเลือกผลลัพธ์จากสด REA การวิเคราะห์ เส้นทางเป้าหมายท้องถิ่นจะสั้นลงสำหรับการแสดงผล;ที่อยู่อ้างถึง REAของภาพที่นำเข้า

## หนึ่งตรวจสอบเผยตัวละครตัวหนึ่ง

ตรวจสอบจัดป้อนข้อมูลใน 6×6 ตาราง หน้ากากจะเลือกเซลล์ที่ส่งผลต่อผลรวม การเข้ารหัสขนาดกะทัดรัดใช้ตัวเลขเชิงลบเพื่อข้ามเซลล์และตัวเลขบวกเพื่อเลือกพวกเ

![หน้ากากที่เจ็ดข้าม 21 เซลล์เลือกตำแหน่ง 21 แล้วข้าม 14 เฉพาะเซลล์ที่ก่อให้เกิดผลรวม รหัสอักขระที่จำเป็นคือ 55 ซึ่งหมายความว่าอักขระคือ 7](https://rea.tools/assets/localized/th/figures/ctf-mask-equation.svg)

ตรวจสอบที่เจ็ดเลือกเพียงหนึ่งตำแหน่ง [เปิดรูป](https://rea.tools/assets/localized/th/figures/ctf-mask-equation.svg).

### อ่านหน้ากากและเป้าหมายจากไบนารี

เจ้าหน้าที่→ REA ·อ่าน_ไบต์

```
{"address": "0x1040e0", "length": 624}
{"address": "0x104060", "length": 144}
```

REA →ตัวแทน\*รายการที่เจ็ด

```
Mask at 0x104170:
eb 01 f2 00  →  -21, +1, -14, stop

Target at 0x104078:
37 00 00 00  →  55
```

การเรียนการสอน `MOVSX` อ่านไบต์หน้ากากเป็นค่าที่ลงนาม นี่คือเหตุผลที่ `eb` หมายถึง -21 เป้าหมายคือจำนวนเต็มเอนเดียนน้อย ร่วมกันไบต์เหล่านี้บอกตัวแทนที่ `code[21] = 55` เพื่อให้ตัวละครที่เป็น `7`.

## จากคำแนะนำในการตรวจสอบที่อ่านได้

เลือกขั้นตอนในการเชื่อมต่อผู้ช่วยข้อสรุปและฟังก์ชั่นการเรียกของกฎเดียวกันในซี

REA \*เลือกคำแนะนำเดิม

```
0x10121c: MOV ECX, 0x0

0x10122c: CMP dword ptr [RSI + RAX*0x1], 0x0
0x101230: JZ 0x00101223

0x101232: ADD ECX, dword ptr [RDI + RAX*0x1]

0x101223: ADD RAX, 0x4

0x1012f1: CMP dword ptr [RBP], EAX
0x1012f4: JNZ 0x00101335
```

อ่านค·สรุปหนึ่งตรวจสอบ

```
int check_one_mask(const int codes[36],
                   const int mask[36],
                   int target) {
    int total = 0;
    for (int i = 0; i < 36; ++i) {
        if (mask[i]) {
            total += codes[i];
        }
    }
    return total == target;
}
```

**01\*เริ่มที่ศูนย์** `ECX` ถือผลรวมการทำงาน

**02·ตรวจสอบเซลล์หน้ากาก** ค่าศูนย์ข้ามอักขระค่าที่ไม่ใช่ศูนย์รวม

**03\*เพิ่มรหัสอักขระ** จำนวนเต็มของอินพุตที่ชดเชยเดียวกันจะถูกเพิ่มในผลรวม

**04\*ย้ายไปยังเซลล์ถัดไป** ห่วงเดิมก้าวหน้าสี่ไบต์ต่อจำนวนเต็มและการเข้าชมหกแถวของหกเซลล์

**05\*เปรียบเทียบกับเป้าหมายที่เก็บไว้** ฟังก์ชั่นการโทรได้รับผลรวมใน `EAX`. ไม่ตรงกันกระโดดไป `Incorrect!`.

คำแนะนำมาจากผู้ช่วยข้อสรุปและฟังก์ชั่นการเรียก คเป็นบทสรุปอธิบายที่มีชื่ออธิบายและแบนลูป 36 เซลล์

## แก้สมการ 26

หน้ากากส่วนใหญ่เลือกหลายเซลล์ ตัวอย่างเช่นการตรวจสอบครั้งแรกเพิ่ม 16 รหัสอักขระและต้องมีทั้งหมด 1441 การเลือกที่ทับซ้อนกันให้สมการที่สคริปต์หลามขนาดเล็กสามารถแก้ร่วมกัน

งูหลาม\*ตัดตอนแก้

```
from z3 import Int, Or, Solver, Sum, sat

codes = [Int(f"code_{i}") for i in range(36)]
solver = Solver()
alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_{}"
for code in codes:
    solver.add(Or(*[code == ord(c) for c in alphabet]))
for code, char in zip(codes, "DUCTF{"):
    solver.add(code == ord(char))
solver.add(codes[-1] == ord("}"))

for selected, target in checks:
    solver.add(Sum([codes[i] for i in selected]) == target)

assert solver.check() == sat
model = solver.model()
print("".join(chr(model.eval(code).as_long()) for code in codes))
```

3 เป็นตัวแก้ที่พบว่าค่าที่น่าพอใจสมการเหล่านี้ ข้อความที่ตัดตอนมานี้จะใช้การตรวจสอบสกัดและถือว่า `DUCTF{…}` ธงที่มีตัวอักษรตัวเลขขีดและวงเล็บ ดาวน์โหลดที่สมบูรณ์รวมถึงทั้งหมด 26 หน้ากากและเป้าหมาย

[ดาวน์โหลดแก้ที่สมบูรณ์](https://rea.tools/showcase/ctf/solve.py)

## ตรวจสอบคำตอบด้วยโปรแกรมต้นฉบับ

REAกระบวนการจับภาพบันทึกปฏิบัติการเดิมยอมรับธงแก้ไข เปลี่ยนตัวอักษรที่เลือกจาก `z` ถึง `y` ทำให้ผลรวมแรก 1440 แทน 1441 และโปรแกรมปฏิเสธมัน

| อินพุต | ผลลัพธ์ที่สังเกต | รหัสออก |
| --- | --- | --- |
| ธงของแก้ | `Correct!` | 0 |
| ตัวละครตัวหนึ่งเปลี่ยนไป | `Incorrect!` | 255 |

แสดงธงที่กู้คืนและเอาท์พุทที่จับ

REA\*เอาท์พุทโปรแกรมต้นฉบับ

```
What is the flag? DUCTF{ezzzpzzz_07bcda7bfe81faf43caa}
Correct!
```

ค่าที่กู้คืนยังตรงกับธงในการเผยแพร่ข้อมูลเมตาความท้าทายของผู้จัดงาน,ตรวจสอบหลังจ


แหล่งที่มาอัตลักษณ์เป้าหมายและรายละเอียดการวิเคราะห์

เพิ่งวิเคราะห์และสองระบวนการจับภาพใน 8 ตุลาคม 2026 ใช้REA4.1.0 กับGhidra12.1.4 บLinuxx64. 86-64 เอลฟ์ 15,248 ไบต์

ปฏิบัติการเดิม · SHA-256

```
dcd3bec4f608e11f3a12ce461100aaf5f621851ee63a1f870d7c90d4e3dd51ae
```

อ้างอิงสตริงฟังก์ชั่นและค่าคงที่ได้รับการตรวจสอบก่อนที่จะอ่านแหล่งที่มาของผู้จัดงานหรือ แก้หลามและแผนภาพที่ถูกสร้างขึ้นจากเหล่านั้น REA กเขา

[เปรียบเทียบกับแหล่งที่มาของผู้จัดงาน](https://github.com/DownUnderCTF/Challenges_2023_Public/blob/b48f83db2984bc7fa2ec7879a32d7efb1be8d333/rev/masked-squares-flag-checker/src/ms_flag_checker.c) · [ท้าทายข้อมูลเมตาและธง](https://github.com/DownUnderCTF/Challenges_2023_Public/blob/b48f83db2984bc7fa2ec7879a32d7efb1be8d333/rev/masked-squares-flag-checker/ctfcli.yaml) · [REA บันทึกหลักฐาน](https://github.com/morluto/rea/blob/main/website/evidence/ctf-masked-squares.md)

## ลองด้วยตัวคุณเอง

ดาวน์โหลดความท้าทายเดิมและแก้ลงในโฟลเดอร์หนึ่ง ใช้พร้อมท์ข้างต้นเพื่อตรวจสอบกับตัวแทนของคุณหรือเรียกใช้สคริปต์ที่รวมอยู่

[ดาวน์โหลดความท้าทายเดิม](https://raw.githubusercontent.com/DownUnderCTF/Challenges_2023_Public/b48f83db2984bc7fa2ec7879a32d7efb1be8d333/rev/masked-squares-flag-checker/publish/ms_flag_checker)[ดาวน์โหลดแก้](https://rea.tools/showcase/ctf/solve.py)

เทอร์มินัล\*แก้ปัญหาและเรียกใช้

```
python3 -m venv .venv
.venv/bin/python -m pip install z3-solver
.venv/bin/python solve.py

chmod +x ms_flag_checker
./ms_flag_checker
```

สคริปต์พิมพ์ธงผู้สมัครวางไว้ที่พรอมต์ของโปรแกรม การแก้ความต้องการงูหลามและ `z3-solver`. การเรียกใช้ความต้องการที่ปฏิบัติการเดิม Linux จำนวน 86-64

[ตั้งค่า REA กับตัวแทนการเขียนโค้ดของคุณ](https://rea.tools/get-started/)