นักวิจัยความปลอดภัยนำเสนอกระบวนการเจาะการเข้ารหัสเพื่อหาข้อความในเว็บที่เข้ารหัส HTTPS ได้ภายใน 30 วินาทีที่งาน Black Hat
BREACH อาศัยการดักฟังผู้ใช้ที่เข้าเว็บที่เข้ารหัสและบีบอัดข้อมูลแบบ DEFLATE ซึ่งเบราว์เซอร์รองรับเป็นมาตรฐาน และต้องบังคับให้ผู้ใช้เข้าเว็บที่มีสคริปต์ฝังอยู่ ซึ่งหากดักฟังแล้วก็ทำได้ง่ายเพราะใช้การโจมตีแบบ man-in-the-middle แทรกโค้ดเข้าไปยังเว็บอื่นๆ ที่ไม่ได้เข้ารหัสได้
หลังจากที่ฝังสคริปต์ได้แล้ว สคริปต์จะเรียกหน้าข้อความโดยพยายามให้มีเนื้อความเป็นข้อความที่กำหนดได้ เช่นสั่งเรียกหน้า reply โดยกำหนดอีเมลลงไป หลังจากนั้นจึงดูขนาดของเนื้อหาที่ส่งกลับมาว่ามีขนาดเท่าใด
หากแฮกเกอร์เดาอีเมลได้ถูกต้อง ขนาดไฟล์ที่ส่งกลับมาจะมีขนาดเล็กลง แฮ็กเกอร์สามารถค่อยๆ เดาทีละตัวอักษรเพื่อรู้อีเมลแอดเดรสได้
กระบวนการนี้เป็นการโจมตีรูปแบบเดียวกับ CRIME ที่ใช้โจมตี SDPY เพียงแต่รอบนั้นเป็นการโจมตีที่การบีบอัดส่วนหัว (header) ของข้อความ การปิดการบีบอัดไม่เสียหายอะไรมากนัก แต่การบีบอัดเว็บนั้นมีการใช้งานกันโดยทั่วไป และช่วยให้เว็บทำงานได้เร็วขึ้นมาก (Blognone เองก็บีบอัดด้วย gzip) การปิดการทำงานของการบีบอัดคงเป็นเรื่องยากกว่ามาก
ใครทำงานวิจัยด้านความปลอดภัยตอนนี้หัวข้อที่น่าสนใจคงเป็นกระบวนการบีบอัดที่ทนทานต่อการโจมตีแบบนี้ครับ
Comments
ผมอ่านคำว่าดักฟังแล้วแปลกๆ คล้ายๆดักฟังโทรศัพท์ แต่อ่านแล้วสนุกดีครับ
เหมือนเกมหนูวิ่งหนีแมวเลย โดยที่แฮกเกอร์ทำหน้าที่เป็นแมว
ผมจึงไม่ชอบ Text Protocol แม้จะเข้ารหัส ( https ) แต่เป็นการแค่ยืนยันตัวตนของ Server เท่านั้น Cracker สามารถจำลองตัวเองเป็น Browser หรือ Proxy โจมตีได้อยู่ดี ฝันรอ Binary Protocol บน http 2.0 อยู่ครับ สำหรับ Web App
ปล. ผมชอบ Binary Protocol เช่น Java RMI, CORBA หรือ DCOM มากกว่า
ต่อให้ binary ถ้าไม่ใช้ HTTPs ยังไงก็ัดักได้ครับ HTTP เป็นมาตรฐานเปิด ใครๆก็เข้าถึงข้อมูลได้
Opensource - Hackintosh - Graphic Design - Scriptkiddie - Xenlism Project
Binary Protocol ทุกตัว ก็เป็นมาตราฐานเปิดเหมือนกันครับ
ทุก Protocol เราสามารถดักจับ "ข้อมูลดิบ ๆ" ได้หมด เพียงแต่ว่า เมื่อคุณดับจับข้อมูลดิบ ๆ มาได้แล้ว คุณจะมองเห็น Patterns ของ "ข้อมูลจริง ๆ" ...ได้ หรือไม่
เพราะมันเปิดมาตรฐานเปิดไงครับ ใครก็เข้าถึงมาตรฐานได้ ตราบใดที่ไม่เข้ารหัส ยังไงก็ดักจับได้
Opensource - Hackintosh - Graphic Design - Scriptkiddie - Xenlism Project
เห็นสิครับ ก็มันเป็นมาตรฐานเปิดนิครับ
binary นอกจากว่ามีขนาดเล็กกว่า plain text แล้วมันมีอะไรต่างกันอีกเหรอครับ?
ส่วนที่เป็น binary มันแค่ header รึเปล่าครับ เพราะส่วนหน้าเว็บยังคงเป็น html ... ซึ่งเป็น plain text อยู่ดี
จริง ๆ มันก็เป็นเช่นนั้นครับ
แต่จะเปิดโอกาศให้เราส่ง ข้อมูล ได้ทั้งในรูป Text หรือ Binary ก็ได้ ตามมาตราฐานของ Binary Protocol ทั่ว ๆ ไป โดยผมมองว่า มันเป็นจุดเริ่มต้นพื้นฐาน ของ มาตราฐานอื่น ๆ ที่จะตามมา ซึ่งเปิดโอกาศให้คนสร้าง Content หรือ App ทำอะไรได้ด้วยตนเอง ...มากขึ้น โดยเฉพาะการกำหนด Patterns ของ ข้อมูลเราเอง
แล้วถ้า header เป็น text จะไม่สามารถส่งข้อมูลที่เป็น binary ได้หรือไงครับ (- -!)a
แล้วแบบ text เราไม่สามารถกำหนด pattern ข้อมูลในแบบของเราได้เองเหรอครับ?
แล้วการเป็น binary มันช่วยแก้ปัญหาอะไรหรือครับ???
ใช้ binary แล้ว compress จะไม่เจอปัญหานี้?
lewcpe.com, @wasonliw
อ่าน DCOM แล้วนึกถึงประกันเครื่อง = ="
SDPY -> SPDY
SPDY ป่าวครับ
^_^
apache deflate ก็เป็น gzip output encoding นี่แหละครับ
ซึ่งหมายความว่าก็ใช้วิธีเดียวกันนี้กับ nginx ที่เปิด gzip module แบบ blognone ได้ครับ
สรุปง่าย ๆ ครับ
Text ใคร ๆ ก็อ่านได้ แต่ Binary ถ้าคุณไม่รู้ Patterns ของ ข้อมูล ( ผู้สร้างกำหนดขึ้นเองได้ ...ไม่ใช่ มาตราฐาน ) คุณจะไม่มีวันอ่านได้ เช่น Text { 123,456 + 7.89 } ใคร ๆ ก็อ่านได้ แต่ถ้าเป็น Binary { 000101111000001110 } ถ้าคุณ ไม่รู้ Pattern ของข้อมูน เช่น Data Type รวมถึงลำดับการเรียง Byte ว่าเป็น Big-endian หรือ Little-endian ก็ไม่มีวันอ่านข้อมูลนี้ได้ ซึ่งผู้สร้างเท่านั้น ...ถึงจะรู้ เพราะ Patterns ของ ข้อมูล ไม่ใช่มาตราฐาน
ส่วนการ เข้ารหัส หรือ compress ของ text ปกติ header จะบอกก่อนอยู่แล้ว โดย Cracker จำลองตัวเองเป็น Browser หรือ Proxy ก็สามารถทราบได้ตลอดเวลา
เช่นเดียวกับ การแจกจ่าย Excute code ใช่ว่าใครจะถอดมาเป็น Source Code ได้ง่าย ๆ ยกเว้น Java & .Net ซึ่งมี Decomplier สามารถอ่าน Pattern ของ Excute code นั้นได้ เพราะมันเป็น มาตราฐาน รวมทั้ง ชื่อ Method & Var ก็ประกาศไว้เป็น Text เห็นชัดเจน
ต่างจาก Excute code ซึ่งเป็น Native ต้องใช้ Debug เท่านั้น แม้จะรู้ Pattern ของ Mechine Code ก็ตาม ( สามารถใช้ Sourcer ถอด Excute code มาเป็น Assembly code ได้ แต่ไม่เห็น ชื่อ method หรือ var แถมบางครั้ง ไม่เห็นโครงสร้างของ method ด้วย ) แต่จะเห็น เฉพาะ Method ที่ประกาศเป็น Dynamic Link เปิดให้ Module อื่น ๆ เรียกเท่านั้น ทำให้ทุกวันนี้ Hack & Crack ทำผ่าน Scipt หรือ Data/Config ซึ่งเก็บไว้ในรูป Text File มากกว่า Excute code
แม้แต่ DataBase ทั่ว ๆ ไป ก็ต้องเก็บข้อมูลเป็น Text เพราะไม่สามารถคาดเดา Data Type ได้ หลัง ๆ จึงทำ DataBase รองรับ XML ไปเสียเลย ต่างจาก NoSQL จะเก็บเป็น Binary Data จึงทำงานเร็วกว่า RDBMs หรือ SQL 100 - 1,000 เท่า อย่างน้อย ๆ ไม่ต้อง Convert จาก Text มาเป็น Data type โดยเฉพาะ OODB : Object-Oriented DataBase ซึ่งแต่ละ Field ของ Record สามารถมี Data Type เป็น Array หรือ Object ซ้อนกันไม่รู้จบ
ตลกครับ
ถ้าคุณพูดถึงว่าคุณเขียนรับส่งข้อมูลกับ native app ผมยอมรับว่ามันอ่าน pattern "ยาก" แต่ไม่ใช่ว่าทำไม่ได้ครับ เอาที่ใกล้ตัวเห็นง่ายสุด รู้จัก bot ของเกมออนไลน์ไหมครับ? คำสั่งที่มาจาก server ไม่ใช่มาตรฐานเปิดด้วยซ้ำแต่ก็แกะ packet กันโครมๆ แถมเป็น encrypt packet ด้วย
คิดงี้จริงๆหรือครับเนี่ย ถ้าเขาพยายามจะ crack โปแกรมของคุณ เขาจะสนชื่อตัวแปรหรือโครงสร้าง method ไปทำไมครับ ในเมื่อเขาอ่าน assembly ได้ - -! และโปรแกรมที่โดนแครกกันทุกวันนี้ไม่ได้โดนแครกที่ตัว exe หรือ dll เหรอครับ
database "ทั่วๆไป" นี่มันอะไรครับขอชื่อหน่อย แล้วทำไมคุณถึงคิดว่ามันไม่สามารถคาดเดา Data Type ได้
NoSQL ไม่ได้ทำงานเร็วกว่าเพราะเป็น Binary Data ครับ และที่คนหันมาใช้ NoSQL ไม่ใช่เพราะเหตุผลเรื่องรูปแบบการเก็บข้อมูล ที่เป็น binary หรือ text แน่นอนครับ เพราะผมเชื่อว่าคนที่เอา NoSQL มาใช้เขาเก็บข้อมูลลงใน NoSQL ร้อยละ 90 เป็นข้อมูลประเภท text ครับ
แล้วมาเข้าเรื่องของเราได้รึยังครับว่า Binary protocol ของ http 2.0 มันแตกต่างอะไรกับการใช้เป็น text มันทำให้คุณมั่นใจในความปลอดภัยได้ยังไง
อ่านให้ดี ๆ ครับ ( อย่างนึกเอาเอง )
Native ต้องใช้ Debug หรือ Sourcer เพราะมันรู้ Pattern ของ Machine Code
ส่วน DataBase ถ้าคุณเป็นคนสร้าง Engine คุณจะเก็บข้อมูลอย่างไรครับ ในเมื่อ Programmer สามารถออกแบบ Pattern ของ Data Type อะไรก็ได้ ต่างจาก NoSQL จะเก็บ Pattern ของ Data Type อยู่ในรูปของ Source Code ก่อนจะ Compile มาใช้งาน ( เอาง่าย ๆ ครับ เคยมีข่าว Crack ข้อมูล กลางอากาศ ระหว่าง Binary Protocol บางหรือเปล่าครับ เช่น Java RMI, CORBA หรือ DCOM )
นั่นหมายความว่ามันมีวิธีที่จะcrack ได้ไม่ใช่หรือไงครับ แล้วไงล่ะ?
คุณไม่เคยออกแบบ schema ของ table เหรอครับ? (อันนี้เหมือนผมอ่านพลาดไป ตอบผิดประเด็น)
(ตอบใหม่)จริงๆแล้ววิธีเก็บข้อมูลของ database มีให้อ่านตามเวบมันนะครับผมขี้เกียจอธิบายรายละเอียดมาก
แต่ขอถามคุณนิดนึงว่า คุณรูปไหมว่าเราสามารถ convert ข้อมูลจาก text(เช่น "123456") เป็น integer และ convert เป็น byte array ขนาด 4 byte ได้? แค่นี้พอจะตอบคำถามของคุณได้ไหมครับว่า เก็บข้อมูลลงไปยังไง
ไปเอาข้อมูลนั้มาจากไหนครับ?
ผมยกตัวอย่างว่ามีการดัก packet ของ server game online แล้วนำมาสร้างเป็น bot แล้วไม่ใช่รึครับ มันก็เป็นตัวอย่างที่ดีว่า ข้อมูลแบบ binary มันก็ถูกอ่าน pattern ของข้อมูลได้ถ้าคิดจะทำ
แล้วพวก Java RMI, CORBA หรือ DCOM ที่มันมี specification ให้อ่านอยู่แล้วเนี่ยคุณคิดว่าจะอ่าน pattern ข้อมูลไม่ได้เหรอครับ?
ว่าแต่มาเข้าเรื่องของเราได้รึยังครับว่า Binary protocol ของ http 2.0 มันแตกต่างอะไรกับการใช้เป็น text มันทำให้คุณมั่นใจในความปลอดภัยได้ยังไง
ใช่ครับ ถ้าคุณไม่รู้ Pattern มันก็จบ Crack ไม่ได้ ( ผมเน้น Pattern ตั้งแต่แรก )
ส่วน Schema ของ Table มันก็คล้าย ๆ ของ XML ไม่ใช่หรือครับ และ ประมวลผลคล้าย ๆ XML ด้วย
ส่วนพวกเกมส์ Protocol กระจอก ๆ ไม่ได้อยู่ บน ...มาตราฐาน แสดงว่า "ทำอะไร กันแบบ ...ลวก ๆ" รวมทั้ง พนักงานเข้า ๆ ออก ๆ ก็รู้ Pattern กันง่าย ครับ
เอ้าคนที่จงใจจะแครกเขาก็ต้องศึกษา pattern สิครับ ดูรูปแบบการรับส่งข้อมูลและตาดเดา pattern มันยาก ผมรู้และผมเคยทำจึงบอกได้ว่ายาก แต่จุดที่อ่านง่ายมันก็มีอยู่ แต่ไม่ใช่ทำไม่ได้ครับ
จบครับ ผมจะไม่คุยกับคุณในประเด็นนี้อีก เพราะคุณไม่รู้เรื่องนี้จริงๆ แค่อยากจะพ่นออกมา
จบนะครับ มันจะดีกับตัวคุณมากกว่า
มาตรฐานอะไรครับ? ถ้ามาตรฐานเปิดนี่หาอ่านง่ายเลยนะครับ แต่เกมออนไลน์เป็นระบบปิดนะครับ คนภายนอกแกะ packet กันเองและการรับส่งข้อมูลเขารับส่งโดยการโยน data structure(นี่ไงครับที่คุณบอกว่า สามารถกำหนด pattern ได้เอง) ที่ถูก write ออกมาเป็น binary และส่งให้ client คนดักก็เอา packet นั่นมาแกะว่า byte ที่ 0-4 เก็บข้อมูลเกี่ยวกับตำแหน่ง x 5-8 เป็นพิกัด y bla bla bla...
แล้วคุณคิดจะเข้าเรื่องของเราได้รึยังครับว่า Binary protocol ของ http 2.0 มันแตกต่างอะไรกับการใช้เป็น text มันทำให้คุณมั่นใจในความปลอดภัยได้ยังไง
ผมทำงานด้านการพัฒนา OODB Engine บน Network Programming ครับ
คุณเก่งนัก ก็ไป Crack เอาเองซิครับ 555+
?
ไม่สำคัญว่าคุณทำงานด้านไหน หรือผมเก่งแค่ไหนครับ
แต่อะไรที่ไล่ต้อนคุณก็ตาม มันไม่ใช่ผมแน่
เริ่มจากบอกว่าให้กำหนด pattern เองโดยไม่ให้คนอื่นรู้
จิกกัดเล็กน้อยด้วยการบอกว่าของเค้ากระจอก ต่อด้วยบอกว่า pattern ที่ทำเองไม่อยู่บนมาตรฐานนั่นเป็นการทำแบบลวก ๆ
ผมทำเป็นไม่เห็นอันนี้ดีกว่า ไม่รู้จะบรรยายยังไงแล้ว
ตามด้วยสูตรงัดหน้าที่การงานออกมา
แล้วก็บอกว่าอีกฝ่ายเก่งจริงก็ไปหาเอง
จบที่เก่งจนมองข้ามปัญหาที่ถามซ้ำมาแทบทุกคอมเมนท์ สงสัยระบบการมองเห็นจะเซนเซอร์ทิ้งได้เหมือนเวลาอ่านเว็บที่มีโฆษณา
55555555
วิเคราะห์ได้แจ่มมากครับ
HTTP เป็นมาตรฐานเปิดครับ ต่อให้ออกแบบเป็นไบนารี สุดท้ายสเปคทั้งหมดก็ต้องเปิดเผยทั้งหมด
ใจความสำคัญของการออกแบบมาตรฐานเปิด คือ อยากได้ทุกคนอ่านออก เข้าใจได้ ทำงานร่วมกันได้ เราถึงได้มีเบราว์เซอร์และเซิร์ฟเวอร์นับร้อยๆ ยี่ห้อทำงานร่วมกันได้แทบทั้งหมด
การไปแอบๆ ทำโปรโตคอลของตัวเองคนอื่นอ่านไม่ออกก็อาจจะถูกครับ
แต่ไม่มีใครไปใช้กับคุณ
lewcpe.com, @wasonliw
ถูกต้องครับ
ผมจึงพูดถึง Patterns ของ ข้อมูล เท่านั้น โดยเฉพาะระหว่าง Web App กับ Web Server โดยผ่าน Binary Protocol ซึ่งเป็นมาตราฐานเดียวกัน จะทำให้การ Crack ยากขึ้น ครับ ( หรือ มาตราฐานอื่น ๆ ที่จะตามมาบน Binary Protocol โดยให้อิสระ กับ ผู้พัฒนาในการออกแบบ Patterns ของ ข้อมูล ได้เองเหมือน XML แต่อยู่ในรูปของ Binary )
ผมชักสงสัยแล้ว ว่าไอ้เจ้า pattern ของข้อมูลนี่มันไม่ใช่ส่วนนึงของโปรโตคอลหรือครับ???
ถูกต้องครับ
เราต้องแยกออกเป็น Pattern ของ Protocol และ Pattern ของ ข้อมูล
ซึ่ง "ข้อมูล" ในที่นี่ผม หมายถึง Object ปกติผมชอบ Java RMI มาก ๆ มันเหมือนกว่า CORBA และ DCOM เพราะ Object ของ RMI ไม่ใช่ ...แค่ Serialization แต่รวมถึง Process หรือ Java Byte Code เพื่อแปลงเป็น Machine Code ในการประมวลผลฝั่งตรงข้าม ทั้ง Client และ Server
hack ยากขึ้นอย่างไรครับ ตัวอย่าง? ความยากคืออะไรถ้าต้องรับประกันความเข้ากันได้ของแต่ละผู้ผลิต
lewcpe.com, @wasonliw
ทำไม Web App ต้องสื่อสารกับ Web Server ครับ?
คิดว่าจบไปนานแล้วซะอีก ฮาๆๆ
Opensource - Hackintosh - Graphic Design - Scriptkiddie - Xenlism Project