ข้อมูลอ้างอิงด่วนของส่วนหัวการรักษาความปลอดภัย

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

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

ส่วนหัวด้านความปลอดภัยที่แนะนำสำหรับเว็บไซต์ที่จัดการข้อมูลที่ละเอียดอ่อนของผู้ใช้มีดังนี้
นโยบายรักษาความปลอดภัยเนื้อหา (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) และการรั่วไหลแบบข้ามเว็บไซต์ต่างๆ

การพัฒนาเว็บหลังสเปคเตอร์เป็นบทความที่น่าอ่านหากคุณสนใจส่วนหัวเหล่านี้

สร้างเว็บไซต์ที่มีประสิทธิภาพอย่างปลอดภัย

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

เข้ารหัสการเข้าชมเว็บไซต์

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

การเข้ารหัสที่ไม่เพียงพออาจเกิดขึ้นในกรณีต่อไปนี้ ไม่ใช้ HTTPS, เนื้อหาผสม, การตั้งค่าคุกกี้โดยไม่มีแอตทริบิวต์ Secure (หรือคำนำหน้า __Secure) หรือตรรกะการตรวจสอบ CORS ที่ไม่เข้มงวด

นโยบายรักษาความปลอดภัยเนื้อหา (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';
วิธีใช้ CSP

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, '&lt;').replace(/>/g, '&gt;');
    }
  });
}

// Assignment of raw strings is blocked by Trusted Types.
el.innerHTML = &#39;some string&#39;; // This throws an exception.

// Assignment of Trusted Types is accepted safely.
const escaped = policy.createHTML(&#39;&lt;img src=x onerror=alert(1)&gt;&#39;);
el.innerHTML = escaped;  // &#39;&amp;lt;img src=x onerror=alert(1)&amp;gt;&#39;

วิธีใช้ Trusted Types

  1. บังคับใช้ 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 &#39;nonce-{RANDOM1}&#39; &#39;strict-dynamic&#39; https: &#39;unsafe-inline&#39;;
  object-src &#39;none&#39;;
  base-uri &#39;none&#39;;
  require-trusted-types-for &#39;script&#39;;

<aside class="note"><b>หมายเหตุ: </b> คุณสามารถจำกัดชื่อนโยบายประเภทที่เชื่อถือได้ที่อนุญาตโดยการตั้งค่าคำสั่ง <code>trusted-types</code> เพิ่มเติม (เช่น <code>trusted-types myPolicy</code>) แต่ไม่จำเป็นต้องทำเช่นนี้ </aside>

  1. กำหนดนโยบาย

    นโยบาย:

    // Feature detection
    if (window.trustedTypes && trustedTypes.createPolicy) {
      // Name and create a policy
      const policy = trustedTypes.createPolicy('escapePolicy', {
        createHTML: str => {
          return str.replace(/\/g, '>');
        }
      });
    }
  2. ใช้นโยบาย

    ใช้นโยบายเมื่อเขียนข้อมูลลงใน DOM:

    // Assignment of raw strings are blocked by Trusted Types.
    el.innerHTML = &#39;some string&#39;; // This throws an exception.</p>
    
    <p>// Assignment of Trusted Types is accepted safely.
    const escaped = policy.createHTML(&#39;<img src="x" onerror="alert(1)">&#39;);
    el.innerHTML = escaped;  // &#39;&lt;img src=x onerror=alert(1)&gt;&#39;

    เมื่อใช้ require-trusted-types-for 'script' คุณต้องใช้ประเภทที่เชื่อถือได้ การใช้ DOM API ที่เป็นอันตรายกับสตริงจะทำให้เกิดข้อผิดพลาด

เบราว์เซอร์ที่รองรับ

ดูข้อมูลเพิ่มเติม

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

ขอแนะนำให้ใช้ X-Content-Type-Options: nosniff สำหรับทรัพยากรทั้งหมดที่แสดงจากเซิร์ฟเวอร์ของคุณพร้อมกับส่วนหัว Content-Type ที่ถูกต้อง

X-Content-Type-Options: nosniff

ตัวอย่างส่วนหัวที่ส่งพร้อมกับ HTML ของเอกสาร

X-Content-Type-Options: nosniff
Content-Type: text/html; charset=utf-8

เบราว์เซอร์ที่รองรับ

Browser Support

  • Chrome: 64.
  • Edge: 12.
  • Firefox: 50.
  • Safari: 11.

Source

ดูข้อมูลเพิ่มเติม

X-Frame-Options

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

X-Frame-Options ระบุว่าควรอนุญาตให้เบราว์เซอร์แสดงผลหน้าเว็บใน <frame>, <iframe>, <embed> หรือ <object> หรือไม่ ขอแนะนำให้เอกสารทั้งหมดส่งส่วนหัวนี้เพื่อระบุว่าอนุญาตให้เอกสารอื่นๆ ฝังหรือไม่

ตัวอย่างการใช้งาน

X-Frame-Options: DENY
วิธีใช้ X-Frame-Options

เอกสารทั้งหมดที่ไม่ได้ออกแบบมาเพื่อฝังควรใช้ส่วนหัว X-Frame-Options

ป้องกันไม่ให้เว็บไซต์อื่นๆ ฝังเว็บไซต์ของคุณ

ปฏิเสธการฝังโดยเอกสารอื่นๆ

X-Frame-Options: DENY
X-Frame-Options: DENY

ปกป้องเว็บไซต์ของคุณจากการฝังโดยเว็บไซต์แบบข้ามต้นทาง

อนุญาตให้ฝังโดยเอกสารจากต้นทางเดียวกันเท่านั้น

X-Frame-Options: SAMEORIGIN

เบราว์เซอร์ที่รองรับ

Browser Support

  • Chrome: 4.
  • Edge: 12.
  • Firefox: 4.
  • Safari: 4.

Source

ดูข้อมูลเพิ่มเติม

นโยบายทรัพยากรแบบข้ามต้นทาง (CORP)

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

Cross-Origin-Resource-Policy ช่วยลดความเสี่ยงนี้โดยการระบุชุดเว็บไซต์ที่โหลดได้ ส่วนหัวจะใช้ค่าใดค่าหนึ่งจาก 3 ค่า ได้แก่ same-origin, same-site และ cross-origin เราขอแนะนำให้ทรัพยากรทั้งหมดส่งส่วนหัวนี้เพื่อระบุว่าจะอนุญาตให้เว็บไซต์อื่นๆ โหลดหรือไม่

ตัวอย่างการใช้งาน

Cross-Origin-Resource-Policy: same-origin
วิธีใช้ CORP

ขอแนะนำให้แสดงทรัพยากรทั้งหมดด้วยส่วนหัวอย่างใดอย่างหนึ่งต่อไปนี้

อนุญาตให้โหลดทรัพยากร cross-origin

เราขอแนะนำให้บริการที่คล้ายกับ CDN ใช้ cross-origin กับทรัพยากร (เนื่องจากมักจะโหลดโดยหน้าเว็บแบบข้ามต้นทาง) เว้นแต่ว่าจะแสดงผ่าน CORS ซึ่งมีผลคล้ายกันอยู่แล้ว

Cross-Origin-Resource-Policy: cross-origin
Cross-Origin-Resource-Policy: cross-origin

จำกัดทรัพยากรที่จะโหลดจาก same-origin

ควรใช้ same-origin กับทรัพยากรที่มีไว้ให้โหลดโดยหน้าเว็บที่มีต้นทางเดียวกันเท่านั้น คุณควรใช้ส่วนหัวนี้กับทรัพยากรที่มีข้อมูลที่ละเอียดอ่อนเกี่ยวกับผู้ใช้ หรือการตอบกลับของ API ที่มีไว้เพื่อเรียกใช้จากต้นทางเดียวกันเท่านั้น

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

Cross-Origin-Resource-Policy: same-origin
Cross-Origin-Resource-Policy: same-origin

จำกัดทรัพยากรที่จะโหลดจาก same-site

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

Cross-Origin-Resource-Policy: same-site
Cross-Origin-Resource-Policy: same-site

เบราว์เซอร์ที่รองรับ

Browser Support

  • Chrome: 73.
  • Edge: 79.
  • Firefox: 74.
  • Safari: 12.

Source

ดูข้อมูลเพิ่มเติม

นโยบาย 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
วิธีใช้ COOP

แยกเอกสารออกจากหน้าต่างแบบข้ามต้นทาง

การตั้งค่า same-origin จะทำให้เอกสารแยกออกจากหน้าต่างเอกสารแบบข้ามต้นทาง

Cross-Origin-Opener-Policy: 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
Cross-Origin-Opener-Policy: same-origin-allow-popups

อนุญาตให้หน้าต่างแบบข้ามต้นทางอ้างอิงเอกสารได้

unsafe-none เป็นค่าเริ่มต้น แต่คุณสามารถระบุอย่างชัดเจนว่าเอกสารนี้สามารถเปิดได้โดยหน้าต่างแบบข้ามต้นทางและคงสิทธิ์เข้าถึงร่วมกันไว้

Cross-Origin-Opener-Policy: 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"

เบราว์เซอร์ที่รองรับ

Browser Support

  • Chrome: 83.
  • Edge: 83.
  • Firefox: 79.
  • Safari: 15.2.

Source

ดูข้อมูลเพิ่มเติม

การแชร์ทรัพยากรแบบข้ามต้นทาง (CORS)

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

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

ตัวอย่างการใช้งาน

Access-Control-Allow-Origin: https://example.com
Access-Control-Allow-Credentials: true
วิธีใช้ CORS

ก่อนที่จะดูวิธีกำหนดค่า 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 อนุญาตให้ส่งคำขอต่อไปนี้ด้วยเมธอด POST
  • Access-Control-Request-Headers: X-PINGOTHER, Content-Type ช่วยให้ผู้ส่งคำขอตั้งค่าส่วนหัว HTTP X-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 และ OPTIONS
  • Access-Control-Allow-Headers: X-PINGOTHER, Content-Type บ่งชี้ว่าคำขอที่ตามมาสามารถรวมส่วนหัว X-PINGOTHER และ Content-Type ได้
  • Access-Control-Max-Age: 86400 บ่งบอกว่าผลลัพธ์ของคำขอที่ตรวจสอบล่วงหน้าสามารถแคชไว้ได้เป็นเวลา 86,400 วินาที

เบราว์เซอร์ที่รองรับ

Browser Support

  • Chrome: 4.
  • Edge: 12.
  • Firefox: 3.5.
  • Safari: 4.

Source

ดูข้อมูลเพิ่มเติม

นโยบายเครื่องมือฝังแบบข้ามต้นทาง (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

ตัวอย่างการใช้งาน

COEP จะใช้ค่าเดียวของ require-corp การส่งส่วนหัวนี้จะช่วยให้คุณสั่งให้เบราว์เซอร์บล็อกการโหลดทรัพยากรที่ไม่ได้เลือกใช้ผ่าน CORS หรือ CORP ได้

วิธีการทำงานของ COEP

เปิดใช้การแยกแบบข้ามต้นทาง

เปิดใช้การแยกแบบข้ามต้นทางโดยส่ง 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"

เบราว์เซอร์ที่รองรับ

Browser Support

  • Chrome: 83.
  • Edge: 83.
  • Firefox: 79.
  • Safari: 15.2.

Source

ดูข้อมูลเพิ่มเติม

HTTP Strict Transport Security (HSTS)

การสื่อสารผ่านการเชื่อมต่อ HTTP ธรรมดาจะไม่ได้รับการเข้ารหัส ทำให้ผู้ดักฟังระดับเครือข่ายเข้าถึงข้อมูลที่โอนได้

ส่วนหัว Strict-Transport-Security จะแจ้งให้เบราว์เซอร์ทราบว่าไม่ควรโหลดเว็บไซต์โดยใช้ HTTP และให้ใช้ HTTPS แทน เมื่อตั้งค่าแล้ว เบราว์เซอร์จะใช้ HTTPS แทน HTTP เพื่อเข้าถึงโดเมนโดยไม่มีการเปลี่ยนเส้นทางเป็นระยะเวลาที่กำหนดไว้ในส่วนหัว

ตัวอย่างการใช้งาน

Strict-Transport-Security: max-age=31536000
วิธีใช้ HSTS

เว็บไซต์ทั้งหมดที่เปลี่ยนจาก HTTP เป็น HTTPS ควรตอบกลับด้วยส่วนหัว Strict-Transport-Security เมื่อได้รับคำขอที่มี HTTP

Strict-Transport-Security: max-age=31536000

เบราว์เซอร์ที่รองรับ

Browser Support

  • Chrome: 4.
  • Edge: 12.
  • Firefox: 4.
  • Safari: 7.

Source

ดูข้อมูลเพิ่มเติม

อ่านเพิ่มเติม