ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนหัวที่ช่วยให้เว็บไซต์ปลอดภัยและค้นหารายละเอียดที่สำคัญที่สุดได้อย่างรวดเร็ว
บทความนี้แสดงรายการส่วนหัวด้านความปลอดภัยที่สำคัญที่สุดที่คุณใช้เพื่อปกป้องเว็บไซต์ได้ ใช้เพื่อทำความเข้าใจฟีเจอร์ความปลอดภัยบนเว็บ เรียนรู้วิธีใช้ฟีเจอร์ดังกล่าวในเว็บไซต์ และใช้เป็นข้อมูลอ้างอิงเมื่อต้องการการช่วยเตือน
- ส่วนหัวด้านความปลอดภัยที่แนะนำสำหรับเว็บไซต์ที่จัดการข้อมูลที่ละเอียดอ่อนของผู้ใช้มีดังนี้
- นโยบายรักษาความปลอดภัยเนื้อหา (CSP)
- ประเภทที่เชื่อถือได้
- ส่วนหัวด้านความปลอดภัยที่แนะนำสำหรับเว็บไซต์ทั้งหมดมีดังนี้
- X-Content-Type-Options
- X-Frame-Options
- Cross-Origin Resource Policy (CORP)
- Cross-Origin Opener Policy (COOP)
- HTTP Strict Transport Security (HSTS)
- ส่วนหัวด้านความปลอดภัยสำหรับเว็บไซต์ที่มีความสามารถขั้นสูง
- กลไกการแชร์ทรัพยากรข้ามโดเมน (CORS)
- นโยบายเครื่องมือฝังแบบข้ามต้นทาง (COEP)
ก่อนที่จะเจาะลึกเรื่องส่วนหัวด้านความปลอดภัย โปรดดูข้อมูลเกี่ยวกับภัยคุกคามที่ทราบในเว็บและเหตุผลที่คุณควรใช้ส่วนหัวด้านความปลอดภัยเหล่านี้
ปกป้องเว็บไซต์จากช่องโหว่ในการแทรกโค้ด
ช่องโหว่จากการแทรกเกิดขึ้นเมื่อข้อมูลที่ไม่น่าเชื่อถือซึ่งประมวลผลโดยแอปพลิเคชันของคุณอาจส่งผลต่อลักษณะการทำงานของแอปพลิเคชัน และโดยทั่วไปจะนำไปสู่การเรียกใช้สคริปต์ที่ผู้โจมตีควบคุม ช่องโหว่ที่พบบ่อยที่สุดซึ่งเกิดจากข้อบกพร่องในการแทรกคือ Cross-site Scripting (XSS) ในรูปแบบต่างๆ ซึ่งรวมถึง Reflected XSS, Stored XSS, DOM-based XSS และตัวแปรอื่นๆ
โดยทั่วไปแล้ว ช่องโหว่ XSS จะทำให้ผู้โจมตีเข้าถึงข้อมูลผู้ใช้ที่แอปพลิเคชันประมวลผลและข้อมูลอื่นๆ ที่โฮสต์ในต้นทางเว็บเดียวกันได้อย่างสมบูรณ์
การป้องกันการแทรกแบบดั้งเดิม ได้แก่ การใช้ระบบเทมเพลต HTML ที่มีการหลีกอักขระอัตโนมัติอย่างสม่ำเสมอ การหลีกเลี่ยงการใช้ JavaScript API ที่เป็นอันตราย และการประมวลผลข้อมูลผู้ใช้อย่างเหมาะสมโดยการโฮสต์การอัปโหลดไฟล์ในโดเมนแยกต่างหากและการล้าง HTML ที่ผู้ใช้ควบคุม
- ใช้นโยบายรักษาความปลอดภัยเนื้อหา (CSP) เพื่อควบคุมสคริปต์ที่แอปพลิเคชันของคุณเรียกใช้ได้เพื่อลดความเสี่ยงของการแทรกโค้ด
- ใช้ Trusted Types เพื่อบังคับใช้การล้างข้อมูลที่ส่งไปยัง JavaScript API ที่เป็นอันตราย
- ใช้ X-Content-Type-Options เพื่อป้องกันไม่ให้เบราว์เซอร์ตีความประเภท MIME ของทรัพยากรในเว็บไซต์ผิดพลาด ซึ่งอาจทำให้สคริปต์ทำงานได้
แยกเว็บไซต์ของคุณออกจากเว็บไซต์อื่นๆ
ความเปิดกว้างของเว็บช่วยให้เว็บไซต์โต้ตอบกันในลักษณะที่อาจละเมิดความคาดหวังด้านความปลอดภัยของแอปพลิเคชันได้ ซึ่งรวมถึงการส่งคำขอที่ผ่านการตรวจสอบสิทธิ์โดยไม่คาดคิดหรือการฝังข้อมูลจากแอปพลิเคชันอื่นในเอกสารของผู้โจมตี ซึ่งทำให้ผู้โจมตีแก้ไขหรืออ่านข้อมูลแอปพลิเคชันได้
ช่องโหว่ที่พบบ่อยซึ่งบั่นทอนการแยกเว็บไซต์ ได้แก่ การหลอกให้คลิก, การปลอมแปลงคำขอแบบข้ามเว็บไซต์ (CSRF), การรวมสคริปต์แบบข้ามเว็บไซต์ (XSSI) และการรั่วไหลแบบข้ามเว็บไซต์ต่างๆ
- ใช้ X-Frame-Options เพื่อป้องกันไม่ให้เว็บไซต์ที่เป็นอันตรายฝังเอกสารของคุณ
- ใช้นโยบายทรัพยากรข้ามต้นทาง (CORP) เพื่อป้องกันไม่ให้เว็บไซต์แบบข้ามต้นทางรวมทรัพยากรของเว็บไซต์คุณ
- ใช้นโยบาย Cross-Origin Opener (COOP) เพื่อปกป้องหน้าต่างของเว็บไซต์จากการโต้ตอบโดยเว็บไซต์ที่เป็นอันตราย
- ใช้กลไกการแชร์ทรัพยากรแบบข้ามต้นทาง (CORS) เพื่อควบคุมการเข้าถึงทรัพยากรของเว็บไซต์จากเอกสารแบบข้ามต้นทาง
การพัฒนาเว็บหลังสเปคเตอร์เป็นบทความที่น่าอ่านหากคุณสนใจส่วนหัวเหล่านี้
สร้างเว็บไซต์ที่มีประสิทธิภาพอย่างปลอดภัย
Spectreทำให้ข้อมูลที่โหลดลงในกลุ่มบริบทการท่องเว็บเดียวกันอาจอ่านได้แม้จะมีนโยบายต้นทางเดียวกัน เบราว์เซอร์จะจำกัดฟีเจอร์ที่อาจใช้ประโยชน์จากช่องโหว่เบื้องหลังสภาพแวดล้อมพิเศษที่เรียกว่า "การแยกแบบข้ามต้นทาง" การแยกแบบข้ามต้นทางช่วยให้คุณใช้ฟีเจอร์ที่มีประสิทธิภาพ เช่น SharedArrayBuffer ได้
- ใช้นโยบายเครื่องมือฝังแบบข้ามต้นทาง (COEP) ร่วมกับ COOP เพื่อเปิดใช้การแยกแบบข้ามต้นทาง
เข้ารหัสการเข้าชมเว็บไซต์
ปัญหาการเข้ารหัสจะปรากฏขึ้นเมื่อแอปพลิเคชันไม่ได้เข้ารหัสข้อมูลที่อยู่ระหว่างการส่งอย่างสมบูรณ์ ซึ่งทำให้ผู้โจมตีที่ลักลอบดักฟังสามารถเรียนรู้เกี่ยวกับการโต้ตอบของผู้ใช้กับแอปพลิเคชันได้
การเข้ารหัสที่ไม่เพียงพออาจเกิดขึ้นในกรณีต่อไปนี้ ไม่ใช้ HTTPS, เนื้อหาผสม, การตั้งค่าคุกกี้โดยไม่มีแอตทริบิวต์ Secure (หรือคำนำหน้า __Secure) หรือตรรกะการตรวจสอบ CORS ที่ไม่เข้มงวด
- ใช้ HTTP Strict Transport Security (HSTS) เพื่อแสดงเนื้อหาผ่าน HTTPS อย่างสม่ำเสมอ
นโยบายรักษาความปลอดภัยเนื้อหา (CSP)
Cross-Site Scripting (XSS) คือการโจมตีที่ช่องโหว่ในเว็บไซต์ทำให้สามารถแทรกและเรียกใช้สคริปต์ที่เป็นอันตรายได้
Content-Security-Policy เพิ่มการป้องกันอีกชั้นเพื่อลดการโจมตี XSS โดยจำกัดสคริปต์ที่หน้าเว็บจะเรียกใช้ได้
เราขอแนะนำให้เปิดใช้ CSP แบบเข้มงวดโดยใช้วิธีใดวิธีหนึ่งต่อไปนี้
- หากคุณแสดงผลหน้า HTML บนเซิร์ฟเวอร์ ให้ใช้ CSP ที่เข้มงวดตาม Nonce
- หากต้องแสดง HTML แบบคงที่หรือแคช เช่น ในกรณีที่เป็นแอปพลิเคชันหน้าเว็บเดียว ให้ใช้ CSP แบบเข้มงวดที่อิงตามแฮช
ตัวอย่างการใช้งาน: CSP ที่อิงตาม Nonce
Content-Security-Policy:
script-src 'nonce-{RANDOM1}' 'strict-dynamic' https: 'unsafe-inline';
object-src 'none';
base-uri 'none';
การใช้งานที่แนะนำ
1. ใช้ CSP แบบเข้มงวดที่อิงตาม Nonce {: #nonce-based-csp}
หากคุณแสดงผลหน้า HTML บนเซิร์ฟเวอร์ ให้ใช้ CSP ที่เข้มงวดตาม Nonce
สร้างค่า Nonce ของสคริปต์ใหม่สำหรับคำขอทุกรายการในฝั่งเซิร์ฟเวอร์และตั้งค่าส่วนหัวต่อไปนี้
ไฟล์การกำหนดค่าเซิร์ฟเวอร์
Content-Security-Policy: script-src 'nonce-{RANDOM1}' 'strict-dynamic' https: 'unsafe-inline'; object-src 'none'; base-uri 'none';
ใน HTML หากต้องการโหลดสคริปต์ ให้ตั้งค่าแอตทริบิวต์ nonce ของแท็ก <script> ทั้งหมดเป็นสตริง {RANDOM1} เดียวกัน
index.html
<script nonce="{RANDOM1}" src="https://example.com/script1.js"></script>
<script nonce="{RANDOM1}">
// Inline scripts can be used with the <code>nonce</code> attribute.
</script>Google Photos เป็นตัวอย่าง CSP แบบเข้มงวดที่อิงตาม Nonce ที่ดี ใช้เครื่องมือสำหรับนักพัฒนาเว็บเพื่อดูวิธีใช้งาน
2. ใช้ CSP แบบเข้มงวดที่อิงตามแฮช {: #hash-based-csp}
หากต้องแสดงหรือแคช HTML แบบคงที่ เช่น หากคุณกำลังสร้างแอปพลิเคชันหน้าเว็บเดียว ให้ใช้ CSP แบบเข้มงวดที่อิงตามแฮช
ไฟล์การกำหนดค่าเซิร์ฟเวอร์
Content-Security-Policy: script-src 'sha256-{HASH1}' 'sha256-{HASH2}' 'strict-dynamic' https: 'unsafe-inline'; object-src 'none'; base-uri 'none';
ใน HTML คุณจะต้องแทรกสคริปต์ในบรรทัดเพื่อใช้นโยบายที่อิงตามแฮช เนื่องจากเบราว์เซอร์ส่วนใหญ่ไม่รองรับการแฮชสคริปต์ภายนอก
index.html
<script> ...// your script1, inlined </script> <script> ...// your script2, inlined </script>
หากต้องการโหลดสคริปต์ภายนอก โปรดอ่าน "โหลดสคริปต์ที่มาจากแหล่งที่มาแบบไดนามิก" ในส่วนตัวเลือก ข: ส่วนหัวการตอบกลับ CSP ที่อิงตามแฮช
CSP Evaluator เป็นเครื่องมือที่ดีในการประเมิน CSP ของคุณ แต่ในขณะเดียวกันก็เป็นตัวอย่าง CSP ที่เข้มงวดซึ่งอิงตาม Nonce ที่ดีด้วย ใช้เครื่องมือสำหรับนักพัฒนาเว็บเพื่อดูวิธีใช้งาน
เบราว์เซอร์ที่รองรับ
สิ่งอื่นๆ ที่ควรทราบเกี่ยวกับ CSP
- คำสั่ง
frame-ancestorsจะปกป้องเว็บไซต์ของคุณจากการลักลอบคลิก ซึ่งเป็นความเสี่ยงที่เกิดขึ้นหากคุณอนุญาตให้เว็บไซต์ที่ไม่น่าเชื่อถือฝังเว็บไซต์ของคุณ หากต้องการโซลูชันที่ง่ายกว่า คุณสามารถใช้X-Frame-Optionsเพื่อบล็อกการโหลดได้ แต่frame-ancestorsจะให้การกำหนดค่าขั้นสูงเพื่ออนุญาตเฉพาะต้นทางที่เฉพาะเจาะจงเป็นผู้ฝัง - คุณอาจใช้ CSP เพื่อให้แน่ใจว่าทรัพยากรทั้งหมดของเว็บไซต์โหลดผ่าน HTTPS ซึ่งปัจจุบันมีความเกี่ยวข้องน้อยลง เนื่องจากเบราว์เซอร์ส่วนใหญ่บล็อกเนื้อหาผสม
- นอกจากนี้ คุณยังตั้งค่า CSP ในโหมดรายงานเท่านั้นได้ด้วย
- หากตั้งค่า CSP เป็นส่วนหัวฝั่งเซิร์ฟเวอร์ไม่ได้ คุณก็ตั้งค่าเป็นเมตาแท็กได้เช่นกัน โปรดทราบว่าคุณไม่สามารถใช้โหมดรายงานเท่านั้นสำหรับเมตาแท็ก (แม้ว่าอาจมีการเปลี่ยนแปลง)
ดูข้อมูลเพิ่มเติม
ประเภทที่เชื่อถือได้
XSS ที่อิงตาม DOM คือการโจมตีที่มีการส่งข้อมูลที่เป็นอันตรายไปยังซิงก์ที่รองรับการเรียกใช้โค้ดแบบไดนามิก เช่น eval() หรือ .innerHTML
Trusted Types มีเครื่องมือในการเขียน ตรวจสอบความปลอดภัย และดูแลรักษาแอปพลิเคชันที่ไม่มี DOM XSS คุณสามารถเปิดใช้ประเภทที่เชื่อถือได้ผ่าน CSP และทำให้โค้ด JavaScript มีความปลอดภัยโดยค่าเริ่มต้นด้วยการจำกัด Web API ที่เป็นอันตรายให้ยอมรับเฉพาะออบเจ็กต์พิเศษ ซึ่งก็คือประเภทที่เชื่อถือได้
หากต้องการสร้างออบเจ็กต์เหล่านี้ คุณสามารถกำหนดนโยบายความปลอดภัยที่ช่วยให้มั่นใจได้ว่ากฎความปลอดภัย (เช่น การหลีกเลี่ยงหรือการล้างข้อมูล) จะมีผลอย่างสม่ำเสมอก่อนที่จะเขียนข้อมูลลงใน DOM นโยบายเหล่านี้จึงเป็นที่เดียวในโค้ดที่อาจทำให้เกิด DOM XSS ได้
ตัวอย่างการใช้งาน
Content-Security-Policy: require-trusted-types-for 'script'
// Feature detection
if (window.trustedTypes && trustedTypes.createPolicy) {
// Name and create a policy
const policy = trustedTypes.createPolicy('escapePolicy', {
createHTML: str => {
return str.replace(/\</g, '<').replace(/>/g, '>');
}
});
}
// Assignment of raw strings is blocked by Trusted Types.
el.innerHTML = 'some string'; // This throws an exception.
// Assignment of Trusted Types is accepted safely.
const escaped = policy.createHTML('<img src=x onerror=alert(1)>');
el.innerHTML = escaped; // '&lt;img src=x onerror=alert(1)&gt;'
การใช้งานที่แนะนำ
-
บังคับใช้ Trusted Types สำหรับซิงก์ DOM ที่เป็นอันตราย ส่วนหัว CSP และ Trusted Types:
Content-Security-Policy: require-trusted-types-for 'script'ปัจจุบัน
'script'เป็นค่าเดียวที่ยอมรับได้สำหรับคำสั่งrequire-trusted-types-forแน่นอนว่าคุณสามารถรวม Trusted Types เข้ากับคำสั่ง CSP อื่นๆ ได้ ดังนี้
การรวม CSP ที่อิงตาม Nonce จากด้านบนเข้ากับ Trusted Types
Content-Security-Policy:
script-src 'nonce-{RANDOM1}' 'strict-dynamic' https: 'unsafe-inline';
object-src 'none';
base-uri 'none';
require-trusted-types-for 'script';
<aside class="note"><b>หมายเหตุ: </b> คุณสามารถจำกัดชื่อนโยบายประเภทที่เชื่อถือได้ที่อนุญาตโดยการตั้งค่าคำสั่ง <code>trusted-types</code> เพิ่มเติม (เช่น <code>trusted-types myPolicy</code>) แต่ไม่จำเป็นต้องทำเช่นนี้ </aside>
-
กำหนดนโยบาย
นโยบาย:
// Feature detection if (window.trustedTypes && trustedTypes.createPolicy) { // Name and create a policy const policy = trustedTypes.createPolicy('escapePolicy', { createHTML: str => { return str.replace(/\/g, '>'); } }); }
-
ใช้นโยบาย
ใช้นโยบายเมื่อเขียนข้อมูลลงใน DOM:
// Assignment of raw strings are blocked by Trusted Types. el.innerHTML = 'some string'; // This throws an exception.</p> <p>// Assignment of Trusted Types is accepted safely. const escaped = policy.createHTML('<img src="x" onerror="alert(1)">'); el.innerHTML = escaped; // '<img src=x onerror=alert(1)>'
เมื่อใช้
require-trusted-types-for 'script'คุณต้องใช้ประเภทที่เชื่อถือได้ การใช้ DOM API ที่เป็นอันตรายกับสตริงจะทำให้เกิดข้อผิดพลาด
เบราว์เซอร์ที่รองรับ
ดูข้อมูลเพิ่มเติม
- ป้องกันช่องโหว่ของ Cross-site Scripting ที่อิงตาม DOM ด้วย Trusted Types
- CSP: require-trusted-types-for - HTTP | MDN
- CSP: trusted-types - HTTP | MDN
- การสาธิตประเภทที่เชื่อถือได้ - เปิดเครื่องมือตรวจสอบสำหรับนักพัฒนาซอฟต์แวร์และดูสิ่งที่เกิดขึ้น
X-Content-Type-Options
เมื่อมีการแสดงเอกสาร HTML ที่เป็นอันตรายจากโดเมนของคุณ (เช่น หากรูปภาพที่อัปโหลดไปยังบริการรูปภาพมีมาร์กอัป HTML ที่ถูกต้อง) เบราว์เซอร์บางรายการจะถือว่าเอกสารดังกล่าวเป็นเอกสารที่ใช้งานอยู่และอนุญาตให้เรียกใช้สคริปต์ในบริบทของแอปพลิเคชัน ซึ่งจะนำไปสู่ข้อบกพร่องของ Cross-site Scripting
X-Content-Type-Options: nosniff จะป้องกันการดำเนินการดังกล่าวโดยแจ้งให้เบราว์เซอร์ทราบว่าประเภท MIME ที่ตั้งค่าไว้ในส่วนหัว Content-Type สำหรับการตอบกลับหนึ่งๆ นั้นถูกต้อง เราขอแนะนำให้ใช้ส่วนหัวนี้กับทรัพยากรทั้งหมด
ตัวอย่างการใช้งาน
X-Content-Type-Options: nosniff
การใช้งานที่แนะนำ
ขอแนะนำให้ใช้ X-Content-Type-Options: nosniff สำหรับทรัพยากรทั้งหมดที่แสดงจากเซิร์ฟเวอร์ของคุณพร้อมกับส่วนหัว Content-Type ที่ถูกต้อง
ตัวอย่างส่วนหัวที่ส่งพร้อมกับ HTML ของเอกสาร
X-Content-Type-Options: nosniff Content-Type: text/html; charset=utf-8
เบราว์เซอร์ที่รองรับ
ดูข้อมูลเพิ่มเติม
X-Frame-Options
หากเว็บไซต์ที่เป็นอันตรายสามารถฝังเว็บไซต์ของคุณเป็น iframe ได้ ผู้โจมตีอาจเรียกใช้การดำเนินการที่ไม่ได้ตั้งใจโดยผู้ใช้ด้วยการลักลอบคลิก นอกจากนี้ ในบางกรณีการโจมตีประเภทสเปคเตอร์จะเปิดโอกาสให้เว็บไซต์ที่เป็นอันตรายเรียนรู้เกี่ยวกับเนื้อหาของเอกสารที่ฝังไว้
X-Frame-Options ระบุว่าควรอนุญาตให้เบราว์เซอร์แสดงผลหน้าเว็บใน <frame>, <iframe>, <embed> หรือ <object> หรือไม่ ขอแนะนำให้เอกสารทั้งหมดส่งส่วนหัวนี้เพื่อระบุว่าอนุญาตให้เอกสารอื่นๆ ฝังหรือไม่
ตัวอย่างการใช้งาน
X-Frame-Options: DENY
การใช้งานที่แนะนำ
เอกสารทั้งหมดที่ไม่ได้ออกแบบมาเพื่อฝังควรใช้ส่วนหัว X-Frame-Options
ป้องกันไม่ให้เว็บไซต์อื่นๆ ฝังเว็บไซต์ของคุณ
ปฏิเสธการฝังโดยเอกสารอื่นๆ
X-Frame-Options: DENYปกป้องเว็บไซต์ของคุณจากการฝังโดยเว็บไซต์แบบข้ามต้นทาง
อนุญาตให้ฝังโดยเอกสารจากต้นทางเดียวกันเท่านั้น
X-Frame-Options: SAMEORIGINเบราว์เซอร์ที่รองรับ
ดูข้อมูลเพิ่มเติม
นโยบายทรัพยากรแบบข้ามต้นทาง (CORP)
ผู้โจมตีสามารถฝังทรัพยากรจากต้นทางอื่น เช่น จากเว็บไซต์ของคุณ เพื่อดูข้อมูลเกี่ยวกับทรัพยากรเหล่านั้นโดยใช้ประโยชน์จากการรั่วไหลข้ามเว็บไซต์บนเว็บ
Cross-Origin-Resource-Policy ช่วยลดความเสี่ยงนี้โดยการระบุชุดเว็บไซต์ที่โหลดได้ ส่วนหัวจะใช้ค่าใดค่าหนึ่งจาก 3 ค่า ได้แก่ same-origin, same-site และ cross-origin เราขอแนะนำให้ทรัพยากรทั้งหมดส่งส่วนหัวนี้เพื่อระบุว่าจะอนุญาตให้เว็บไซต์อื่นๆ โหลดหรือไม่
ตัวอย่างการใช้งาน
Cross-Origin-Resource-Policy: same-origin
การใช้งานที่แนะนำ
ขอแนะนำให้แสดงทรัพยากรทั้งหมดด้วยส่วนหัวอย่างใดอย่างหนึ่งต่อไปนี้
อนุญาตให้โหลดทรัพยากร cross-origin
เราขอแนะนำให้บริการที่คล้ายกับ CDN ใช้ cross-origin กับทรัพยากร (เนื่องจากมักจะโหลดโดยหน้าเว็บแบบข้ามต้นทาง) เว้นแต่ว่าจะแสดงผ่าน CORS ซึ่งมีผลคล้ายกันอยู่แล้ว
Cross-Origin-Resource-Policy: cross-originจำกัดทรัพยากรที่จะโหลดจาก same-origin
ควรใช้ same-origin กับทรัพยากรที่มีไว้ให้โหลดโดยหน้าเว็บที่มีต้นทางเดียวกันเท่านั้น คุณควรใช้ส่วนหัวนี้กับทรัพยากรที่มีข้อมูลที่ละเอียดอ่อนเกี่ยวกับผู้ใช้ หรือการตอบกลับของ API ที่มีไว้เพื่อเรียกใช้จากต้นทางเดียวกันเท่านั้น
โปรดทราบว่าทรัพยากรที่มีส่วนหัวนี้จะยังคงโหลดได้โดยตรง เช่น โดยการไปยัง URL ในหน้าต่างเบราว์เซอร์ใหม่ นโยบายทรัพยากรแบบข้ามต้นทางจะปกป้องทรัพยากรจากการฝังโดยเว็บไซต์อื่นๆ เท่านั้น
Cross-Origin-Resource-Policy: same-originจำกัดทรัพยากรที่จะโหลดจาก same-site
ขอแนะนำให้ใช้ same-site กับทรัพยากรที่คล้ายกับด้านบน แต่มีไว้เพื่อให้โดเมนย่อยอื่นๆ ของเว็บไซต์โหลด
Cross-Origin-Resource-Policy: same-siteเบราว์เซอร์ที่รองรับ
ดูข้อมูลเพิ่มเติม
นโยบาย Cross-Origin Opener (COOP)
เว็บไซต์ของผู้โจมตีสามารถเปิดเว็บไซต์อื่นในหน้าต่างป๊อปอัปเพื่อดูข้อมูลเกี่ยวกับเว็บไซต์นั้นโดยใช้ประโยชน์จากการรั่วไหลข้ามเว็บไซต์บนเว็บ ในบางกรณี การดำเนินการนี้อาจทำให้เกิดการโจมตีแบบ Side-channel โดยอิงตามSpectreด้วย
ส่วนหัว Cross-Origin-Opener-Policy ช่วยให้เอกสารแยกตัวเองออกจากหน้าต่างแบบข้ามต้นทางที่เปิดผ่าน window.open() หรือลิงก์ที่มี target="_blank" โดยไม่มี rel="noopener" ได้ ด้วยเหตุนี้ ตัวเปิดแบบข้ามต้นทางของเอกสารจะไม่มีการอ้างอิงถึงเอกสารและจะไม่สามารถโต้ตอบกับเอกสารได้
ตัวอย่างการใช้งาน
Cross-Origin-Opener-Policy: same-origin-allow-popups
การใช้งานที่แนะนำ
แยกเอกสารออกจากหน้าต่างแบบข้ามต้นทาง
การตั้งค่า same-origin จะทำให้เอกสารแยกออกจากหน้าต่างเอกสารแบบข้ามต้นทาง
Cross-Origin-Opener-Policy: same-originแยกเอกสารออกจากหน้าต่างแบบข้ามต้นทาง แต่อนุญาตป๊อปอัป
การตั้งค่า same-origin-allow-popups ช่วยให้เอกสารเก็บการอ้างอิงไปยังหน้าต่างป๊อปอัปไว้ได้ เว้นแต่ว่าจะตั้งค่า COOP ด้วย same-origin หรือ same-origin-allow-popups ซึ่งหมายความว่า same-origin-allow-popups ยังคงปกป้องเอกสารจากการอ้างอิงเมื่อเปิดเป็นหน้าต่างป๊อปอัปได้ แต่จะอนุญาตให้สื่อสารกับป๊อปอัปของตัวเองได้
Cross-Origin-Opener-Policy: same-origin-allow-popupsอนุญาตให้หน้าต่างแบบข้ามต้นทางอ้างอิงเอกสารได้
unsafe-none เป็นค่าเริ่มต้น แต่คุณสามารถระบุอย่างชัดเจนว่าเอกสารนี้สามารถเปิดได้โดยหน้าต่างแบบข้ามต้นทางและคงสิทธิ์เข้าถึงร่วมกันไว้
Cross-Origin-Opener-Policy: unsafe-noneรูปแบบรายงานที่ใช้ร่วมกับ COOP ไม่ได้
คุณจะได้รับรายงานเมื่อ COOP ป้องกันการโต้ตอบข้ามหน้าต่างด้วย Reporting API
Cross-Origin-Opener-Policy: same-origin; report-to="coop"นอกจากนี้ COOP ยังรองรับโหมดรายงานเท่านั้นเพื่อให้คุณรับรายงานได้โดยไม่ต้องบล็อกการสื่อสารระหว่างเอกสารแบบข้ามต้นทางจริงๆ
Cross-Origin-Opener-Policy-Report-Only: same-origin; report-to="coop"เบราว์เซอร์ที่รองรับ
ดูข้อมูลเพิ่มเติม
การแชร์ทรัพยากรแบบข้ามต้นทาง (CORS)
กลไกการแชร์ทรัพยากรข้ามโดเมน (CORS) ไม่ใช่ส่วนหัวเหมือนกับรายการอื่นๆ ในบทความนี้ แต่เป็นกลไกของเบราว์เซอร์ที่ขอและอนุญาตให้เข้าถึงทรัพยากรข้ามโดเมน
โดยค่าเริ่มต้น เบราว์เซอร์จะบังคับใช้นโยบายต้นทางเดียวกันเพื่อป้องกันไม่ให้หน้าเว็บเข้าถึงทรัพยากรแบบข้ามต้นทาง ตัวอย่างเช่น เมื่อโหลดรูปภาพแบบข้ามต้นทาง แม้ว่ารูปภาพจะแสดงบนหน้าเว็บอย่างชัดเจน แต่ JavaScript ในหน้าเว็บจะไม่มีสิทธิ์เข้าถึงข้อมูลของรูปภาพ ผู้ให้บริการทรัพยากรสามารถผ่อนคลายข้อจำกัดและอนุญาตให้เว็บไซต์อื่นๆ อ่านทรัพยากรได้โดยเลือกใช้ CORS
ตัวอย่างการใช้งาน
Access-Control-Allow-Origin: https://example.com
Access-Control-Allow-Credentials: true
ก่อนที่จะดูวิธีกำหนดค่า CORS คุณควรทำความเข้าใจความแตกต่างระหว่างประเภทคำขอ คำขอจะได้รับการจัดประเภทเป็นคำขอแบบง่ายหรือคำขอแบบ Preflight ทั้งนี้ขึ้นอยู่กับรายละเอียดคำขอ
เกณฑ์สำหรับคำขอแบบง่ายมีดังนี้
- วิธีการคือ
GET,HEADหรือPOST - ส่วนหัวที่กำหนดเองจะมีเฉพาะ
Accept,Accept-Language,Content-LanguageและContent-Type Content-Typeคือapplication/x-www-form-urlencoded,multipart/form-dataหรือtext/plain
ส่วนคำขออื่นๆ ทั้งหมดจะจัดประเภทเป็นคำขอที่ผ่านการตรวจสอบล่วงหน้า ดูรายละเอียดเพิ่มเติมได้ที่กลไกการแชร์ทรัพยากรแบบข้ามต้นทาง (CORS) - HTTP | MDN
การใช้งานที่แนะนำ
คำของ่ายๆ
เมื่อคำขอเป็นไปตามเกณฑ์คำขอแบบง่าย เบราว์เซอร์จะส่งคำขอแบบข้ามต้นทางพร้อมส่วนหัว Origin ที่ระบุต้นทางที่ส่งคำขอ
ตัวอย่างส่วนหัวของคำขอ
Get / HTTP/1.1 Origin: https://example.com
ตัวอย่างส่วนหัวการตอบกลับ
Access-Control-Allow-Origin: https://example.com Access-Control-Allow-Credentials: true
Access-Control-Allow-Origin: https://example.comบ่งชี้ว่าhttps://example.comสามารถเข้าถึงเนื้อหาของการตอบกลับได้ ทรัพยากรที่เว็บไซต์ใดๆ อ่านได้สามารถตั้งค่าส่วนหัวนี้เป็น*ซึ่งในกรณีนี้เบราว์เซอร์จะกำหนดให้ส่งคำขอโดยไม่มีข้อมูลเข้าสู่ระบบเท่านั้นAccess-Control-Allow-Credentials: trueบ่งชี้ว่าคำขอที่มีข้อมูลเข้าสู่ระบบ (คุกกี้) ได้รับอนุญาตให้โหลดทรัพยากร มิเช่นนั้น ระบบจะปฏิเสธคำขอที่ตรวจสอบสิทธิ์แล้ว แม้ว่าต้นทางที่ส่งคำขอจะอยู่ในส่วนหัวAccess-Control-Allow-Originก็ตาม
คำขอที่ตรวจสอบล่วงหน้า
คำขอที่ผ่านการตรวจสอบล่วงหน้าจะนำหน้าด้วยคำขอ OPTIONS เพื่อตรวจสอบว่าอนุญาตให้ส่งคำขอที่ตามมาหรือไม่
ตัวอย่างส่วนหัวของคำขอ
OPTIONS / HTTP/1.1 Origin: https://example.com Access-Control-Request-Method: POST Access-Control-Request-Headers: X-PINGOTHER, Content-Type
Access-Control-Request-Method: POSTอนุญาตให้ส่งคำขอต่อไปนี้ด้วยเมธอดPOSTAccess-Control-Request-Headers: X-PINGOTHER, Content-Typeช่วยให้ผู้ส่งคำขอตั้งค่าส่วนหัว HTTPX-PINGOTHERและContent-Typeในคำขอต่อมาได้
ตัวอย่างส่วนหัวการตอบกลับ
Access-Control-Allow-Origin: https://example.com Access-Control-Allow-Credentials: true Access-Control-Allow-Methods: POST, GET, OPTIONS Access-Control-Allow-Headers: X-PINGOTHER, Content-Type Access-Control-Max-Age: 86400
Access-Control-Allow-Methods: POST, GET, OPTIONSบ่งชี้ว่าสามารถส่งคำขอที่ตามมาด้วยเมธอดPOST,GETและOPTIONSAccess-Control-Allow-Headers: X-PINGOTHER, Content-Typeบ่งชี้ว่าคำขอที่ตามมาสามารถรวมส่วนหัวX-PINGOTHERและContent-Typeได้Access-Control-Max-Age: 86400บ่งบอกว่าผลลัพธ์ของคำขอที่ตรวจสอบล่วงหน้าสามารถแคชไว้ได้เป็นเวลา 86,400 วินาที
เบราว์เซอร์ที่รองรับ
ดูข้อมูลเพิ่มเติม
นโยบายเครื่องมือฝังแบบข้ามต้นทาง (COEP)
ระบบจะปิดใช้ฟีเจอร์ต่างๆ เช่น SharedArrayBuffer หรือ performance.measureUserAgentSpecificMemory() โดยค่าเริ่มต้น เพื่อลดความสามารถของการโจมตีที่อิงตาม Spectre ในการขโมยทรัพยากรแบบข้ามต้นทาง
Cross-Origin-Embedder-Policy: require-corp ป้องกันไม่ให้เอกสารและเวิร์กเกอร์โหลดทรัพยากรแบบข้ามต้นทาง เช่น รูปภาพ สคริปต์ สไตล์ชีต iframe และอื่นๆ เว้นแต่ทรัพยากรเหล่านี้จะเลือกให้โหลดผ่านส่วนหัว CORS หรือ CORP อย่างชัดแจ้ง COEP สามารถใช้ร่วมกับ Cross-Origin-Opener-Policy เพื่อเลือกใช้เอกสารในการแยกแบบข้ามต้นทาง
ใช้ Cross-Origin-Embedder-Policy: require-corp เมื่อต้องการเปิดใช้การแยกแบบข้ามต้นทางสำหรับเอกสาร
ตัวอย่างการใช้งาน
Cross-Origin-Embedder-Policy: require-corp
ตัวอย่างการใช้งาน
COEP จะใช้ค่าเดียวของ require-corp การส่งส่วนหัวนี้จะช่วยให้คุณสั่งให้เบราว์เซอร์บล็อกการโหลดทรัพยากรที่ไม่ได้เลือกใช้ผ่าน CORS หรือ CORP ได้
เปิดใช้การแยกแบบข้ามต้นทาง
เปิดใช้การแยกแบบข้ามต้นทางโดยส่ง Cross-Origin-Embedder-Policy: require-corp พร้อมกับ Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Embedder-Policy: require-corp Cross-Origin-Opener-Policy: same-origin
รายงานทรัพยากรที่ใช้ร่วมกับ COEP ไม่ได้
คุณสามารถรับรายงานทรัพยากรที่ถูกบล็อกซึ่งเกิดจาก COEP ด้วย Reporting API
Cross-Origin-Embedder-Policy: require-corp; report-to="coep"COEP ยังรองรับโหมดรายงานเท่านั้นเพื่อให้คุณรับรายงานได้โดยไม่ต้องบล็อกทรัพยากรที่โหลดจริงๆ
Cross-Origin-Embedder-Policy-Report-Only: require-corp; report-to="coep"เบราว์เซอร์ที่รองรับ
ดูข้อมูลเพิ่มเติม
HTTP Strict Transport Security (HSTS)
การสื่อสารผ่านการเชื่อมต่อ HTTP ธรรมดาจะไม่ได้รับการเข้ารหัส ทำให้ผู้ดักฟังระดับเครือข่ายเข้าถึงข้อมูลที่โอนได้
ส่วนหัว Strict-Transport-Security จะแจ้งให้เบราว์เซอร์ทราบว่าไม่ควรโหลดเว็บไซต์โดยใช้ HTTP และให้ใช้ HTTPS แทน เมื่อตั้งค่าแล้ว เบราว์เซอร์จะใช้ HTTPS แทน HTTP เพื่อเข้าถึงโดเมนโดยไม่มีการเปลี่ยนเส้นทางเป็นระยะเวลาที่กำหนดไว้ในส่วนหัว
ตัวอย่างการใช้งาน
Strict-Transport-Security: max-age=31536000
การใช้งานที่แนะนำ
เว็บไซต์ทั้งหมดที่เปลี่ยนจาก HTTP เป็น HTTPS ควรตอบกลับด้วยส่วนหัว Strict-Transport-Security เมื่อได้รับคำขอที่มี HTTP
Strict-Transport-Security: max-age=31536000เบราว์เซอร์ที่รองรับ