บทความนี้ทดสอบรหัสผ่าน 3 แบบที่แตกต่างกันด้วยเครื่องมือถอดรหัสผ่านโอเพ่นซอร์ส เพื่อค้นหาวิธีใดที่ได้ผลจริงในการรักษาความปลอดภัยรหัสผ่าน
สารบัญ
การแคร็กพาสเวิร์ดคืออะไร?
เมื่อคุณสร้างบัญชีกับบริการออนไลน์ ผู้ให้บริการมักจะเข้ารหัสข้อมูลการเข้าสู่ระบบของคุณบนเซิร์ฟเวอร์ของพวกเขา สิ่งนี้จะทำได้โดยใช้อัลกอริทึมเพื่อสร้าง "แฮช" ซึ่งเป็นสตริงตัวอักษรและตัวเลขแบบสุ่มที่ไม่ซ้ำกันสำหรับรหัสผ่านของคุณ แน่นอนว่ามันไม่ได้สุ่มจริงๆ แต่เป็นชุดอักขระที่เฉพาะเจาะจงมาก ซึ่งมีเพียงรหัสผ่านของคุณเท่านั้นที่สร้างได้ แต่สำหรับผู้ที่ไม่ชำนาญ มันดูเหมือนเป็นระเบียบเรียบร้อย
การเปลี่ยนคำให้เป็นแฮชนั้นเร็วและง่ายกว่าการ "ถอดรหัส" แฮชกลับเป็นคำอีกครั้งมาก ดังนั้นเมื่อคุณตั้งรหัสผ่าน บริการที่คุณเข้าสู่ระบบจะรันรหัสผ่านของคุณผ่านแฮชและจัดเก็บผลลัพธ์ไว้บนเซิร์ฟเวอร์
หากไฟล์รหัสผ่านนี้รั่วไหล แฮกเกอร์จะพยายามค้นหาเนื้อหาด้วยการแคร็กรหัสผ่าน เนื่องจากการเข้ารหัสรหัสผ่านนั้นเร็วกว่าการถอดรหัส แฮกเกอร์จึงตั้งระบบที่รับรหัสผ่านที่เป็นไปได้เป็นอินพุต จากนั้นเข้ารหัสโดยใช้วิธีเดียวกับเซิร์ฟเวอร์ จากนั้นจึงเปรียบเทียบผลลัพธ์กับฐานข้อมูลรหัสผ่าน
หากแฮชของรหัสผ่านที่เป็นไปได้ตรงกับรายการใดๆ ในฐานข้อมูล แฮกเกอร์จะรู้ว่าความพยายามแต่ละครั้งจะตรงกับรหัสผ่านที่เป็นไปได้ที่ลอง
วิธีการแคร็กรหัสผ่านของคุณเองโดยใช้ HashCat
ลองแคร็กบางรหัสผ่านที่บทความสร้างขึ้นเพื่อดูว่าทำได้ง่ายเพียงใด ในการดำเนินการนี้ ตัวอย่างจะใช้Hashcatซึ่งเป็นเครื่องมือถอดรหัสผ่านโอเพ่นซอร์ส ฟรี ที่ใครๆ ก็สามารถใช้ได้
สำหรับการทดสอบเหล่านี้ ตัวอย่างจะถอดรหัสผ่านต่อไปนี้:
- 123456 : รหัสผ่านคลาสสิกและฝันร้ายทางความปลอดภัยทางไซเบอร์ 123456 ถือเป็น รหัสผ่านที่ใช้กันมากที่สุด ในโลก NordPass คำนวณว่าบัญชีผู้ใช้จำนวน 3 ล้านบัญชีใช้รหัสผ่าน 123456 บัญชีเป็นรหัสผ่าน ซึ่งรวมทั้งบัญชีระดับองค์กรจำนวน 1.2 ล้านบัญชีที่ใช้ปกป้อง
- ซูซาน48! :รหัสผ่านที่เป็นไปตามรูปแบบที่ผู้ใช้ส่วนใหญ่ใช้เพื่อสร้างรหัสผ่านที่ปลอดภัย โดยทั่วไปแล้วจะตรงตามเกณฑ์สำหรับการป้องกันด้วยรหัสผ่านพื้นฐาน แต่ตามที่เราจะสำรวจในภายหลัง พบว่ายังมีจุดอ่อนสำคัญบางประการที่อาจถูกใช้ประโยชน์ได้
- t9^kJ$2q9a : รหัสผ่านที่สร้างโดยใช้เครื่องมือของ Bitwarden ตั้งค่าให้สร้างรหัสผ่านที่มีความยาว 10 ตัวอักษร พร้อมทั้งตัวอักษรพิมพ์ใหญ่และพิมพ์เล็ก สัญลักษณ์ และตัวเลข
ตอนนี้เข้ารหัสรหัสผ่านโดยใช้ MD5 นี่คือลักษณะของรหัสผ่านหากอยู่ในไฟล์รหัสผ่านที่บันทึกไว้:
- 123456 : e10adc3949ba59abbe56e057f20f883e
- ซูซาน48! : df1ce7227606805745ee6cbc644ecbe4
- t9^kJ$2q9a : 450e4e0ad3ed8766cb2ba83081c0a625
ตอนนี้ถึงเวลาที่จะแคร็กพวกมันแล้ว
ทำการเจลเบรกแบบง่ายๆ โดยใช้การโจมตีแบบพจนานุกรม
ในการเริ่มต้น ให้เราดำเนินการโจมตีด้วยพจนานุกรม ซึ่งเป็นหนึ่งในวิธีโจมตีรหัสผ่านที่พบบ่อยที่สุด นี่เป็นการโจมตีแบบง่ายๆ โดยแฮกเกอร์จะหยิบรายการรหัสผ่านที่เป็นไปได้ จากนั้นขอให้ Hashcat แปลงรหัสผ่านเหล่านั้นเป็น MD5 และตรวจดูว่ามีรหัสผ่านใดที่ตรงกับ 3 รายการด้านบนหรือไม่ สำหรับการทดสอบนี้ ให้ใช้ไฟล์ "rockyou.txt" เป็นพจนานุกรม ซึ่งถือเป็นการรั่วไหลของรหัสผ่านครั้งใหญ่ที่สุดในประวัติศาสตร์
ในการเริ่มแคร็ก ผู้เขียนบทความไปที่โฟลเดอร์ Hashcat คลิกขวาบนพื้นที่ว่าง และคลิกเปิดใน Terminal ตอนนี้ที่เปิด Terminal แล้วและตั้งค่าเป็นไดเร็กทอรี Hashcat ให้เรียกแอปพลิเคชัน Hashcat ด้วยคำสั่งต่อไปนี้:
.\hashcat -m 0 -a 0 passwordfile.txt rockyou.txt -o results.txt
นี่คือสิ่งที่คำสั่งทำ:
- .\hashcatเรียกใช้ Hashcat
- -m 0 : ระบุประเภทของการเข้ารหัสที่จะใช้ กรณีนี้จะใช้ MD5 ซึ่งระบุไว้เป็น 0 ในเอกสารวิธีใช้ Hashcat
- -a 0 : ระบุการโจมตีที่จะดำเนินการ เอกสารวิธีใช้ Hashcat ระบุ Dictionary Attack เป็นศูนย์ ดังนั้นเราจึงเรียกแบบนั้นที่นี่
- passwordfile.txt rockyou.txt : ไฟล์แรกประกอบด้วยรหัสผ่านเข้ารหัส 3 รหัสที่เราตั้งค่าไว้ก่อนหน้านี้ ไฟล์ที่สองเป็นฐานข้อมูลรหัสผ่าน Rockyou ทั้งหมด
- -o results.txt : ตัวแปรนี้จะกำหนดว่าจะวางผลลัพธ์ไว้ที่ไหน ในคำสั่งนี้มันจะใส่รหัสผ่านที่ถอดรหัสได้ไว้ในไฟล์ TXT ที่มีชื่อว่า "results"
แม้ว่า Rockyou จะใหญ่มาก แต่ Hashcat ก็ประมวลผลทั้งหมดได้ภายใน 6 วินาที ในไฟล์ผลลัพธ์ Hashcat ระบุว่าสามารถถอดรหัสผ่าน 123456 ได้ แต่ยังสามารถถอดรหัสผ่าน Susan และ Bitwarden ได้อีกด้วย นั่นเป็นเพราะมีผู้อื่นใช้รหัส 123456 ในไฟล์ rockyou.txt แต่ไม่มีใครใช้รหัสผ่าน Susan หรือ Bitwarden ซึ่งหมายความว่าพวกเขาปลอดภัยเพียงพอที่จะรอดชีวิตจากการโจมตีครั้งนี้
ทำการเจลเบรกที่ซับซ้อนมากขึ้นโดยใช้การโจมตีแบบ Brute Force ที่ซ่อนอยู่
ทำการโจมตีแบบ Brute Force ด้วย Hashcat
การโจมตีด้วยพจนานุกรมมีประสิทธิผลเมื่อมีคนใช้รหัสผ่านเดียวกันกับรหัสผ่านที่พบในรายการรหัสผ่านจำนวนมาก พวกมันรวดเร็วและง่ายต่อการใช้งาน แต่ไม่สามารถถอดรหัสที่ไม่อยู่ในพจนานุกรมได้ ดังนั้น หากคุณต้องการทดสอบรหัสผ่านของคุณจริงๆ คุณต้องใช้การโจมตีแบบ Brute Force
หากการโจมตีด้วยพจนานุกรมเป็นเพียงการเอารายการที่กำหนดไว้ล่วงหน้าแล้วแปลงทีละรายการ การโจมตีแบบ Brute Force ก็จะทำแบบเดียวกัน แต่จะใช้การผสมผสานทุกรูปแบบที่สามารถจินตนาการได้ การดำเนินการดังกล่าวอาจยากกว่าและใช้เวลานานกว่า แต่ในที่สุดแล้วก็สามารถถอดรหัสผ่านใดๆ ก็ได้ อย่างที่เราจะเห็นในไม่ช้า ความสามารถดังกล่าวอาจต้องใช้เวลานาน
นี่คือคำสั่งที่ใช้ในการโจมตีแบบ Brute Force "จริง":
.\hashcat -m 0 -a 3 target.txt --increment ?a?a?a?a?a?a?a?a?a?a -o output.txt
นี่คือสิ่งที่คำสั่งทำ:
- -a 3 : ตัวแปรนี้จะกำหนดการโจมตีที่เราต้องการดำเนินการ เอกสารความช่วยเหลือของ Hashcat ระบุการโจมตี Brute Force เป็นหมายเลข 3 ดังนั้นจึงเรียกที่นี่
- target.txt : ไฟล์ที่มีรหัสผ่านเข้ารหัสที่เราต้องการถอดรหัส
- --increment : คำสั่งนี้จะแจ้งให้ Hashcat ลองรหัสผ่านทั้งหมดที่มีความยาวหนึ่งอักขระ จากนั้นเป็นสองอักขระ สามอักขระ และต่อไปเรื่อยๆ จนกว่าจะพบรหัสผ่านที่ตรงกัน
- ?a?a?a?a?a?a?a?a?a?a?a : สิ่งนี้เรียกว่า “หน้ากาก” มาสก์ช่วยให้เราบอก Hashcat ได้ว่าอักขระใดถูกใช้ในตำแหน่งใด เครื่องหมายคำถามแต่ละตัวจะระบุตำแหน่งอักขระในรหัสผ่าน และตัวอักษรจะระบุว่าเราจะลองทำอะไรที่ตำแหน่งแต่ละตำแหน่ง ตัวอักษร "a" แทนตัวพิมพ์ใหญ่และพิมพ์เล็ก ตัวเลขและสัญลักษณ์ ดังนั้นหน้ากากนี้จึงระบุว่า "ลองทุกอย่างในแต่ละตำแหน่ง" นี่คือหน้ากากที่แย่มาก แต่เราจะมาลองใช้มันอย่างมีประสิทธิภาพในภายหลัง
- -o output.txt : ตัวแปรนี้จะกำหนดว่าจะวางผลลัพธ์ไว้ที่ไหน คำสั่งตัวอย่างจะใส่รหัสผ่านที่ถอดรหัสได้ลงในไฟล์ TXT ชื่อ "output"
แม้ว่าจะมีหน้ากากแย่ๆ แต่สามารถถอดรหัสรหัสผ่าน 123456 ได้ภายใน 15 วินาที แม้ว่าจะเป็นรหัสผ่านที่พบได้บ่อยที่สุด แต่ก็เป็นหนึ่งในรหัสผ่านที่อ่อนแอที่สุด
รหัสผ่าน "Susan48!" ดีกว่ามาก - คอมพิวเตอร์แจ้งว่าจะใช้เวลา 4 วันในการแคร็ก อย่างไรก็ตาม ยังมีปัญหาอยู่ประการหนึ่ง คุณจำตอนที่บทความกล่าวว่ารหัสผ่านของซูซานมีข้อบกพร่องร้ายแรงหรือไม่? ความผิดพลาดที่ใหญ่ที่สุดคือรหัสผ่านถูกสร้างขึ้นในลักษณะที่สามารถคาดเดาได้
เมื่อสร้างรหัสผ่าน เราจะใส่องค์ประกอบบางอย่างไว้ในตำแหน่งเฉพาะ คุณคงนึกภาพออกว่าผู้สร้างรหัสผ่าน Susan พยายามใช้ "susan" ในตอนแรกแต่ถูกขอให้เพิ่มตัวอักษรพิมพ์ใหญ่และตัวเลข เพื่อให้จดจำได้ง่ายขึ้น พวกเขาจึงพิมพ์ตัวพิมพ์ใหญ่ที่ตัวอักษรตัวแรกและเติมตัวเลขที่ท้าย จากนั้นบางทีบริการเข้าสู่ระบบอาจขอสัญลักษณ์ ดังนั้นผู้ตั้งรหัสผ่านจึงใส่สัญลักษณ์นั้นต่อท้าย
ดังนั้น เราจึงสามารถใช้หน้ากากเพื่อบอก Hashcat ให้ลองเฉพาะอักขระที่เจาะจงในตำแหน่งที่เจาะจงเท่านั้น เพื่อใช้ประโยชน์จากความง่ายในการเดาของผู้คนเมื่อสร้างรหัสผ่าน ในหน้ากากนี้ "?u" จะใช้เฉพาะตัวอักษรพิมพ์ใหญ่ที่ตำแหน่งนั้น "?l" จะใช้เฉพาะตัวอักษรพิมพ์เล็ก และ "?a" แทนอักขระใดก็ได้:
.\hashcat -m 0 -a 3 -1 ?a target.txt ?u?l?l?l?l?a?a?a -o output.txt
ด้วยหน้ากากนี้ Hashcat สามารถถอดรหัสผ่านได้ภายใน 3 นาที 10 วินาที เร็วกว่าที่ใช้เวลา 4 วันมาก
รหัสผ่าน Bitwarden มีความยาว 10 ตัวอักษรและไม่ใช้รูปแบบที่สามารถคาดเดาได้ ดังนั้นต้องใช้การโจมตีแบบ Brute Force โดยไม่มีหน้ากากจึงจะถอดรหัสได้ น่าเสียดายที่เมื่อขอให้ Hashcat ดำเนินการดังกล่าว ระบบจะเกิดข้อผิดพลาดโดยแจ้งว่าจำนวนการรวมกันที่เป็นไปได้เกินขีดจำกัดจำนวนเต็ม ผู้เชี่ยวชาญด้านความปลอดภัยไอทีกล่าวว่า Bitwarden ใช้เวลา 3 ปีในการถอดรหัสผ่าน ซึ่งนั่นก็เพียงพอแล้ว
วิธีรักษาบัญชีของคุณให้ปลอดภัยจากการแฮ็ครหัสผ่าน
ปัจจัยหลักที่ทำให้บทความไม่สามารถแคร็กรหัสผ่าน Bitwarden ได้คือความยาว (10 ตัวอักษร) และความไม่สามารถคาดเดาได้ ดังนั้น เมื่อสร้างรหัสผ่าน ให้พยายามให้ยาวที่สุดเท่าที่จะทำได้ และกระจายสัญลักษณ์ ตัวเลข และตัวพิมพ์ใหญ่ให้เท่าๆ กันตลอดทั้งรหัสผ่าน สิ่งนี้ช่วยป้องกันไม่ให้แฮกเกอร์ใช้หน้ากากเพื่อคาดเดาตำแหน่งของแต่ละองค์ประกอบ และทำให้แคร็กได้ยากขึ้นมาก
คุณอาจเคยรู้จักคำกล่าวรหัสผ่านเก่าๆ เช่น "ใช้ชุดอักขระ" และ "ให้ยาวที่สุดเท่าที่จะทำได้" หวังว่าคุณคงทราบว่าเหตุใดผู้คนจึงแนะนำเคล็ดลับที่มีประโยชน์เหล่านี้ นั่นก็คือ เคล็ดลับเหล่านี้เป็นความแตกต่างที่สำคัญระหว่างรหัสผ่านที่ถอดรหัสได้ง่ายกับรหัสผ่านที่ปลอดภัย