ดาวน์โหลด cheat extreme hack สำหรับ cs go สูตรโกงสำหรับ CS:GO ExtrimHack เหตุใดจึงต้องมีกลโกง?

อัปเดตแล้ว

แฮ็คสุดขีดสำหรับ cs go

• เอมบอท

  - การกำหนดเป้าหมายอัตโนมัติไปที่ร่างกาย ศีรษะ ขา ขึ้นอยู่กับว่าคุณกำหนดค่าอย่างไร

• วอลล์แฮ็ค

  - คุณสามารถมองเห็นศัตรูผ่านกำแพงได้

• ทริกเกอร์บอท

  - ยิงอัตโนมัติเมื่อเล็งไปที่ศัตรู

เปิดตัวโกง:

• เปิด cs go
• เปิดตัวแฮ็คสุดขีดสำหรับ cs go
• เปิดใช้งานสูตรโกงในเกมโดยใช้ปุ่ม "Insert" หรือ "SHIFT + F5"

แฮ็คสุดขีดสำหรับ cs go

ทำการโจมตี DoS โดยใช้การชนกันของแฮช

สารละลาย

เท่าที่ฉันจำได้ หัวข้อของการโจมตี DoS ใน Easy Hack ได้ถูกนำเสนออย่างเต็มที่ในงานที่หลากหลาย - อย่างน้อยก็การโจมตีหลักทั่วไป แต่ไม่ฉันจำอย่างอื่นได้ ดังนั้นพบกับ Hash Collision DoS ฉันจะบอกทันทีว่าหัวข้อนี้ค่อนข้างกว้างและครอบคลุมแง่มุมต่างๆ มากมาย ดังนั้นเราจะเริ่มต้นด้วยทฤษฎีทั่วไปโดยสรุป

ดังนั้น แฮชเป็นผลมาจากฟังก์ชันแฮชบางตัว (หรือที่รู้จักกันในชื่อฟังก์ชันการบิด) ซึ่งไม่มีอะไรมากไปกว่า "การแปลงโดยใช้อัลกอริธึมที่กำหนดขึ้นของอาร์เรย์ข้อมูลอินพุตที่มีความยาวตามอำเภอใจไปเป็นสตริงบิตเอาท์พุตของค่าคงที่ ความยาว” (อ้างอิงจาก Wiki) นั่นคือเราให้เป็นอินพุต ตัวอย่างเช่น สตริงที่มีความยาวเท่าใดก็ได้ และรับความยาวที่แน่นอนเป็นเอาต์พุต (ตามความลึกของบิต) ในกรณีนี้ สำหรับบรรทัดอินพุตเดียวกัน เราจะได้ผลลัพธ์เดียวกัน สิ่งนี้ค่อนข้างคุ้นเคยสำหรับเราทุกคน: ประกอบด้วย MD5, SHA-1 และเช็คซัมต่างๆ (CRC)

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

อีกคำถามหนึ่งคือวิธีรับค่าอินพุตที่จะนำไปสู่การชนกัน สำหรับฟังก์ชันแฮชที่ทนต่อการเข้ารหัสลับ (เช่น MD5, SHA-1) ตามทฤษฎีแล้ว การแจงนับโดยตรงของค่าอินพุตที่เป็นไปได้เท่านั้นที่จะช่วยเราได้ แต่ฟังก์ชั่นดังกล่าวช้ามาก ฟังก์ชันแฮชที่ไม่ใช่การเข้ารหัสมักจะคำนวณค่าอินพุตที่ทำให้เกิดการชนกัน (เพิ่มเติมเกี่ยวกับเรื่องนี้ในสองสามย่อหน้า)

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

ภาษาโปรแกรมสมัยใหม่ส่วนใหญ่ (PHP, Python, ASP.NET, JAVA) ค่อนข้างแปลกที่มักใช้ฟังก์ชันแฮชที่ไม่ใช่การเข้ารหัสเป็นการภายใน แน่นอนว่าเหตุผลนี้เป็นอย่างมาก ความเร็วสูงหลัง. หนึ่งในแอปพลิเคชันทั่วไปคืออาเรย์แบบเชื่อมโยงหรือที่เรียกว่าตารางแฮช ใช่ ใช่ สิ่งเดียวกันนั้นคือการจัดเก็บข้อมูลในรูปแบบ "คีย์-ค่า" และเท่าที่ฉันรู้ แฮชนั้นคำนวณจากคีย์ ซึ่งต่อมาจะกลายเป็นดัชนี

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

และหากตอนนี้เราจำได้ว่าเราสามารถคำนวณจำนวนคีย์ (n) ได้ตามต้องการ ซึ่งแต่ละคีย์จะนำไปสู่การชนกัน ดังนั้นในทางทฤษฎีการเพิ่มองค์ประกอบ n (คีย์ - ค่า) จะต้องมีค่าใช้จ่าย O(n^2) ซึ่ง จะนำเราไปสู่ ​​DoS ที่รอคอยมานานได้

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

ดังที่ได้กล่าวไปแล้ว สำหรับคำถามแรก เราสามารถคำนวณได้ ภาษาส่วนใหญ่ใช้รูปแบบหนึ่งของฟังก์ชันแฮชเดียวกัน สำหรับ PHP5 นี่คือ DJBX33A (จาก Daniel J. Bernstein, X33 - คูณด้วย 33, A - นอกจากนี้นั่นคือบวก)

อินไลน์แบบคงที่ ulong zend_inline_hash_func (const char *arKey, uint nKeyLength) ( ลงทะเบียน ulong hash = 5381; for (uint i = 0; i< nKeyLength; ++i) { hash = hash * 33 + arKey[i]; } return hash; }

อย่างที่คุณเห็นมันง่ายมาก เราใช้ค่าแฮชคูณด้วย 33 แล้วบวกค่าของสัญลักษณ์หลัก และสิ่งนี้จะเกิดขึ้นซ้ำสำหรับอักขระหลักแต่ละตัว

Java ใช้สิ่งที่คล้ายกันเกือบ ข้อแตกต่างเพียงอย่างเดียวคือค่าแฮชเริ่มต้นเป็น 0 และความจริงที่ว่าการคูณเกิดขึ้นด้วย 31 แทนที่จะเป็น 33 หรือตัวเลือกอื่น - ใน ASP.NET และ PHP4 - DJBX33X นี่ยังคงเป็นฟังก์ชันเดิม แต่แทนที่จะเพิ่มด้วยค่าของสัญลักษณ์คีย์ จะใช้ฟังก์ชัน XOR (ด้วยเหตุนี้ X ที่ส่วนท้าย)

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

แฮช(Line1)=แฮช(Line2) แฮช(xxxLine1zzz)=แฮช(xxxLine2zzz)

ตัวอย่างเช่น จากสตริง Ez และ FY ซึ่งมีแฮชเดียวกัน เราสามารถรับ EzEz, EzFY, FYEz, FYFY ซึ่งแฮชชนกันเช่นกัน

อย่างที่คุณเห็น เราสามารถคำนวณค่าจำนวนเท่าใดก็ได้อย่างรวดเร็วและง่ายดายด้วยค่าแฮช DJBX33A เดียว คุณสามารถอ่านเพิ่มเติมเกี่ยวกับรุ่นได้

เป็นที่น่าสังเกตว่าสำหรับ DJBX33X (นั่นคือด้วย XOR) หลักการนี้ใช้ไม่ได้ผลซึ่งเป็นตรรกะ แต่มีแนวทางที่แตกต่างออกไปซึ่งช่วยให้คุณสามารถสร้างการชนกันจำนวนมากได้แม้ว่าจะต้องใช้ต้นทุนจำนวนมากเนื่องจาก กำลังดุร้ายในปริมาณเล็กน้อย อย่างไรก็ตาม ฉันไม่พบการใช้งานจริงของเครื่องมือล็อค DoS สำหรับอัลกอริทึมนี้

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

ในความเป็นจริง ทุกอย่างเป็นเรื่องง่าย: เราจำเป็นต้องค้นหาตำแหน่งในแอปพลิเคชันที่มันจะสร้างอาร์เรย์ดังกล่าวสำหรับข้อมูลอินพุตของเราโดยอัตโนมัติ ที่สุด วิธีการสากลกำลังส่งคำขอ POST ไปยังเว็บเซิร์ฟเวอร์ “ภาษา” ส่วนใหญ่จะเพิ่มพารามิเตอร์อินพุตทั้งหมดจากคำขอลงในอาเรย์ที่เชื่อมโยงโดยอัตโนมัติ ใช่ ใช่ มันเป็นตัวแปร $_POST ใน PHP ที่ให้การเข้าถึงมัน อย่างไรก็ตาม ฉันอยากจะย้ำว่าโดยทั่วไปแล้ว เราไม่สนใจว่าตัวแปรนี้จะถูกใช้ (เพื่อเข้าถึงพารามิเตอร์ POST) ในสคริปต์/แอปพลิเคชันหรือไม่ (ข้อยกเว้นน่าจะเป็น ASP.NET) เนื่องจากสิ่งสำคัญคือ เว็บเซิร์ฟเวอร์ส่งพารามิเตอร์ไปยังตัวจัดการภาษาเฉพาะ และพารามิเตอร์เหล่านั้นจะถูกเพิ่มลงในอาเรย์ที่เชื่อมโยงโดยอัตโนมัติ

ตอนนี้ตัวเลขบางส่วนเพื่อยืนยันกับคุณว่าการโจมตีนั้นรุนแรงมาก มาจากปี 2011 แต่สาระสำคัญไม่ได้เปลี่ยนแปลงมากนัก บนโปรเซสเซอร์ Intel i7 ใน PHP5 การชนกัน 500 KB จะใช้เวลา 60 วินาทีบน Tomcat 2 MB - 40 นาทีสำหรับ Python 1 MB - 7 นาที

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

โดยทั่วไป ช่องโหว่ที่เกี่ยวข้องกับการชนกันในฟังก์ชันแฮชและการใช้ประโยชน์จากช่องโหว่เหล่านี้ได้เกิดขึ้นตั้งแต่ต้นทศวรรษ 2000 สำหรับภาษาต่างๆ แต่สิ่งนี้โจมตีเว็บอย่างหนักในปี 2554 หลังจากการตีพิมพ์งานวิจัยเชิงปฏิบัติจากบริษัท n.runs ผู้ขายได้ปล่อยแพตช์ต่างๆ ออกมาแล้ว แม้ว่าต้องบอกว่าการเจาะเกราะยังสูงอยู่ก็ตาม

ฉันต้องการดึงความสนใจว่าผู้ขายพยายามปกป้องตนเองอย่างไร และเหตุใดบางครั้งจึงไม่เพียงพอ จริงๆ แล้วมีสองแนวทางหลัก ประการแรกคือการใช้การป้องกันระดับภาษา “การป้องกัน” ประกอบด้วยการเปลี่ยนฟังก์ชันแฮช กล่าวอย่างแม่นยำยิ่งขึ้นคือมีการเพิ่มองค์ประกอบแบบสุ่มเข้าไป โดยไม่รู้ว่าเราไม่สามารถสร้างคีย์ใดเพื่อสร้างการชนกันได้ แต่ไม่ใช่ผู้ขายทุกรายที่เห็นด้วยกับสิ่งนี้ เท่าที่ฉันรู้ Oracle ละทิ้งการแก้ไขใน Java 1.6 และแนะนำการสุ่มจากกลางสาขาที่ 7 เท่านั้น Microsoft ได้ดำเนินการแก้ไขใน ASP.NET ตั้งแต่เวอร์ชัน 4.5 แนวทางที่สอง (ซึ่งใช้เป็นวิธีแก้ปัญหาชั่วคราวด้วย) คือการจำกัดจำนวนพารามิเตอร์ในคำขอ ใน ASP.NET คือ 1,000 ใน Tomcat คือ 10,000 ใช่ คุณไม่สามารถปรุงโจ๊กด้วยค่าดังกล่าวได้ แน่นอนว่าสำหรับฉันแล้วดูเหมือนว่าไม่ - เรายังมีโอกาสที่จะส่งข้อมูลของเราที่มีการชนกันไปยังที่อื่นซึ่งระบบจะประมวลผลโดยอัตโนมัติเช่นกัน หนึ่งในตัวอย่างที่ชัดเจนที่สุดของสถานที่ดังกล่าวคือตัวแยกวิเคราะห์ XML ต่างๆ ใน Xerces parser สำหรับ Java อาร์เรย์ที่เชื่อมโยง (HashMap) จะถูกใช้อย่างสมบูรณ์ในระหว่างการแยกวิเคราะห์ และในเวลาเดียวกัน parser จะต้องประมวลผลทุกอย่างก่อน (นั่นคือ ดันโครงสร้างเข้าไปในหน่วยความจำ) จากนั้นจึงสร้างตรรกะทางธุรกิจต่างๆ วิธีนี้เราสามารถสร้างคำขอ XML ปกติที่มีการชนกันและส่งไปยังเซิร์ฟเวอร์ เนื่องจากจริงๆ แล้วจะมีเพียงพารามิเตอร์เดียว การป้องกันสำหรับการนับจำนวนพารามิเตอร์จึงจะถูกส่งผ่าน

แต่ขอกลับไปสู่เวอร์ชัน POST ธรรมดา หากคุณต้องการทดสอบไซต์ของคุณหรือของผู้อื่น มีเครื่องมือที่เรียบง่ายสำหรับสิ่งนี้หรือโมดูล Metasploit - auxiliary/dos/http/hashcollision_dos ในกรณีที่คุณยังมีคำถามหลังจากฉันอธิบายหรือแค่รักแมว นี่คือเวอร์ชั่นในรูป

งาน

จัดระเบียบเปลือกย้อนกลับ

สารละลาย

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

จุดสำคัญประการหนึ่งของวิธีนี้คือการมองไม่เห็นจาก IDS ใด ๆ รวมถึง "การซึมผ่าน" หรือบางอย่าง ประเด็นที่สองเกี่ยวข้องกับความจริงที่ว่าโดยปกติแล้วโฮสต์ที่ใช้งานไม่ได้จะไม่โดดเด่นโดยตรง แต่ตั้งอยู่ภายในเครือข่ายองค์กรหรือใน DMZ นั่นคือด้านหลังไฟร์วอลล์ NAT หรืออย่างอื่น ดังนั้นหากเราเปิดพอร์ตโดยมีกระสุนอยู่บนเหยื่อ เราจะไม่สามารถเชื่อมต่อที่นั่นได้ Reverse Shells มักจะดีกว่าเสมอเนื่องจากพวกมันเชื่อมต่อกับเราเองและไม่จำเป็นต้องเปิดพอร์ต แต่ก็มีเช่นกัน สถานการณ์ที่ยากลำบาก. หนึ่งในเชลล์ที่ “แตกหักได้” มากที่สุดคือเชลล์ DNS เนื่องจากการสื่อสารของเรากับเชลล์ไม่ได้เกิดขึ้นโดยตรง แต่เกิดขึ้นผ่านเซิร์ฟเวอร์ DNS ขององค์กร (ผ่านการร้องขอไปยังโดเมนของเรา) แต่วิธีนี้ใช้ไม่ได้ผลเสมอไป ดังนั้นคุณต้องเลิกใช้วิธีนี้ Metasploit ยังมี Reverse Shell ที่น่าสนใจอีกด้วย เมื่อเริ่มต้น ระบบจะพยายามเชื่อมต่อพอร์ต TCP ทั้งหมดไปยังเซิร์ฟเวอร์ของเรา โดยพยายามระบุช่องโหว่ในกฎไฟร์วอลล์ อาจทำงานในการกำหนดค่าบางอย่าง

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

สิ่งที่น่าสนใจที่สุดสำหรับเราคือรองรับระบบปฏิบัติการหลายระบบ ส่วนใหญ่ *ระวัง แต่ดูเหมือนว่า Windows รุ่นใหม่กว่าจะรองรับมันตั้งแต่แกะกล่อง (แม้ว่าฉันจะไม่พบการยืนยันจริง ๆ ก็ตาม) แน่นอนว่ามันไม่ใช่เทคโนโลยีขั้นสูงสุด แต่ IDS ไม่น่าจะตรวจพบกระสุนดังกล่าวได้ง่ายนัก ซึ่งเป็นข้อดีสำหรับเรา โดยทั่วไปเราสลัดมันออกแล้วเอาเปลือกออกเอง

งาน

DoS ใช้การโจมตีแบบขยายสัญญาณ

สารละลาย

เราได้กล่าวถึงหัวข้อดังกล่าวในการขยายการโจมตี DDoS มากกว่าหนึ่งครั้งใน Easy Hack แล้ว สาระสำคัญของพวกเขาคือผู้โจมตีสามารถส่งคำขอไปยังบริการบางอย่างในนามของเหยื่อได้ และการตอบกลับจะถูกส่งในขนาดที่ใหญ่ขึ้นอย่างมีนัยสำคัญ (หลายเท่า) การโจมตีเหล่านี้เป็นไปได้หลักๆ เนื่องจากโปรโตคอล UDP เองไม่ได้เกี่ยวข้องกับการสร้างการเชื่อมต่อ (ไม่มีการจับมือกันเหมือนใน TCP) นั่นคือเราสามารถแทนที่ IP ของผู้ส่งได้ และเนื่องจากบริการจำนวนมาก "ช่างพูด" มาก (ตอบมากกว่าคำขออย่างมีนัยสำคัญ) และดำเนินการ "โดยไม่มี" การรับรองความถูกต้อง (แม่นยำยิ่งขึ้น ไม่มีการสร้างการเชื่อมต่อในระดับที่สูงกว่า)

โดยทั่วไปแล้ว เมื่อไม่นานมานี้ มีการพูดถึงการโจมตีด้วยการขยาย DNS บนอินเทอร์เน็ตในหัวข้อการโจมตีด้วยการขยายสัญญาณ DNS เท่าที่ฉันจำได้ การโจมตีครั้งล่าสุดใช้บริการ NTP ตัวเลขดังกล่าวเป็นสิ่งต้องห้าม - หลายร้อยกิกะบิต... แต่ฉันอยากจะกลับไปที่หัวข้อนี้เพื่อเน้นย้ำถึงสิ่งสำคัญ: นี่เป็นปัญหาลึกที่ไม่น่าจะได้รับการแก้ไขในอีกไม่กี่ปีข้างหน้า ปัญหาหลักอยู่ที่ UDP และไม่มีประเด็นในการ "แก้ไข" โปรโตคอลเฉพาะ - DNS, NTP ฯลฯ (แม้ว่าการกำหนดค่าเริ่มต้นที่ปลอดภัยกว่าจะมีประโยชน์ก็ตาม) ท้ายที่สุดแล้ว การโจมตีด้วยการขยายสัญญาณที่คล้ายกันสามารถทำได้โดยใช้โปรโตคอล SNMP (พร้อมสตริงชุมชนมาตรฐาน - สาธารณะ) หรือ NetBIOS หรือโปรโตคอลที่ไม่ค่อยมีใครรู้จัก เช่น Citrix ที่นี่คุณสามารถเพิ่มสิ่งต่าง ๆ ได้ เกมเครือข่าย. ใช่ ใช่ หลายๆ อย่าง (เช่น Half-Life, Counter-Strike, Quake) ก็ใช้ UDP เป็นพาหนะในการส่ง และผ่านสิ่งเหล่านี้ เราก็สามารถใช้ DDoS กับใครบางคนได้เช่นกัน คุณสามารถเพิ่มบริการสตรีมมิ่งวิดีโอได้ที่นี่

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

งาน

สกัดกั้น DNS ด้วย Bitsquating

สารละลาย

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

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

แต่ทั้งหมดนี้ไม่น่าสนใจมากนัก ไม่ใช่ "สวยงาม" “การค้นพบ” ที่น่าสนใจยิ่งกว่านั้นถูกนำเสนอที่ Black Hat Las Vegas 2011 โดยนักวิจัยชื่อ Artem Dinaburg เป็นสิ่งที่คาดไม่ถึงมาก แต่กลับกลายเป็นว่าคอมพิวเตอร์ก็ทำผิดพลาดเช่นกัน อาจเกิดขึ้นได้ว่าด้วยเหตุผลบางอย่างหนึ่งหรือสองบิตเปลี่ยนจาก 0 เป็น 1 หรือในทางกลับกัน และนั่นคือทั้งหมด - เรามีคำขอใหม่แล้ว... แต่ฉันกำลังนำหน้าตัวเองอยู่

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

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

แต่กลับไปสู่โอกาสที่จะเกิดข้อผิดพลาด น่าแปลกที่มี "สถิติ" อยู่บ้างเกี่ยวกับเรื่องนี้ (ดูภาพหน้าจอ) ลักษณะสำคัญคือ FIT (ความล้มเหลวตามเวลา) โดยที่ 1 FIT เท่ากับหนึ่งข้อผิดพลาดต่อการทำงานหนึ่งพันล้านชั่วโมง ผลลัพธ์ที่แย่ที่สุดคือ 81,000 FIT ต่อหน่วยความจำ 1 Mbit (1 ข้อผิดพลาดต่อ 1.4 ปี) และที่ดีที่สุดคือ 120 FIT ต่อหน่วยความจำ 1 Mbit (1 ข้อผิดพลาดต่อ 950 ปี) ใช่ ดูเหมือนว่าผลลัพธ์เหล่านี้จะไม่น่าประทับใจ แต่ถ้าคุณพิจารณาว่าเรามีหน่วยความจำมากกว่า 1 Mbit และใช้ค่าเฉลี่ย 4 GB เป็นพื้นฐาน แม้แต่ หน่วยความจำที่ดีที่สุด(120 FIT) เราจะได้รับข้อผิดพลาดสามครั้งต่อเดือน (ฉันไม่ได้คำนวณใหม่เป็นการส่วนตัว และเหตุผลในการคำนวณเป็นบิตแทนที่จะเป็นไบต์นั้นไม่ชัดเจนสำหรับฉัน ดังนั้นหวังว่าการคำนวณจะถูกต้อง)

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

• 5x10^9 x 128 MB = 5.12 x 10^12 Mbit - จำนวนหน่วยความจำทั้งหมด

• 5.12 x 10^12 Mbit x 120 FIT= 614,400 ข้อผิดพลาด/ชั่วโมง

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

ผู้วิจัยพบวิธีที่จะใช้ประโยชน์จากสิ่งนี้ - เทคนิค bitsquating คล้ายกับการพิมพ์ผิด แต่พื้นฐานในการเลือกโดเมนคือชื่อที่แตกต่างจากชื่อที่ถูกต้องหนึ่งหรือสองบิต ตัวอย่างเช่น Microsoft.com และ mic2soft.com แทนที่จะเป็น r มี 2 เนื่องจาก r คือ 01110010 และ 2 (เป็นสัญลักษณ์) คือ 00110010 นั่นคืออันที่สองจะถูกแทนที่ด้วยศูนย์

ดังนั้นเมื่ออุปกรณ์บางตัวทำผิดพลาดและพยายามแก้ไขชื่อโดเมน mic2soft.com แทน microsoft.com อุปกรณ์นั้นจะมาหาเราแล้ว โดเมนย่อยก็จะมาหาเราเช่นกัน

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

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

แต่ แต่ แต่... มีการจองมากมาย แต่ความจริงหลักยังคงอยู่ - เทคโนโลยีใช้งานได้ Artem จดทะเบียนโดเมนหลายสิบโดเมนและติดตามคำขอที่มาถึงเขาเป็นเวลาหกเดือน โดยรวมแล้วมีการรวบรวมคำขอประมาณ 50,000 รายการ โดยเฉลี่ยแล้ว มีการเชื่อมต่อ 60 ครั้งต่อวันจาก IP ที่ไม่ซ้ำกัน (แต่ก็เพิ่มขึ้นถึง 1,000 ครั้งเช่นกัน) ในเวลาเดียวกัน เขาอ้างว่าสิ่งเหล่านี้เป็นท่อนไม้ที่ไม่มีแมงมุม เครื่องสแกน และสิ่งอื่นๆ เข้ามาสุ่ม

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

อืม. เห็นด้วยเทคนิค smacks of madness :) แต่มันได้ผล ฉันขอแนะนำให้คุณทำความคุ้นเคยกับสถิติอื่นๆ ที่นำเสนอในงานนี้

ขอบคุณสำหรับความสนใจและขอให้โชคดีในการเรียนรู้สิ่งใหม่!

สูตรโกงที่น่าสนใจมากชื่อ ExtrimHack สำหรับ CS:GO จากนักพัฒนาชาวรัสเซีย ในขณะที่เผยแพร่ VAC anti-cheat จะไม่ตรวจพบ รวมคุณสมบัติยอดนิยมดังต่อไปนี้: AimBot, WallHack, TriggerBot, RadarHack และอีกมากมาย...

คำอธิบายของฟังก์ชั่น
AimBot (Aim bot) - เล็งไปที่หัวของศัตรูโดยอัตโนมัติ (สูตรโกงมีการตั้งค่าเล็งอัตโนมัติที่ศีรษะ คอ หรือลำตัว)
WallHack (ESP, WallHack หรือ VX) - ช่วยตรวจจับศัตรูผ่านกำแพงใดๆ ในระยะไกล และยังแสดงจำนวนชีวิตและเกราะของศัตรูอีกด้วย
TriggerBot - เริ่มยิงอัตโนมัติทันทีที่คุณเล็งไปที่ศัตรู

คำแนะนำในการติดตั้ง / เปิดใช้สูตรโกง

1. เปิดการโกง เมื่อต้องการทำเช่นนี้ ให้เรียกใช้ไฟล์ .exe ExtrimHack.exe
2. วิ่ง เคาน์เตอร์-สไตรค์ โกลบอลก้าวร้าว.
3. รอจนกว่าเกมจะโหลดเสร็จสมบูรณ์แล้วคลิก “เปิดตัวโกง | เริ่มโกง"

สูตรโกงจะถูกฉีดเข้าไปในตัวมันเองและโปรแกรมบายพาส Anti-Cheat จะถูกเปิดใช้งาน จากนั้นคุณเพียงแค่ต้องเลือกฟังก์ชั่นที่คุณต้องการ คุณสามารถยุบเมนูโกงได้โดยการกดปุ่ม Insert, Home, End

สูตรโกง KFG ถูกเก็บไว้ที่นี่:
C:\Users\ชื่อผู้ใช้\AppData\Roaming\ExtrimTeam\Settings.cfg

ให้คะแนนของคุณ!

คลิกที่ดาวเพื่อให้คะแนนเนื้อหา