ป้องกัน Cross-Site Scripting (XSS) ใน Spring Boot ด้วยนโยบายความปลอดภัยเนื้อหา (CSP)

เผยแพร่ซ้ำโดยเพลโต

ผู้ติดตาม: 0

บทนำ

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

การโจมตีแบบ "มาตรฐาน" จำนวนมากเป็นที่รู้จักและได้รับการบันทึกไว้ และการป้องกันจากการโจมตีเหล่านี้ก็ไม่ยาก เพื่อปลดภาระให้กับนักพัฒนาจากการใช้แนวทางปฏิบัติด้านความปลอดภัย เฟรมเวิร์ก เช่น Spring Boot ได้แยกมาตรการความปลอดภัยต่างๆ ออก และอนุญาตให้คุณใช้ตัวกรองความปลอดภัยในแอปพลิเคชันของคุณเพื่อป้องกันการโจมตีที่รู้จักกันดี

ในคำแนะนำสั้น ๆ นี้ เราจะมาดูกันว่า Cross-Site Scripting (XSS) คืออะไร มีคนทำการโจมตีบนแอปพลิเคชันของคุณเองได้อย่างไร และคุณจะป้องกันมันได้อย่างง่ายดายด้วย Spring Boot อย่างไร

Cross-Site Scripting (XSS) คืออะไร?

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

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

Cross-Site Scripting หลีกเลี่ยงนโยบายที่มาเดียวกันโดยการฉีดสคริปต์ที่เป็นอันตรายลงในหน้าเว็บไซต์ที่เชื่อถือได้ เนื่องจากสคริปต์ถูกเรียกใช้จากเว็บไซต์ที่เชื่อถือได้ จึงทำงานเป็นสคริปต์ที่เชื่อถือได้ ไม่มีวิธีที่ชัดเจนในการแยกความแตกต่างระหว่างสคริปต์ที่ประสงค์ร้ายและสคริปต์ที่ไม่ประสงค์ร้าย ดังนั้นการเรียกใช้โค้ดโดยอำเภอใจจึงเป็นไปได้ด้วย Cross-Site Scripting มีตั้งแต่การแทรกการแจ้งเตือนที่น่ารำคาญ ไปจนถึงการโจมตีทางวิศวกรรมสังคม การรวบรวมข้อมูลผู้ใช้อย่างเงียบๆ หรือการเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าฟิชชิ่งที่ดูเหมือนเป็นส่วนหนึ่งของเว็บไซต์ที่เชื่อถือได้

หลาย เว็บไซต์มีความอ่อนไหวต่อการโจมตีแบบ Cross-Site Scripting และยังคงเป็นการโจมตีทั่วไปในปัจจุบัน ถึงแม้ว่าการใช้ประโยชน์ประเภทนี้จะเป็นที่รู้จักมาตั้งแต่ยุค 90

การป้องกัน XSS ใน Spring Boot Application ด้วย Content-Security Policy (CSP)

Spring Boot ให้ความสำคัญกับความปลอดภัยเป็นอย่างมาก และโมดูลความปลอดภัยของ Spring นำแนวปฏิบัติด้านความปลอดภัยที่ยืดหยุ่นและทรงพลังมาใช้ ซึ่งช่วยให้นักพัฒนาลดความกังวลในเรื่องความปลอดภัย ซึ่งบ่อยครั้งมักต้องการความเข้าใจในระดับต่ำเกี่ยวกับหลักการของวิธีแลกเปลี่ยนข้อความในเว็บ แอปพลิเคชัน.

โดยค่าเริ่มต้น Spring Boot ใช้ส่วนหัวความปลอดภัยหลายส่วน:

Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=31536000 ; includeSubDomains
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block

X-XSS-Protection รวมอยู่ด้วยโดยค่าเริ่มต้น! ส่วนหัวความปลอดภัยนี้พยายามที่จะ ตรวจจับ XSS พยายามและบล็อกพวกเขา นี่ไม่ใช่กระบวนการป้องกันการล้มเหลว และเบราว์เซอร์มีการใช้งานตัวตรวจจับที่แตกต่างกัน เบราว์เซอร์บางตัว เช่น Chrome มีแม้กระทั่ง ลบ XSS Auditor ของพวกเขาออก. นอกจากนี้ การตรวจจับอัตโนมัติยังทำงานสำหรับ สะท้อนการโจมตี XSSในขณะที่การโจมตีประเภทอื่นก็มีอยู่เช่นกัน

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

หมายเหตุ แม้จะมี CSP อยู่แล้ว ก็ยังเป็นแนวทางปฏิบัติที่ดีที่สุดในการตรวจสอบเสมอ ใด ป้อนข้อมูลของผู้ใช้และตรวจสอบให้แน่ใจว่าการประมวลผลโดยใช้ระบบของคุณปลอดภัย เพื่อป้องกันการฉีดโค้ด

ใน Spring Boot – ในการกำหนดค่ามาตรการรักษาความปลอดภัยเว็บแบบกำหนดเอง โดยปกติคุณจะขยาย WebSecurityConfigurerAdapter คลาส และแทนที่ configure() วิธี:

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

@Override
protected void configure(HttpSecurity http) throws Exception {
	http
	.headers()
		.contentSecurityPolicy("csp-directives");
    }
}

ในกรณีที่คำสั่งนโยบายการรักษาความปลอดภัยของเนื้อหา (ระบุเป็น a ;-แยกสตริง) ขึ้นอยู่กับกรณีการใช้งานของคุณและแหล่งที่คุณต้องการเชื่อถือ:

Content-Security Policy: directive1; directive2; directive3; ... directiveN;

ตัวอย่างเช่น เว็บแอปพลิเคชันสามารถแสดงรายการเว็บไซต์ที่เชื่อถือได้ซึ่งสคริปต์สามารถโหลดได้:

script-src https://trusted.com;

หรือคุณสามารถข้ามการเชื่อถือเว็บไซต์บุคคลที่สาม:

script-src self;

ในทำนองเดียวกัน แอปพลิเคชันสามารถเชื่อถือปลั๊กอินได้:

object-src https://trusted.com

มีคำสั่งมากมายที่คุณสามารถจัดหาได้ รวมถึง:

default-src – ทางเลือกเริ่มต้น
child-src – แหล่งที่มาของ Web Worker ที่ถูกต้อง
frame-src – แหล่งที่ถูกต้องสำหรับ และ s
img-src – แหล่งที่มาที่ถูกต้องสำหรับรูปภาพ
media-src – แหล่งที่ถูกต้องสำหรับ , และ แท็ก
script-src – แหล่งที่มาของสคริปต์ที่ถูกต้อง (ช่วยป้องกัน XSS)
style-src – แหล่งที่ถูกต้องสำหรับ องค์ประกอบ
base-uri – จำกัดทรัพยากรที่เข้าถึงได้จาก ธาตุ
frame-ancestors – ผู้ปกครองที่ถูกต้องของ , , , ฯลฯ องค์ประกอบ
เป็นต้น

ดูคู่มือเชิงปฏิบัติสำหรับการเรียนรู้ Git ที่มีแนวทางปฏิบัติที่ดีที่สุด มาตรฐานที่ยอมรับในอุตสาหกรรม และเอกสารสรุปรวม หยุดคำสั่ง Googling Git และจริงๆ แล้ว เรียน มัน!

ตัวอย่างเช่น นี่คือชุดคำสั่งนโยบายที่ปลอดภัย:

script-src 'strict-dynamic' 'nonce-rAnd0m123' 'unsafe-inline' http: https:;
object-src 'none';
base-uri 'none';
require-trusted-types-for 'script';
report-uri https://csp.example.com;

มาเพิ่มสิ่งเหล่านี้ในแอปพลิเคชัน Spring Boot ของเรา:

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

@Override
protected void configure(HttpSecurity http) throws Exception {
	http
	.headers()
		.contentSecurityPolicy("script-src 'strict-dynamic' 'nonce-rAnd0m123' 'unsafe-inline' http: https:; object-src 'none'; base-uri 'none'; require-trusted-types-for 'script'; report-uri https://csp.example.com;");
    }
}

คุณสามารถใช้ CSP-ผู้ประเมิน เพื่อประเมินว่าคำสั่ง CSP ของคุณถูกต้องหรือไม่ และ ปลอดภัยและจะชี้ให้เห็นว่าคำสั่งใดที่สามารถใช้ประโยชน์ได้ง่าย นี่คือคำสั่ง CSP ที่อนุญาตให้ใช้ Google APIs:

default-src 'self';
object-src 'none';
frame-src 'self' data:; 
script-src 'self' 'strict-dynamic' 'nonce-rAnd0m123' 'unsafe-inline' https://storage.googleapis.com; 
style-src 'self' 'unsafe-inline'; 
img-src 'self' data:; 
font-src 'self' data:;
base-uri 'self'

สรุป

ในคู่มือฉบับย่อนี้ เราได้ศึกษาว่า Cross-Site Scripting (XSS) คืออะไรและทำงานอย่างไรในระดับองค์รวม จากนั้น เราได้สำรวจมาตรการป้องกัน XSS บางอย่างที่สามารถนำไปใช้กับ Spring Boot ได้อย่างง่ายดาย เพื่อทำให้แอปพลิเคชันของคุณปลอดภัย และตั้งค่า นโยบายการรักษาความปลอดภัยของเนื้อหา (คสพ.).

สุดท้าย เราได้สำรวจคำสั่ง CSP และดูนโยบายความปลอดภัยที่แตกต่างกันสองสามข้อ

ประทับเวลา: ตุลาคม 30, 2022ตุลาคม 30, 2022