มาเรียนรู้เกี่ยวกับการโจมตีด้วย SYN Flood ใน TCP Protocol กันครับ
ก่อนจะรู้ว่าพวก Attacker มันจะโจมตีได้อย่างไรได้บ้าง เรามาดูว่าใน TCP Protocol มันเริ่มต้นการสื่อสารระหว่าง Host 2 Hosts ได้อย่างไรกันก่อนครับ
การเริ่มต้นการติดต่อด้วย TCP Protocol มีขั้นตอนโดยคร่าวดังนี้:
1. ผู้ส่ง ทำการส่ง Flags = SYN เพื่อขอเริ่มการติดต่อ ผู้รับจะตอบโดยการส่ง Flags = SYN พร้อมกับ ACK เพื่อรับทราบว่าได้รับ SYN จากต้นทาง กระบวนการนี้คือการเขย่ามือ (Handshake) ครั้งที่ 1 โดยผู้รับจะส่ง Flags = SYN/ACK กลับไปหาผู้ส่ง
2. ผู้ส่ง รับ Flags = SYN/ACK และทำการตอบกลับด้วยการส่ง Flags = ACK เพื่อขอจองทรัพยากร เป็นการเขย่ามือ (Handshake) ครั้งที่ 2 เพื่อที่จะสื่อสารกันได้แบบ Connection Oriented (คือ มีการบอกจุดเริ่มต้น Start และจุดจบ End ของการส่งข้อมูลนั่นเอง)
3. ผู้รับ รับ Flags = ACK กลับมา กระบวนการสร้าง Connection เสร็จสมบูรณ์ นี้คือการเขย่ามือ (Handshake) ครั้งที่ 3 และการ สร้าง Connection ถูกสร้างขึ้นแล้ว (Connection Established)
จากรูป OSI 7Layers เทียบกับ TCP/IP Layers ด้านบน การส่งข้อมูลในแต่ละครั้ง จะเริ่มจาก Layer ที่สูง คือ Layer 7 ไล่ลงมา ใน Layer 1 ที่ต่ำสุด แล้วส่งผ่าน Media ต่างๆ เช่น สายแลน , WIFI จากนั้น เมื่อถึงผู้รับ ผู้รับ ก็จะแกะข้อมูลมาอ่าน จาก Layer 1 ไล่ขึ้นไปจนถึง Layer 7 ให้เราเห็นข้อมูลนั้นๆได้ บทความนี้ ผมจะพูดถึง TCP Protocol ซึ่งเราจะเห็นว่าอยู่ใน Layer 4 ซึ่งเราจะมาดูว่ามันเก็บข้อมูลอะไรไว้บ้างนั่นเองครับ
จากรูป TCP Segment Header ซึ่งอยู่ใน Layer 4 Transport จะมีการเก็บข้อมูลต่างๆ โดย Octet แรก หรือ เริ่มจาก
Bit 0–31 จะเก็บ Source port 16 bit / Destination port : 16 bit คือ มีจำนวน ²¹⁶ = 65536 port นั่นเอง เริ่มจากพอร์ท 0–65535
Bit ที่ 32–63 จะเก็บ Sequence number มี ขนาด 32 bit เพราะข้อมูลมีการแบ่งออกเป็นหลายๆ Segment เลขนี้จะใช้เพื่อให้ฝั่งรับ นำไปจัดเรียงข้อมูลชุดนั้นๆ กลับมาได้เหมือนเดิม
Bit ที่ 64–95 จะเก็บ Acknowledgement number มีขนาด 32 bit ใช้สำหรับตอบกลับผู้ส่ง เพื่อยืนยันว่าได้รับข้อมูลที่มี Sequence number นั้นๆแล้ว และบอกกลับให้ผู้ส่ง ด้วย ACK.number เพื่อบอกว่า Sequence number ที่จะส่งครั้งต่อไป สามารถส่งมาได้เลย ซึ่ง Sequence number ต่อไป ก็จะตรงกลับ ACK.number ที่ส่งตอบกลับไปนั่นเอง
Bit ที่ 96–127 โดย 4bit จะใช้เก็บ Data Offset หรือ Header Length คือระบุความกว้างหรือขนาดของ Header ซึ่งในชั้นๆนึง ซึ่ง 4bit จะคือแทนค่าได้ตั้งแค่ 0–15 ชั้นข้อมูล แต่ละชั้นจะมีขนาด 32bits ตัว Data offset นี้จะระบุว่าจะใช้พื้นที่เพื่อเก็บข้อมูล Header นี้กี่ชั้น ซึ่งเล็กสุดคือ 5 ชั้น จบที่ชั้นของ Checksum นั่นคือ 32bits x 5ชั้นข้อมูล = 160bit เอาไป หาร 8bits = 20Byte และสูงสดที่จะอยู่ที่ 15ชั้นข้อมูล ทำให้เก็บได้ 32bits x15ชั้นข้อมูล 480bit คือขนาด TCP Segment Header = 60Byte สูงสุดนั่นเอง ,
ส่วน Reserved bit 4 bits (จากรูป)สงวนไว้ใช้งานในอนาคต ซึ่งตอนนี้ ก็เหลือ 3bits reserved แล้ว เพราะ ถ้าดูจากโปรแกรม Wireshark ตอนนี้ ถูกนำไปใช้ทำ TCP Flags เพิ่มขึ้นมา คือ Flags : Accurate ECN ,
ถัดมาก็จะเป็น Bits ที่ใช้เก็บ TCP Flags ต่างๆ หรือเรียกอีกชื่อว่า Control bits ,
ถัดมาเป็นส่วน Window Size ขนาด 16bits เป็นตัวกำหนดขนาดของ Data ที่ไม่ใช่ Acknowledged ว่าจะรับข้อมูลนั้นได้สูงสุดที่ขนาดเท่าไหร่ มีหน่วยเป็น Byte เป็นการบอกอีกฝั่งที่รับว่า สามารถส่ง Data ขนาด Window Size ที่ไม่เกินนั้น มาได้นะ คือเป็นการบอกจากผู้ส่ง ให้ผู้รับ รับทราบนั่นเองว่าครั้งต่อไปให้ส่งข้อมูลขนาดไม่เกินเท่าไหร่ได้บ้าง เรียกกระบวนการนี้ว่า Flow Contol ขนาดจะปรับเปลี่ยนได้ตลอดขึ้นอยู่กับผู้ส่ง ถ้าผู้ส่ง ส่ง Window Size = 0 ก็หมายความว่า ผู้รับไม่ต้องส่ง Data ใดๆกลับมาแล้วนั่นเอง เพราะผู้รับไม่รับ Data นั้นแล้วสำหรับ Sequence Number นั้นๆ
Bit ที่ 128–159 เป็น Checksum มีขนาด 16Bits ใช้สำหรับตรวจสอบข้อมูลผิดพลาดระหว่างรับส่งข้อมูล ถัดมาเป็น Urgent Pointer ขนาด 16Bits เพื่อชี้ไปยังตำแหน่งสุดท้ายของข้อมูลที่ต้องการส่งแบบเร่งด่วน คือจะถูกใช้งานถ้า TCP Flags bit : URG ถูก Set = 1
ขนาดของ TCP Segment Header โดยทั่วไปจะจบตรงนี้คือมีขนาด 160Bit ซึ่งคือ 20Byte (160/8=20) นั่นเอง
ส่วน Bit ที่ 160–448 จะเก็บพวก Option คือเป็นส่วนที่เหลือๆว่างไว้ของ TCP Segment Header เช่นเอาไว้ใช้เพิ่มขนาดให้มีความยาวเพียงพอกับการใช้งานตามที่ต้องการต่อไป คือจะมาอ่านข้อมูลตรงนี้ต่อเมื่อมีการ Set bit ของ Data offset ให้มากกว่า 5 นั่นเอง
เรามาดูของจริงกันเลยดีกว่าครับ ผมจะทำการเปิดเว็บ www.ntplc.co.th เรามาว่าดูมันเป็นไปตามทฤษฎีหรือไม่ โดยใช้โปรแกรม WireShark เพื่อ Capture Packet ออกมาดูกันครับ
1. ผมทำการเปิด Web Browser เพื่อเข้าเว็บ www.ntpcl.co.th จากนั้นผมใช้โปรแกรม Wireshark เพื่อดูข้อมูล Packet จะเห็นว่า Packer แรกนั้น Src.IP จะเป็นเครื่องของผมเอง ส่วน Dest.IP จะเป็น IP ของ Web Server ของ www.ntplc.co.th
TCP Protocol อยู่ใน Transport Layer คือ Layer 4 ใน OSI 7Layers Model มีหน่วยเป็น Segment จะเห็นว่าเครื่องผู้ส่ง คือเครื่องผมเอง ได้ร้องขอเพื่อสร้าง Connection เครื่องผมก็จะทำการสร้าง TCP Segment ขึ้นมาและทำการสุ่ม Source Port จากรูปคือ Source port number : 52295 และ Destination Port จะเป็น port 443 ซึ่งเป็นพอร์ทมาตรฐานของ https:// โดยระบุ Sequence number = 0 และระบุว่าลำดับถัดไปคือจะส่ง Next Squence number = 1 นะ และระบุ Len (TCP Segment Len)= 0 ก็คือ ไม่มี Data อื่นๆส่งไปด้วยนั่นเอง เพราะนี่เป็นการทำ Handshake เพื่อร้องขอเปิด Connection เท่านั้น
จากนั้นก็ทำการระบุ TCP Flags bit = 0000 0000 001(SYN)0 หมายความว่าตำแหน่ง Bit ของ SYN = 1 คือ การร้องขอเพื่อสร้าง Connection (Connection establish request) โดยใส่ข้อมูลพวกนี้ลงไปในสิ่งที่เรียกว่า TCP Segment Header
คือเลข Seq.number ที่เห็น 0 , 1 , 2 .. nn (relative sequence number) อะไรพวกนี้ เป็นเลขที่โปรแกรม WireShark แปลงมาแล้วเพื่อให้มนุษย์อย่างเราดูได้ง่าย แต่จริงๆแล้ว อุปกรณ์มันคุยกันด้วย Sequence number (raw) ตามรูปด้านบนครับ
2. เมื่อ Web Server ของ www.ntpcl.co.th ได้รับ TCP Segment นี้เข้ามา จากนั้นก็จะทำการส่ง TCP Segment กลับไปเช่นกัน โดยระบุ Source port คือ 443 และ Destination port เป็น 52295 (ซึ่งเป็น Source port ของเครื่องผมเอง) โดยจะทำการส่ง Flags : ACK กลับไปด้วย ACK Seq.number = 0+1 ซึ่ง 0 ก็คือ SYN Seq.number จากผู้ส่งนั่นเอง เพื่อแจ้งให้ผู้ส่งทราบว่า พร้อมแล้วที่จะรับ Sequence number ถัดไป ให้ส่ง TCP Segment ที่มี Sequence number = 1 มาได้เลย จะได้จับคู่กันถูก Session พร้อมกันนั้น Web Server ก็ได้ส่ง SYN กลับไปใหม่ด้วย โดยระบุ SYN Seq.number = 0 ขึ้นมาใหม่ เพื่อแจ้งกลับไปว่า Web Server ทางนี้ก็รับทราบการร้องขอเปิด Connection จากผู้ส่งแล้ว ดังนั้น Sequence number ถัดไปที่ Web Server จะส่งไปอีกก็คือ Next sequence number = 1 ถ้า Web Browser ได้รับ ก็ให้ส่ง ACK.seq.number=1 เพื่อยืนยันกลับมาด้วย ( Connection establish acknowledge ) TCP Flags bit จะเท่ากับ 0000 0001(ACK) 001(SYN)0 และค่า Len ยังคง = 0 คือ ไม่มี Data อื่นๆส่งไปด้วยนั่นเอง เพราะนี่เป็นการทำ Handshake เพื่อร้องขอเปิด Connection เท่านั้น
3. เมื่อเครื่องของผม Web Browser ได้รับ TCP Segment กลับมาจะเห็นว่า Web Server ส่ง ACK.seq.number=1 มาให้ นั่นก็คือ Web Server พร้อมที่จะรับ Sequence number = 1 ของเราแล้ว และ Web Server ก็ส่ง SYN sequece number = 0 มาด้วย เพื่อรับทราบการขอเปิด Connection ด้วยเช่นกัน ดังนั้น เมื่อเรา Web Browser ได้รับ SYN.seq.number=1 มา ก็จะส่ง Flags : ACK กลับไป โดยระบุ ACK Seq.number = SYN Seq.number (จากที่ Web Server ส่งกลับมา) + 1 = 0+1 = 1 เพื่อแจ้งกลับ Web Server ว่า พร้อมแล้วที่จะรับ Next Sequence number ของ Web Server แล้วนะ ซึ่งก็คือ รับทราบว่าการจองทรัพยากร ต่างๆของ Connection นี้นั้นเสร็จแล้ว และค่า Len ยังคง = 0 คือ ไม่มี Data อื่นๆส่งไปด้วยนั่นเอง เพราะนี่เป็นการทำ Handshake เพื่อร้องขอเปิด Connection เท่านั้น จากนั้นก็จะสามารถส่งข้อมูลผ่าน Connection นี้ไปได้เรื่อยๆ
โดยมีการตรวจสอบ Sequence number กันไปตาม TCP Segment ของข้อมูลไปเรื่อยๆ เพื่อการประกอบข้อมูลกลับมาได้ถูกต้อง ตามรูปด้านบน จะเห็นว่า มีการระบุ Next Sequence number กันไปมา และมีการตอบรับ ACK number ที่ถูกต้องว่าเป็นของข้อมูลชุดใดนั่นเอง คือการระบุ ACK number กลับไป ก็เพื่อบอกกลับไปว่า พร้อมที่จะรับ Sequence number นั้นๆได้นั่นเอง ขั้นตอนถัดไปคือ ก็ให้ส่ง Sequence number นั้นๆมาได้เลย
เราจะเห็นว่ามี field ที่ชื่อว่า Len (TCP Segment Len) ด้วย คือเอาไว้ระบุขนาดของ Data ที่ส่งไปในครั้งนั้นๆนั่นเองมีหน่วยเป็น Byte
จากรูปคือจะเห็นว่า Frame ที่ 60 มีขนาด TCP Segment Len = 1380 ฉะนั้นหากเมื่อ TCP Segment นี้มี Sequence number = 1381 ผู้ที่ส่ง Frame นี้ก็จะใช้ TCP Segment Len = 1380 bytes ดังนั้น Next Sequence number ก็จะต้องเป็น 1381(SEQ.No.)+1380(Len) = 2761 นั่นเอง ฉะนั้น เมื่อผู้รับ ได้รับ TCP Segment นี้ คือ Frame ที่ 62 ตามรูปด้านบน ก็จะระบุ ACK.seq.number คือ 2761 เพื่อส่งกลับไปว่า พร้อมแล้วที่จะรับ Sequence number = 2761 ใน TCP Segment ถัดไปนั่นเอง กระบวนการก็ส่งข้อมูลกันไปมาตาม Application จนครบถ้วนของข้อมูลที่รับส่งกัน จนกว่า Connection จะ timeout หรือมีการส่ง flag อื่นๆเข้ามาใหม่เพื่อตัด Connection นี้
เมื่อมีการเริ่มรับส่งข้อมูลกัน เราจะเห็นขนาดของ Window Size ระบุไว้ด้วยใน TCP Segment Header
จากรูปด้านบน เราจะเห็นว่า Frame ที่ 60 ผู้ส่ง ส่งขนาด Window Size = 261632 Bytes ออกไปบอกผู้รับ ก็คือ ผู้ที่จะส่ง Data ใดๆกลับมา เพื่อระบุว่า ส่ง Data มาแต่ละครั้งอย่าให้เกินค่านี้นะ ซึ่งเป็นการทำ Flow Control นั่นเอง ในความเป็นจริง ไม่เกินอยู่แล้ว เพราะจะส่งแต่ละ Frame ได้ จะส่งไม่เกินค่า Default MTU คือ 1500Btyes นั่นเอง
การแก้ปัญหานี้ ฝั่งผู้รับก็อาจระบุ Window Size = 0 กลับไปเพื่อบอกว่าหยุดส่งข้อมูลชุดนี้ก่อนนะ เดี๋ยวร้องขอไปใหม่ จะส่ง Window Size กลับไปใหม่นะ ฝั่งผู้ส่ง ถึงจะส่งข้อมูลชุดใหม่มาได้ และที่กล่าวมานี้ก็คือเป็นการทำ Flow Control นั่นเอง
การทำ Flow Control ใน TCP (Transmission Control Protocol) คือการจัดการและควบคุมการส่งข้อมูลระหว่าง Host ที่เชื่อมต่อกันผ่าน TCP/IP network โดยเฉพาะในกรณีที่ความเร็วในการรับส่งข้อมูลของเครื่องปลายทางไม่สามารถทำงานได้เท่ากับความเร็วที่ส่งข้อมูลมา หรือมีการแจ้งว่า Buffer ที่เครื่องปลายทางสามารถรับข้อมูลได้น้อยลงก็จะมีการระบุ Window Size ไปบอกฝั่งผู้ส่งในการตอบกลับ ACK ของ Sequence นั้นๆที่รับมา
TCP Retransmission เมื่อได้รับข้อมูลไม่ครบก็ต้องทำการส่ง TCP Segment กันใหม่
TCP protocol จะมีการเก็บ Caches ทุกๆ Segment โดยจะกำหนดช่วงเวลาจะที่รอ TCP Segment ของอีกฝั่งตอบ flags : ACK กลับมา เมื่อหมดเวลาก็จะ Timeout จากน้้นฝั่งส่ง ก็จะทำการส่งข้อมูลไปให้ใหม่ ก็คือการทำ Retransmission นั่นเอง กล่าวคือ จะส่ง TCP Segment ไปใหม่ หากไม่ได้รับ flags: ACK กลับมาในช่วงเวลา Timeout ที่กำหนด
1. จากรูปด้านบนจะเห็นว่า Alice ทำการส่งข้อมูลขนาด 200bytes ที่มี Sequence number = 1501
2. ฝั่ง Bob ก็ส่ง flags : ACK กลับมาเพื่อรับทราบว่าได้รับข้อมูลแล้ว และระบุ ACK Sequence number = 1701 กลับมา
3. เมื่อ Alice ได้รับ TCP Segment ที่ Bob ส่งก็เห็นว่า Bob ตอบ ACK มาแล้ว แสดงว่าได้รบข้อมูล 200Bytes ที่ Alice ส่งไปให้แล้ว จากนั้น Alice ก็ส่งข้อมูลชุดต่อไปให้อีกเพราะต่อเนื่องกัน โดยใส่ Sequence number = 1701 เนื่องจากเป็นข้อมูลชุดเดียวกัน และเป็นเลขเดียวกับ ACK Sequence number ที่ Bob ส่งมาว่า พร้อมที่จะรับ Sequence number = 1701 ดังนั้น Alice ก็จะส่งข้อมูลต่อเนื่องที่มี Sequence number = 1701 ไปให้
4. เมื่อ Alice ส่งออกไปแล้ว แต่ Alice ก็รอ แต่รอไปแล้ว ไม่ได้รับ flags : ACK จาก Bob กลับมา จะด้วยเหตุผลใดๆก็ตาม Alice ไม่ทราบได้
5. Alice จึงทำการส่งไปใหม่ ก็เช่นเดิมระบุ Sequence number = 1701 ไปเหมือนเดิม
6. ทีนี้ Bob ได้รับ และส่ง flags : ACK กลับมาได้แล้ว จน Alice ได้รับแล้ว และพร้อมจะส่งข้อมูลที่มี Sequence number ที่ Bob ต้องการได้ต่อๆไป
จะเห็นว่า การ Restransmission นี้ ก็เป็นกระบวนการของ TCP Protocol ที่ทำให้มีความน่าเชื่อถือ ยืนยันได้แน่นอนว่า ข้อมูลไม่มีหายระหว่างทาง เพราะถ้าหาย ก็จะส่งไปไปเรื่อยๆ จนกว่า ปลายทางจะได้รับข้อมูลนั้นนั่นเอง
เมื่อมีการสร้าง Connection Establish ก็ต้องมีการ Disconnection หรือ หยุดการเชื่อมต่อนั่นเอง แล้วมันทำอย่างไรหละ?
ในกระบวนการยุติการเชื่อมต่อ TCP Protocol (Transmission Control Protocol) ใน TCP Segment Header จะมี flags ที่ชื่อว่า FIN ใช้สำหรับเพื่อขอยุติการเชื่อมต่อ ซึ่งจะช่วยให้แต่ละโฮสต์สามารถยกเลิกการเชื่อมต่อของตนเองได้
FIN (Finish): คือ flag ที่ใช้ในการปิดการเชื่อมต่อ โดยในขั้นตอนมีดังนี้ :
- โฮสต์ที่ต้องการยุติการเชื่อมต่อ จากตัวอย่างในรูป ผู้ส่งคือ IP: 192.168.1.7 จะส่ง TCP segment ที่มี Flags bit : FIN ตั้งค่าเป็น 1 ไปยัง โฮสต์ปลายทาง IP: 20.189.173.14 จากรูป Packet Capture ด้านบนจะเห็นว่ามีการส่ง flags: FIN ออกไป มีเลข Sequece number = 1873 และระบุ ACK.Seq.number = 7045 ไปด้วย เพื่อบอกว่า ถ้ารับทราบ FIN ที่ส่งไปนี้ ให้ส่ง TCP Segment flags: ACK ที่มีเลข Sequence number = 7045 นี้กลับมานะ ส่วน Len = 0 เพราะไม่มีการส่งข้อมูลใดๆไปแล้ว
2. จากนั้น IP: 20.189.173.14 จะรอรับ TCP segment จาก IP: 192.168.1.7 ที่มีการยืนยันระบุ Flags : ACK sequence number = 7045 ดังนั้นเมื่อ IP: 20.189.173.14 ได้รับ TCP Segment ดังกล่าว ก็จะรับทราบการร้องขอจบ Connection ( initiates the connection closing) จาก IP: 192.168.1.7
จึงทำการส่ง TCP Segment Flags : FIN ที่มี Sequence number = 7045 กลับไปเพื่อบอกว่าพร้อมแล้วที่จะจบ Connection นี้เช่นกัน และระบุ ACK sequence number = 1874 ไปด้วย เพื่อบอกว่าถ้า IP: 192.168.1.7 ได้รับ TCP Segment นี้ ให้รับทราบ flags : FIN ที่ส่งกลับไปด้วยนะ ถ้ารับทราบ ก็ตอบ Flags : ACK ที่มี Sequence number = 1874 กลับมาด้วย
3. เมื่อ IP: 192.168.1.7 ได้รับ TCP Segment จาก IP: 20.189.173.14 กลับมา ที่ส่ง Flags : FIN มาด้วย ก็จะรับทราบการจบ Connection นี้โดยสมบูรณ์ โดยจะส่ง Flags : ACK ที่มี Sequence number = 1874 กลับไป และระบุ ACK Sequence number กลับไปด้วย ว่าถ้าจะส่ง TCP Segment ใด หรือ ขอเปิด Connection ใหม่ ใดๆต่อจากนี้ ให้เริ่มส่งมาจาก Sequence number = 7046 ได้เลย เช่น ถ้า เครื่อง IP: 20.189.173.14 จะขอส่ง SYN เปิดขอเปิดทำ 3 Way handshake ก็ต้องส่ง flags: SYN ที่มี Sequence number = 7046 มาให้ IP: 192.168.1.7 นั่นเอง
อีก flag ที่ใช้บ่อยในการจบ Connection ก็จะมี flags: RST
flags: RST เป็นการหยุดการเชื่อมต่อแบบทันที เช่น จากรูป Client คือก่อนหน้านี้ ผมใช้โปรแกรมเชื่อมต่อไปยัง Server และได้ทำการปิดโปรแกรม กดออกโปรแกรมไปเลย จะเห็นว่าใน TCP Segment ก็จะส่ง flag RST ไปให้ Server โดยระบุ Window = 0 ด้วย เพราะจะไม่รับข้อมูลใดๆกลับมาแล้ว คือบอกว่า ไม่ต้องส่งอะไรกลับมาแล้วนั่นเอง คือ Connection ถูก Reset จนกว่า Client จะเริ่มส่ง flag SYN ไปใหม่นั่นเอง ซึ่ง flag RST นี้ก็จะเอาไว้ใช้ใน การป้องกันการเชื่อมต่อ SYN Flooding: SYN Flooding ได้ด้วย คือจะเป็นการส่ง flag RST กลับไปหา Attacker เพื่อปฏิเสธการเชื่อมต่อทันที.
กระบวนการของ TCP Protocol ทั้งหมดนี้ ก็คือรูปแบบที่เราเรียกว่า Connection Oriented นั่นเอง
ทำไมต้องมีเลข Sequence number ?
เมื่อเราต้องการส่งข้อมูลขนาดใหญ่ผ่านเครือข่าย, เราไม่สามารถส่งไปได้ในครั้งเดียวเนื่องจากมีข้อจำกัดของค่าค่านึงที่เรียกว่า MTU (Maximum Transmission Unit) ที่กำหนดไว้ว่าข้อมูลต่างๆที่จะส่งไปใน 1 ครั้ง ไม่สามารถส่งเกินขนาดของ 1MTU ได้ ซึ่งในระบบ Ethernet ตามค่า default (ซึ่งแน่นอนมันปรับแต่งได้) จะส่งได้สูงสุดต่อครั้งที่ 1500 Bytes (คือถ้าขนาดเกิน 1500Bytes จะเรียกว่า Jumbo frame สูงสุดที่ 9000Bytes ซึ่งโดย default เราจะไม่ได้ใช้งานครับ)
การรับส่งข้อมูลผ่าน Ethernet protocol นั้น ข้อมูลจะถูกแบ่งออกเป็นชิ้นส่วนขนาด 1500 Bytes เพื่อส่งผ่านสาย LAN, Wireless, Fiber Optic หรือ Media อื่น ๆ ปัญหาที่เกิดขึ้นคือแต่ละ Layer ก็จะมี Header ของตัวเอง, เช่น TCP Header ก็จะมีพวก Src.Port Dst.Port และ IP Header ก็จะมีพวก Src.IP Dst.IP รวมถึง Ethernet Frame ใน Layer 2 ก็จะมี Src.MAC Dst.MAC ที่ต้องถูกเพิ่มลงไป ทำให้เหลือที่ว่างที่จะขนข้อมูลได้เพียงไม่เกินครั้งละ 1460 Bytes
การที่ข้อมูลจะถูกส่งไปต่อ, ข้อมูลจะต้องถูกแปะ TCP, IP Headers , และกลายเป็น Ethernet Frame ใน Layer 2 และลง Layer 1 ต่อไป . ด้วยข้อจำกัดนี้, หากเราจะส่งข้อมูลใดๆที่เริ่มจากตั้งแต่ใน Application Layer ไล่ลงมา TCP Layer (Transport) -> IP Network Layer ต้องรวมกันไม่ให้เกิน 1500 Bytes ถ้าเกินก็ต้องหั่นเป็นชิ้นๆ เราเรียกมันว่า การทำ Fragmentation พอไปถึงปลายทาง ก็เอาข้อมูลที่ส่งมาทีละชิ้น มาประกอบเข้ากันใหม่
ในกระบวนการ Fragmentation นี้ ทุกชิ้นข้อมูลจะถูกกำหนด TCP Sequence Number เพื่อระบุลำดับของข้อมูล. เมื่อข้อมูลถึงเครื่องปลายทางแล้ว ผู้รับ ก็ดู TCP Header เพื่อดู Sequence Number ว่าเลขอะไร เพื่อนำไปประกอบร่างข้อมูลที่แสดงออกมาได้ถูกต้องต่อไป
ดังนั้น TCP Sequence Number จึงเป็นสิ่งสำคัญในการสื่อสารด้วย TCP/IP Protocol ช่วยให้ข้อมูลถูกส่งผ่านเครือข่ายได้อย่างเรียงลำดับและและประกอบรวมกันถูกต้องเมื่อถึงปลายทาง
การโจมตีด้วย SYN Flood ใน TCP Protocol
จากข้างต้น เราได้ทำการความเข้าใจเบื้องต้นเกี่ยวกับการทำงานในกระบวนการ 3Ways Handshake ไปด้วยเพื่อสร้าง Connection ในการติดต่อสื่อสารบน TCP Protocol ซึ่ง Synflood จะอาศัยกระบวนการ 3 Way Handshake ในการโจมตีเครื่องปลายทาง
การโจมตีด้วย SYN Flood นั้น คือการที่
Flags = SYN จะไปจองหน่วยความจำเพื่อทำการสร้างคิวในการเชื่อมต่อ ถ้ามี SYN ถูกส่งเข้ามามาก จะทำให้คิวที่มีอยู่ไม่พอ ส่งผลให้ Server หรือ Host ปลายทาง ไม่สามารถสร้าง Connection ระหว่างกันได้ ทำให้ Server ดังกล่าวที่ถูกโจมตีมานั้นไม่สามารถให้บริการเครื่องต้นทางที่ร้องขอได้ คือเปิด Connection ไม่ได้นั่นเอง
1. จากรูปด้านบน Client ส่ง TCP segment Flags = SYN ซึ่งจะระบุเลข Sequence number มาด้วย สมมติเลข Sequence number ของ Flags: SYN ที่ส่งมาคือ = m = 0 ซึ่งตามหลัก ก็จะรุบ ACK sequence number มาด้วย ปกติจะเริ่มเลขเดียวกันกับ Sequence number ของ Flags : SYN คือ = 0
2. Server จะตอบสนอง Client Connection establish request ด้วย TCP Flags = SYN = n = 0 (คือ 0 คนละตัวกับ SYN ที่ส่งมานะครับ) กลับมาเช่นกัน เพราะฝั่ง Clients ขอเปิด Connection แล้ว ฝั่ง Server ก็ต้องรับทราบและขอเปิด Connection กลับไปด้วยเช่นกัน และก็ส่งกลับ flags: ACK เพื่อรับทราบ SYN ที่ส่งมา และระบุ ACK sequence number ด้วยเลข m+1 = 0+1 เพื่อบอกต้นทางว่า พร้อมรับ Sequence ถัดไปแล้ว ถ้า Client จะส่ง Flags ใดๆกลับมาให้ระบุ Sequence number = 1 นะ เพื่อเป็นการระบุว่า เป็นการคุยกันของการทำ 3 Way Handshake นี้
3. เมื่อ Clients ได้รับ SYN,ACK กลับมา ตามปกติต้องส่ง flags : ACK ที่ระบุ Sequence number = 1 กลับไปให้ Server แต่ Clients นั้นด้วยที่ว่าเป็นตัว Attacker ไม่ยอมส่ง flags : ACK ที่มี Sequence number = 1 กลับไปให้ Server แต่กลับกัน Client ก็ดันส่ง SYN กลับไปใหม่เป็น SYN ไปใหม่เรื่อยๆ
4. ทำให้ Server ก็ได้รับ SYN ใหม่ Server ก็ต้องตอบกลับไปด้วย SYN/ACK แต่จะใช้ ACK Sequence number = 1 กลับไปไม่ได้แล้ว เพราะว่า มันถูกจองไว้ให้ SYN ก่อนหน้านี้แล้ว Server ก็ต้องระบุ ACK Sequence number ใหม่กลับไปให้ อาจเป็น ACK Sequence number 1,2,3…n ไปเรื่อยๆ
5. ถึงจุดนี้ ถ้า Client Attacker ยังส่ง flags : SYN โดยการ Flood มาเรื่อยๆ ทำให้ Server ส่ง SYN/ACK ตอบกลับไปเรื่อยๆ ก็จะทำให้ หน่วยความจำ หรือ ทรัพยากรของเครื่อง Server นั้นเต็มขีดความสามารถ ทำให้ไม่สามารถตอบ SYN/ACK กลับไปได้แล้ว ส่งผลให้ให้บริการต่างๆบน Server นั้นใช้ไม่ได้
6. เมื่อมี Clients ตัวอื่นที่ไม่ใช่ Attacker ต้องการจะติดต่อ Server ดังกล่าว ก็จะติดต่อไม่ได้แล้ว เพราะไม่มีหน่วยความจำพอที่จะใช้ในการสร้าง SYN/ACK กลับไปได้แล้วนั่นเอง
7. ซึ่งการป้องกันตรงนี้ ในยุคนี้ก็อยู่ในพวกอุปกรณ์ Firewall หรือ Software Security ต่างๆที่มีฟังก์ชั่นในการ Detect TCP Flags พวกนี้ว่า มีการส่ง SYN Seq.number เข้ามาโดยผิดปกติหรือไม่ ถ้าตรวจพบก็ทำการแก้ไข ป้องกันหรือบล็อคได้ต่อไป
— — — — — — — — — — — — — — — — — — — — — — — — — — — — — —
TCP Protocol ในความเข้าใจของผมก็มีเนื้อหาประมาณที่เล่ามาครับ หากท่านผู้อ่านอยากเรียนรู้ เข้าใจแบบลึกๆแบบละเอียดๆไปอีก สามารถอ่านเพิ่มเติมได้ในเอกสาร RFC 793 ได้ครับ
— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —
References :
— https://www.ccnahub.com/ip-fundamentals/understanding-tcp-and-udp-protocols/
— https://www.youtube.com/watch?v=JFch3ctY6nE
— https://www.youtube.com/watch?v=jE_FcgpQ7Co
— https://www.youtube.com/watch?v=2QGgEk20RXM
— https://www.youtube.com/watch?v=wMc0H22nyA4
— https://www.geeksforgeeks.org/what-is-transmission-control-protocol-tcp/
— https://www.javatpoint.com/tcp
— https://en.wikipedia.org/wiki/Transmission_Control_Protocol
— https://www.ibm.com/docs/hu/aix/7.1?topic=protocol-tcpip-protocols
— https://www.techtarget.com/searchnetworking/definition/TCP-IP
— https://www.ibm.com/docs/en/aix/7.1?topic=management-transmission-control-protocolinternet-protocol
— https://gaia.cs.umass.edu/kurose_ross/ppt.php
