HTTP biztonsági fejlécek: Egyszerű mód a webalkalmazások megerősítésére

HTTP biztonsági fejlécek: Egyszerű mód a webalkalmazások megerősítésére

A modern böngészők és szerverek erős biztonsági vezérlőket biztosítanak HTTP fejléceken keresztül. Állítsa be egyszer, és a böngésző minden kérésnél érvényesíti a házirendet. Az alkalmazáskód futása előtt teljes támadásosztályokat blokkolhat. Ide tartozik a clickjacking, a cross-site scripting, a MIME sniffing, a nem biztonságos adatátvitel, a különböző eredetű források közötti adat-szivárgás és a gyenge munkamenet-kezelés. A fejlécek kiegészítik a bemeneti validálást, a kimeneti kódolást és az autentikációt. Igazodnak az OWASP Top 10 kockázataihoz és csökkentik a hibás konfigurációból eredő eltérést a különböző stackekben.

Mit nyújtanak ezek a fejlécek

  • Kikényszerítik a HTTPS-t és megállítják a visszaminősítési támadásokat a HSTS segítségével.
  • Korlátozzák, hogy honnan tölthetők be szkriptek, stílusok és egyéb erőforrások a Content-Security-Policy (CSP) használatával.
  • Blokkolják a clickjacking támadásokat azáltal, hogy szabályozzák, hol ágyazható be az oldal, a frame-ancestors utasítással (amely a CSP része és felülírja a régebbi X-Frame-Options fejlécet).
  • Letiltják a MIME sniffinget az X-Content-Type-Options használatával.
  • Korlátozzák a hivatkozó adatok kitettségét a Referrer-Policy segítségével.
  • Kapuzzák a nagy teljesítményű böngészőfunkciókat a Permissions-Policy segítségével.
  • Elérhetővé teszik a cross-origin izolációt, amikor a funkciókészlet megköveteli, a COOP, a COEP és a CORP használatával.
  • Szabályozzák a legitim cross-origin API-hozzáférést a CORS segítségével, és ellenőrzik a szándékot a Fetch Metadata használatával.
  • Védik a munkameneteket a Secure, HttpOnly és SameSite sütikkel.
  • Ellenőrzik a CDN erőforrásokat a Subresource Integrityvel.

Hogyan érdemes velük dolgozni

  • Kezelje a fejléceket, mint kódolt konfigurációt. Tartsa verziókezelésben.
  • Vezesse be report-only és kanári útvonalakkal, majd kényszerítse ki.
  • Ellenőrizze CI környezetben curl ellenőrzésekkel és megbízható szkennerekkel.
  • Használjon DAST megoldásokat a valós viselkedés megerősítésére staging és éles környezetben.
  • Vizsgálja felül a házirendeket, amikor új külső szkripteket, új API-kat vagy új funkciókat ad hozzá.

TLDR

  • Kezdje a CSP-vel Report-Only módban. Használja a default-src 'self' beállítást, nonce-okat a beágyazott szkriptekhez, és a frame-ancestors 'self' direktívát. A jelentésküldést hagyja bekapcsolva.
  • A HTTPS javítása után kapcsolja be a HTTP Strict Transport Securityt. Használja a max-age=31536000; includeSubDomains értéket. A preload-ot csak akkor adja hozzá, ha minden aldomainre készen áll.
  • Hagyja abba a HPKP, az X-XSS-Protection és az Expect-CT használatát. Helyette használjon HSTS-t és CSP-t.
  • Állítsa be a következőt: Referrer-Policy: strict-origin-when-cross-origin. Ha érzékeny adatokat kezel, használja a no-referrer értéket.
  • Csak szükség esetén engedélyezze a cross-origin izolációt. Használja a COOP: same-origin és a COEP: require-corp beállítást, vagy credentialless módot. Adjon CORP-ot az erőforrásaira.
  • Mindig küldje: X-Content-Type-Options: nosniff.
  • Zárja le a sütiket a Secure; HttpOnly; SameSite=Lax vagy a Strict értékekkel. A SameSite=None; Secure beállítást csak harmadik fél sütijeihez használja.
  • Használjon CORS engedélyezési listákat. Soha ne kombinálja a * karaktert hitelesítési adatokkal. Az előzetes kérést rövid Access-Control-Max-Age értékkel cache-elje.
  • Adjon hozzá Fetch Metadata ellenőrzéseket az állapotot módosító végpontokhoz. Utasítsa el gyorsan a cross-site nem biztonságos metódusokat.
  • Használjon Subresource Integrityt a CDN szkriptekhez és stílusokhoz.

Fő fejlécek, biztonságos alapbeállítások és példák

Content-Security-Policy (CSP)

Cél: korlátozza, hogy az oldal honnan tölthet be szkripteket, stílusokat, képeket, frame-eket és egyebeket. Ez mérsékli az XSS-t és az adatbefecskendezést.

Biztonságos kiindulási pont

Content-Security-Policy: default-src 'self'; base-uri 'self'; object-src 'none';
script-src 'self' 'nonce-{RANDOM}';
style-src 'self';
img-src 'self' data:;
frame-ancestors 'self';
upgrade-insecure-requests

Report-Only hangolás közben

Reporting-Endpoints: csp="https://example.com/csp-reports"
Content-Security-Policy-Report-Only: default-src 'self'; base-uri 'self'; object-src 'none'; script-src 'self' 'nonce-{RANDOM}'; style-src 'self'; img-src 'self' data:; frame-ancestors 'self'; upgrade-insecure-requests; report-to csp; report-uri https://example.com/csp-legacy

Reporting API beállítás

Report-To: {"group":"csp-endpoint","max_age":10886400,"endpoints":[{"url":"https://example.com/csp-reports"}],"include_subdomains":true}

Megjegyzés: Elsődlegesen használja a report-to mezőt (modern Reporting API). A report-uri-t csak az átmeneti időszakban, a régi böngészők támogatásához tartsa meg.

Tippek

  • Részesítse előnyben a nonce-okat a beágyazott indítószkriptekhez. Generáljon véletlen nonce-ot minden válaszhoz.
  • Cserélje le az X-Frame-Options fejlécet a frame-ancestors direktívára.
  • Tartsa meg a report-uri-t a régi böngészők számára.
  • Használja a report-to-t a modern Reporting API-hoz. A csp-endpoint értéknek meg kell egyeznie egy külön Report-To HTTP fejlécben definiált csoportnévvel.

Telepítési ellenőrzőlista

  • Indítson Content-Security-Policy-Report-Only móddal minden oldalon.
  • Generáljon új, kriptográfiailag véletlen nonce-ot minden válaszhoz. Ne használja újra kérések között.
  • Távolítsa el az inline eseménykezelőket és az eval-t. Helyettesítse olyan szkriptfájlokkal, amelyek az oldal nonce-át használják.
  • Sorolja fel kifejezetten a külső szkripthosztokat. Kerülje a helyettesítő karaktereket és a data: sémát szkriptekhez.
  • Adja hozzá a frame-ancestors 'self' direktívát akkor is, ha úgy gondolja, hogy nincs beágyazás.
  • Tartsa meg az object-src 'none' beállítást. Bővítményeknek 2025-ben nem kellene szükségesnek lenniük.
  • Váltson a CSP kényszerítésére, amikor a szabálysértések stabilizálódnak, majd hagyja a jelentésküldést bekapcsolva.

Külső szkriptek stratégiája

  • Amikor lehetséges, részesítse előnyben a szerveroldali vagy tagkezelőn hosztolt saját tükröket.
  • Analitikához csak a pontos eredeteket és a szükséges direktívákat engedélyezze. Tiltsa a connect-src-ot ismeretlen hosztok felé.
  • Forgassa a nonce-okat, és ne engedélyezze a 'unsafe-inline' vagy a 'unsafe-eval' használatát.

CSP összehasonlítás

NévCélKritikus direktívákPéldaértékBöngészőtámogatásKompatibilitási kockázatEszközökkel kapcsolatos megjegyzések
Content-Security-PolicyKliensoldali tartalomizolációs házirend, amely a deklarált eredetekre korlátozza az erőforrás-letöltési és futtatási kontextusokat, mérsékelve a visszavert, tárolt és DOM-alapú XSS-t, az aktív tartalom befecskendezését és az UI-visszaélést a frame-ancestors alkalmazásávaldefault-src, script-src nonce-szal, frame-ancestors, object-src 'none', upgrade-insecure-requestsLásd a fenti házirendetChrome 25+, Edge 12+, Firefox 23+, Safari 7+, Opera 15+, iOS Safari 6+, IE 10-11 részlegesen a X-Content-Security-Policy révénKözepestől magasig. A nonce vagy hash nélküli inline szkriptek blokkolódnak, a nem deklarált külső hosztok nem töltenek be, az eval-szerű konstrukciók megszakadnak, és a régi taget kezelők vagy az inline eseménykezelők nem működnekHasználja a Reporting API-t, és a migráció alatt tartsa meg a report-uri-t

HTTP Strict-Transport-Security (HSTS)

Cél: HTTPS kikényszerítése. HTTP és érvénytelen TLS megkerülési kísérletek blokkolása.

Strict-Transport-Security: max-age=31536000; includeSubDomains

Előbetöltés

  • A preload-ot csak akkor adja hozzá, ha minden aldomain HTTPS-t használ és ezt fenn is tartja. Ha már biztos benne, beküldheti a tartományát a hivatalos előbetöltési listára itt: hstspreload.org (új ablakban nyílik meg).
  • Visszaállítás lassú és kockázatos.

Figyelmeztetés: a HSTS előbetöltés gyakorlati szempontból tartós. A böngészők előbetöltési listáiról való eltávolítás 6–12 hónapot is igénybe vehet, és minden nagy böngészővel összehangolást kíván. Csak akkor küldje be a hstspreload.org (új ablakban nyílik meg) oldalra, ha:

  • Minden aldomain érvényes HTTPS-t szolgál ki (a belső eszközök is)
  • Sehol nincs HTTP fallback
  • Rendelkezik dokumentált üzleti jóváhagyással a tartós HTTPS-kikényszerítéshez

Előbetöltési felkészültségi ellenőrzőlista

  • Minden aldomain HTTPS-t szolgál ki érvényes tanúsítványokkal.
  • Állandó 301-es átirányítás van beállítva HTTP-ről HTTPS-re minden hoszton.
  • Nincs olyan belső vagy örökölt rendszer, amely sima HTTP-t igényelne.
  • A max-age legalább 31536000, és az includeSubDomains be van állítva legalább két héttel a beküldés előtt.
  • Dokumentálja a visszaállítási tervet. Az előbetöltés eltávolítása időigényes és nem végezhető el azonnal.

HSTS összehasonlítás

NévCélKritikus direktívákPéldaértékBöngészőtámogatásKompatibilitási kockázatEszközökkel kapcsolatos megjegyzések
HSTSSzállítási biztonsági házirend, amely utasítja a felhasználói ügynököket, hogy a HTTP-t automatikusan HTTPS-re frissítsék, és az eredetre vonatkozóan rögzítsék a kizárólag HTTPS használatát, megelőzve a protokoll-visszaminősítést és az SSL strippingetmax-age, includeSubDomains, opcionális preloadmax-age=31536000; includeSubDomainsChrome 4+, Edge 12+, Firefox 4+, Safari 7+, Opera 12+, IE 11 Windows 8.1-en vagy Windows 7-en KB3058515-telMagas, ha bármely aldomain vagy örökölt végpont továbbra is HTTP-t szolgál ki, vagy érvénytelen TLS-t mutat, mivel a böngésző ezekre a navigációkra kemény hibával reagálElőször tesztelje az átirányításokat és a tanúsítványokat

Referrer-Policy

Cél: szabályozza, mennyi hivatkozó információt küld.

Alapértelmezett

Referrer-Policy: strict-origin-when-cross-origin

Maximális adatvédelemhez használja a no-referrer értéket.

Referrer-Policy összehasonlítás

NévCélKritikus direktívákPéldaértékBöngészőtámogatásKompatibilitási kockázatEszközökkel kapcsolatos megjegyzések
Referrer-PolicyKérés-privát szféra vezérlés, amely korlátozza a Referer fejléc részletezettségét azonos és különböző eredetű navigációk, valamint alerőforrás-letöltések során, csökkentve az eredet- és útvonal-szivárgástEgyetlen token, például no-referrer, strict-origin-when-cross-originstrict-origin-when-cross-originChrome 61+, Edge 79+, Firefox 52+, Safari 11.1+, Opera 48+, iOS Safari 12+Alacsony. Egyes analitikák, A/B irányítás vagy fizetési visszahívások, amelyek teljes útvonalú hivatkozókra támaszkodnak, csökkent láthatóságot tapasztalhatnakEllenőrizze az analitikát, amely teljes hivatkozókra támaszkodik

Permissions-Policy

Cél: hozzáférés szabályozása olyan funkciókhoz, mint a földrajzi hely, a kamera és a mikrofon.

Szigorú alapértelmezett

Permissions-Policy: geolocation=(), camera=(), microphone=()

Ellenőrzési lépések

  • Keresés a kódban a funkció API-k után.
  • DevTools használata a felugrók és letiltott funkciók megtekintéséhez.
  • A szükséges útvonalakon nyissa meg a házirendeket.

Gyakori, kapuzandó funkciók

  • geolocation=(), camera=(), microphone=() olyan oldalakhoz, ahol ezeket soha nem használják.
  • payment=() és usb=() nyilvános marketingoldalakhoz.
  • fullscreen=(self) olyan alkalmazásokhoz, amelyek médiamegtekintőt használnak.

Permissions-Policy összehasonlítás

NévCélKritikus direktívákPéldaértékBöngészőtámogatásKompatibilitási kockázatEszközökkel kapcsolatos megjegyzések
Permissions-PolicyFunkciókapuzási házirend, amely eredetenként és beágyazási kontextusonként engedélyezi vagy tiltja a nagy teljesítményű böngésző-képességeket, biztosítva a legkisebb jogosultság elvét olyan API-k esetén, mint a geolocation, a kamera és a mikrofonFunkciónkénti engedélyezési listákgeolocation=(), camera=(), microphone=()Chrome 88+, Edge 88+, Opera 74+, Firefox nem támogatott, Safari nem támogatottAlacsonytól közepesig. Azok az oldalak vagy iframe-ek, amelyek burkoltan a felugró engedélykérésekre támaszkodtak, megtagadtatásokat fognak látni, amíg kifejezetten nem kapnak engedélytSzükség esetén útvonalanként állítsa

X-Content-Type-Options

Cél: a MIME sniffing megakadályozása. Ez megakadályozza, hogy a böngésző kitalálja a tartalomtípust, ami veszélyes lehet (például egy felhasználó által feltöltött szövegfájlt szkriptként futtathat, ha annak tűnik).

Érték

X-Content-Type-Options: nosniff

X-Content-Type-Options összehasonlítás

NévCélKritikus direktívákPéldaértékBöngészőtámogatásKompatibilitási kockázatEszközökkel kapcsolatos megjegyzések
X-Content-Type-OptionsMIME-kikényszerítési direktíva, amely letiltja a tartalomszimatolást a szkript- és stílusválaszoknál, és megköveteli a helyes Content-Type megadását a futtatáshoznosniffnosniffChrome 64+, Edge 12+, Firefox 50+, Safari 11+, Opera 51+, IE 8+Alacsony, feltéve, hogy minden erőforrás pontos MIME típussal kerül kiszolgálásra. A hibás típusú erőforrások blokkolva lesznekSzolgáljon ki helyes Content-Type-ot

COOP, COEP, CORP

Cél: az alkalmazás izolálása más eredetektől és a cross-site adatszivárgások blokkolása. Bizonyos fejlett funkciókhoz, például a SharedArrayBufferhez szükséges.

Clear-Site-Data: "cache", "cookies", "storage"  # Use on logout endpoints
Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Embedder-Policy: require-corp
Cross-Origin-Resource-Policy: same-origin

Megjegyzések

  • COEP: credentialless egyszerűsítheti a harmadik féltől származó erőforrások betöltését hitelesítési adatok nélkül. Először ellenőrizze a támogatást.
  • Bevezetés előtt végezzen auditot a beágyazásokon és a postMessage használatán.

Mikor használjon cross-origin izolációt

  • Szüksége van SharedArrayBufferre vagy olyan teljesítmény API-kra, amelyek izolációt igényelnek.
  • Erősebb védelmet szeretne a cross-site szivárgások és a felugró ablakok közti kommunikáció ellen.

Hibaelhárítás

  • A képek, betűkészletek vagy WASM betöltési hibáit általában a CORP hiánya okozza. Adja hozzá a Cross-Origin-Resource-Policy: same-origin fejlécet az erőforrásaira, vagy szolgálja ki azokat azonos eredetről.
  • Harmadik féltől származó widgetek nem biztos, hogy beágyazhatók COEP mellett. Hosztolja őket sajátként, vagy használja a credentialless módot, ha támogatott.

COOP, COEP, CORP összehasonlítás

NévCélKritikus direktívákPéldaértékBöngészőtámogatásKompatibilitási kockázatEszközökkel kapcsolatos megjegyzések
COOPBöngészési kontextuscsoport izoláció, amely az oldalt külön csoportba helyezi az eltérő eredetű dokumentumoktól, mérsékelve az ablakok közti adatszivárgásokat és bizonyos XS-Leakeketsame-originsame-originChrome 83+, Edge 83+, Firefox 79+, Safari 15.2+, Opera 69+Közepes. Az eltérő eredetű ablakreferenciák, az opener kapcsolatok és a postMessage folyamatok, amelyek azonos csoportra számítanak, megszakadhatnakAuditálja a postMessage használatot és a window.open hívásokat
COEPBeágyazási házirend, amely előírja, hogy az eltérő eredetű erőforrások kifejezetten engedélyezzék a beágyazást CORP vagy CORS útján, lehetővé téve a cross-origin izolációt és blokkolva az átlátszatlan no-cors beágyazásokatrequire-corp vagy credentiallessrequire-corpChrome 83+, Edge 83+, Opera 69+, Firefox nem támogatott, Safari nem támogatottKözepestől magasig. Azok a külső erőforrások, amelyek nem rendelkeznek CORP vagy CORS fejlécekkel, nem fognak betöltődni, beleértve a betűkészleteket, képeket és a WASM-etAdjon CORP-ot az erőforrásaira
CORPErőforrás-védelmi házirend, amely deklarálja, hogy mely eredetek ágyazhatnak be egy erőforrást no-cors kontextusokban, megakadályozva az illetéktelen cross-origin fogyasztástsame-origin, same-site, cross-originsame-originChrome 73+, Edge 79+, Firefox 74+, Safari nem támogatott, iOS Safari nem támogatottAlacsonytól közepesig. Azok a cross-site fogyasztók, amelyek nem rendelkeznek engedélyezett viszonnyal, nem fogják tudni betölteni a védett erőforrásokatÁllítsa be statikus erőforrásokra

Cross-Origin Resource Sharing (CORS)

Cél: meghatározott cross-origin kérések engedélyezése.

Biztonságos példa

# Preflight (OPTIONS)
Access-Control-Allow-Origin: https://example.com
Access-Control-Allow-Methods: GET, POST, OPTIONS
Access-Control-Allow-Headers: Content-Type
Access-Control-Allow-Credentials: true
Access-Control-Max-Age: 600
Vary: Origin, Access-Control-Request-Method, Access-Control-Request-Headers

# Simple/actual response
Access-Control-Allow-Origin: https://example.com
Access-Control-Allow-Credentials: true
Vary: Origin

Access-Control-Expose-Headers: Content-Length, X-Request-ID
Cross-Origin-Resource-Policy: same-origin

Előzetes kérés (preflight)

  • A böngészők OPTIONS kérést küldenek a házirend ellenőrzéséhez.
  • Cache-elje rövid Access-Control-Max-Age értékkel.

Hitelesített kérések szabályai

  • Ne használja a * karaktert hitelesítési adatokkal együtt. Tükrözze vissza az engedélyezett eredetet egy engedélyezési listáról.
  • Mindig állítsa be a Vary: Origin fejlécet, ha a válaszok eredettől függően különböznek.
  • Csak a szükséges metódusokat és fejléceket engedélyezze. Kerülje a széles Access-Control-Allow-Headers: * beállítást.

Előzetes kérések cache-elésének buktatói

  • Tartsa mérsékelt szinten az Access-Control-Max-Age értéket éles környezetben, például 600 másodpercen, hogy a házirend-változások gyorsan érvénybe lépjenek.
  • A CDN-ek cache-elhetik az OPTIONS kéréseket. Kerülje meg vagy korlátozza a cache-elést az előzetes kérések útvonalaira.

CORS összehasonlítás

NévCélKritikus direktívákPéldaértékBöngészőtámogatásKompatibilitási kockázatEszközökkel kapcsolatos megjegyzések
CORS fejlécekCross-origin kérésengedélyezési keretrendszer, amely meghatározza, hogy mely eredetek, metódusok és fejlécek férhetnek hozzá védett erőforrásokhoz a fetch/XHR csatornán keresztül, beleértve az előzetes egyeztetéstAccess-Control-Allow-Origin, Access-Control-Allow-Methods, Access-Control-Allow-Headers, Access-Control-Allow-Credentials, Access-Control-Max-AgeLásd a példátChrome 4+, Edge 12+, Firefox 3.5+, Safari 4+, Opera 12.1+, IE 10+Közepes. A hibás engedélyezési listák, a hiányzó Vary vagy a rosszul körülhatárolt engedélyezett fejlécek blokkolhatják a legitim klienseket, vagy gyorsítótárban maradt házirend-eltéréseket okozhatnakMindig állítsa be a Vary: Origin fejlécet

Fetch Metadata

Cél: a kérések kontextusának azonosítása és a cross-site visszaélések blokkolása. Használja a CSRF védelem megerősítésére.

Szerveroldali ellenőrzés ötlete

# Pseudocode: reject unsafe, non-navigational cross-site requests
site = get_header("Sec-Fetch-Site")
mode = get_header("Sec-Fetch-Mode")
is_unsafe_method = (method in [POST, PUT, PATCH, DELETE])
is_cross_site = (site == "cross-site")
is_navigational = (mode == "navigate")

# Block requests that are cross-site, unsafe, AND not a top-level navigation
if (is_cross_site && is_unsafe_method && !is_navigational) {
  reject()
}

Express middleware példa

function fetchMetadataGuard(req, res, next) {
  const site = req.get("Sec-Fetch-Site") || "";
  const mode = req.get("Sec-Fetch-Mode") || "";
  const dest = req.get("Sec-Fetch-Dest") || "";
  const unsafe = ["POST", "PUT", "PATCH", "DELETE"].includes(req.method);
  const allowedSameSite = site === "" || site === "same-origin" || site === "same-site";
  const isNavigation = mode === "navigate" && dest === "document";

  if (unsafe && !allowedSameSite && !isNavigation) return res.sendStatus(403);
  next();
}

Fetch Metadata összehasonlítás

NévCélKritikus direktívákPéldaértékBöngészőtámogatásKompatibilitási kockázatEszközökkel kapcsolatos megjegyzések
Fetch MetadataKérés-kontekstus validálás, amely a Sec-Fetch-* fejléceket vizsgálja az azonos eredetű, azonos site-os és különböző site-os kérések megkülönböztetésére, lehetővé téve a szerveroldali CSRF és XS-Leak keményítéstSec-Fetch-Site, Sec-Fetch-Mode, Sec-Fetch-Dest, Sec-Fetch-UserUtasa el az unsafe metódusokat, ha cross-siteChrome 76+, Edge 79+, Opera 63+, Firefox nem támogatott, Safari nem támogatottAlacsony, ha az unsafe metódusokra korlátozódik. A túl szigorú szabályok blokkolhatnak legitim cross-site navigációkat vagy OAuth átirányításokatNaplózza az elutasításokat a finomhangoláshoz

Subresource Integrity (SRI)

Cél: biztosítja, hogy a CDN erőforrásokat ne módosítsák.

Példa

<script src="https://cdn.example.com/app.js" integrity="sha384-BASE64HASH" crossorigin="anonymous"></script>

Megjegyzések

  • Rögzítse a verziókat, vagy frissítse a hasheket automatikusan.
  • Használja szkriptekhez és stílusokhoz.

Hashek előállítása és ellenőrzése

  • Generálás: openssl dgst -sha384 -binary app.js | openssl base64 -A
  • Ellenőrzés: mindig tesztelje az SRI-t staging környezetben élesítés előtt. Hibás hash = hibás oldal.
  • Automatizálás: használjon build eszközöket a hashek telepítés közbeni generálására.

SRI összehasonlítás

NévCélKritikus direktívákPéldaértékBöngészőtámogatásKompatibilitási kockázatEszközmegjegyzések
SRIAl-erőforrások integritásellenőrzése, amely a külső szkripteket és stílusokat kriptográfiai kivonatokhoz köti, megakadályozva a módosított CDN-elemek futtatásátintegrity, crossoriginLásd a példátChrome 45+, Edge 79+, Firefox 43+, Safari 11+, Opera 32+, iOS Safari 11.3+Közepes. Bármilyen upstream változás, amelyhez nem tartozik frissített hash, kemény hibát okozAutomatizálja a hash frissítéseket

Biztonságos sütik

Cél: munkamenetek védelme.

Biztonságos példa

Set-Cookie: session=abc...; Path=/; Secure; HttpOnly; SameSite=Lax

Megjegyzések

  • A modern böngészők hiányzó SameSite esetén Lax alapértelmezést használnak. Legyen explicit.
  • A SameSite=None; Secure beállítást csak harmadik fél sütijeihez használja.
  • A Path=/ értéket csak szükség esetén állítsa. A szűkebb útvonal csökkenti a kitettséget.
  • A Domain hatókörét a lehető legkevesebb hosztra korlátozza. Kerülje a szuper-domainekre kiterjedő sütiket nagy környezetben.
  • Forgassa a munkamenet-azonosítókat bejelentkezéskor és jogosultságváltáskor. Érvénytelenítse kijelentkezéskor.
  • Használjon rövid lejáratot a munkamenet-sütikhez. Részesítse előnyben a szerveroldali munkamenet-tárolókat visszavonási lehetőséggel.

Sütik összehasonlítás

NévCélKritikus direktívákPéldaértékBöngészőtámogatásKompatibilitási kockázatEszközökkel kapcsolatos megjegyzések
Set-CookieA munkamenet-bizalmasság és a CSRF elleni többrétegű védelem biztosítása a Secure szállítással, a szkriptből való elérhetetlenséggel (HttpOnly), valamint a cross-site szemantikákkal (SameSite)Secure, HttpOnly, SameSiteSecure; HttpOnly; SameSite=LaxHttpOnly és Secure minden modern böngészőben támogatott. SameSite=None: Chrome 67+, Edge 16+, Firefox 60+, Safari 13+, iOS Safari 13+Alacsonytól közepesig. Cross-site folyamatok, beágyazott SSO-k vagy régi külső integrációk meghiúsulhatnak, ha nem kapnak SameSite=None; Secure beállítást, ahol szükségesSzűkítés előtt auditálja a cross-site folyamatokat

Elavult vagy nem javasolt fejlécek

FejlécEltávolítva/Elavult stb. miótaOkHelyettesítés
HTTP Public-Key-Pins (HPKP)Eltávolítva, 2018-05-29, szolgáltatásmegtagadási kockázat és rosszindulatú pinningMagas önokozta kizárás kockázataCserélje a Public-Key-Pins fejlécet HSTS előbetöltésre és Certificate Transparency-re
X-XSS-ProtectionElavult, 2019-10, a böngészők elavulttá nyilvánították, XSS sebezhetőségeket okozhat és ütközik a CSP-velHatástalan és félrevezetőCserélje a X-XSS-Protection fejlécet Content-Security-Policy-ra beágyazott szkriptek nélkül
Expect-CTElavult, 2022-11, a CT-t a Chromium érvényesíti, a fejléc okafogyottA CT beépült az ökoszisztémábaA Expect-CT helyett támaszkodjon a Certificate Transparency-re, és távolítsa el a fejlécet
X-Frame-OptionsModern vezérléssel kiváltva, 2016-12-15, hivatkozás a CSP frame-ancestors átvételére, korlátozott direktívák és interoperabilitásKorlátozott szintaxis és vezérlésCserélje a X-Frame-Options fejlécet erre: Content-Security-Policy: frame-ancestors

Konfigurációs receptek

Nginx

# /etc/nginx/conf.d/security.conf
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
add_header Permissions-Policy "geolocation=(), camera=(), microphone=()" always;
add_header X-Content-Type-Options "nosniff" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Resource-Policy "same-origin" always;

location / {
  set_by_lua_block $csp_nonce {
    local rand = require("resty.random").bytes(16, true)
    return ngx.encode_base64(rand)
  }

  add_header Content-Security-Policy
    "default-src 'self'; base-uri 'self'; object-src 'none'; \
    script-src 'self' 'nonce-$csp_nonce'; style-src 'self'; img-src 'self' data:; \
    frame-ancestors 'self'; upgrade-insecure-requests" always;
}

# CORS example for API
location /api/ {
    if ($request_method = 'OPTIONS') {
        add_header Access-Control-Allow-Origin "https://example.com";
        add_header Access-Control-Allow-Methods "GET, POST, OPTIONS";
        add_header Access-Control-Allow-Headers "Content-Type";
        add_header Access-Control-Allow-Credentials "true";
        add_header Access-Control-Max-Age 600;
        return 204;
    }
    add_header Access-Control-Allow-Origin "https://example.com";
    add_header Access-Control-Allow-Credentials "true";
    add_header Vary "Origin";
    proxy_pass http://backend;
}

Apache httpd

# In <VirtualHost> or .htaccess with AllowOverride All
# e.g., SetEnvIfNoCase Request_URI ".*" CSP_NONCE=%{UNIQUE_ID}e
Header always set Content-Security-Policy "default-src 'self'; base-uri 'self'; object-src 'none'; script-src 'self' 'nonce-%{CSP_NONCE}e'; style-src 'self'; img-src 'self' data:; frame-ancestors 'self'; upgrade-insecure-requests"
Header always set Strict-Transport-Security "max-age=31536000; includeSubDomains"
Header always set Referrer-Policy "strict-origin-when-cross-origin"
Header always set Permissions-Policy "geolocation=(), camera=(), microphone=()"
Header always set X-Content-Type-Options "nosniff"
Header always set Cross-Origin-Opener-Policy "same-origin"
Header always set Cross-Origin-Embedder-Policy "require-corp"
Header always set Cross-Origin-Resource-Policy "same-origin"

# CORS example
<Location /api/>
  Header always set Access-Control-Allow-Origin "https://example.com"
  Header always set Access-Control-Allow-Credentials "true"
  Header always set Vary "Origin"
  RewriteEngine On
  RewriteCond %{REQUEST_METHOD} OPTIONS
  RewriteRule ^ - [R=204,L]
  Header always set Access-Control-Allow-Methods "GET, POST, OPTIONS"
  Header always set Access-Control-Allow-Headers "Content-Type"
  Header always set Access-Control-Max-Age "600"
</Location>

Node.js Express

import express from "express";
import crypto from "crypto";

const app = express();

// CSP nonce per response
app.use((req, res, next) => {
  res.locals.cspNonce = crypto.randomBytes(16).toString("base64");
  next();
});

app.use((req, res, next) => {
  const nonce = res.locals.cspNonce;
  res.setHeader("Content-Security-Policy",
    "default-src 'self'; base-uri 'self'; object-src 'none'; " +
    "script-src 'self' 'nonce-" + nonce + "'; style-src 'self'; img-src 'self' data:; " +
    "frame-ancestors 'self'; upgrade-insecure-requests");
  res.setHeader("Strict-Transport-Security", "max-age=31536000; includeSubDomains");
  res.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
  res.setHeader("Permissions-Policy", "geolocation=(), camera=(), microphone=()");
  res.setHeader("X-Content-Type-Options", "nosniff");
  res.setHeader("Cross-Origin-Opener-Policy", "same-origin");
  res.setHeader("Cross-Origin-Embedder-Policy", "require-corp");
  res.setHeader("Cross-Origin-Resource-Policy", "same-origin");
  next();
});

// Fetch Metadata guard
app.use((req, res, next) => {
  const site = req.get("Sec-Fetch-Site");
  const unsafe = ["POST","PUT","PATCH","DELETE"].includes(req.method);
  if (site === "cross-site" && unsafe) return res.status(403).end();
  next();
});

// CORS allowlist example
app.use("/api", (req, res, next) => {
  const origin = req.get("Origin");
  if (origin === "https://example.com") {
    res.setHeader("Access-Control-Allow-Origin", origin);
    res.setHeader("Access-Control-Allow-Credentials", "true");
    res.setHeader("Vary", "Origin");
  }
  if (req.method === "OPTIONS") {
    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
    res.setHeader("Access-Control-Max-Age", "600");
    return res.status(204).end();
  }
  next();
});

app.get("/", (req, res) => {
  res.send(`<script nonce="${res.locals.cspNonce}">console.log("ok")</script>`);
});

app.listen(3000);

Cloudflare Workers

export default {
  async fetch(req, env, ctx) {
    const headers = new Headers({
      "Content-Security-Policy":
        "default-src 'self'; base-uri 'self'; object-src 'none'; " +
        "script-src 'self'; style-src 'self'; img-src 'self' data:; " +
        "frame-ancestors 'self'; upgrade-insecure-requests",
      "Strict-Transport-Security": "max-age=31536000; includeSubDomains",
      "Referrer-Policy": "strict-origin-when-cross-origin",
      "Permissions-Policy": "geolocation=(), camera=(), microphone=()",
      "X-Content-Type-Options": "nosniff",
      "Cross-Origin-Opener-Policy": "same-origin",
      "Cross-Origin-Embedder-Policy": "require-corp",
      "Cross-Origin-Resource-Policy": "same-origin"
    });

    if (req.method === "OPTIONS") {
      headers.set("Access-Control-Allow-Origin", "https://example.com");
      headers.set("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
      headers.set("Access-Control-Allow-Headers", "Content-Type");
      headers.set("Access-Control-Allow-Credentials", "true");
      headers.set("Access-Control-Max-Age", "600");
      return new Response(null, { status: 204, headers });
    }

    headers.set("Access-Control-Allow-Origin", "https://example.com");
    headers.set("Access-Control-Allow-Credentials", "true");
    headers.append("Vary", "Origin");

    return new Response("OK", { headers });
  }
};

Megjegyzés a nonce-okról Edge Workerekben

Ez a példa az egyszerűség kedvéért statikus CSP-t használ. A nonce-ok megvalósítása (ajánlott) edge workerben, például Cloudflare-ben összetettebb. Ehhez a következőkre van szükség:

  • Véletlen nonce generálása, például a crypto.randomUUID() használatával.
  • Az eredeti válasz lekérése.
  • HTML-átalakító használata (például HTMLRewriter a Cloudflare-ben) a válasz streameléséhez, a nonce attribútum beillesztése a <script> és <style> tagekbe, majd
  • A Content-Security-Policy fejléc hozzáadása a végső válaszhoz, beleértve a generált 'nonce-...' értéket.

Ellenőrzés

# Show all response headers
curl -s -D - https://example.com/ -o /dev/null

# Check a single header
curl -s -D - https://example.com/ -o /dev/null | grep -i strict-transport-security

# Check CORS preflight
curl -s -D - -X OPTIONS https://api.example.com/endpoint \
  -H "Origin: https://example.com" \
  -H "Access-Control-Request-Method: POST" -o /dev/null

Biztonsági fejlécek ellenőrző szkript

#!/bin/bash
# Comprehensive security header check
URL="https://example.com"
echo "Testing security headers for $URL"

CRITICAL_HEADERS=(
  "Content-Security-Policy"
  "Strict-Transport-Security"
  "X-Content-Type-Options"
  "Referrer-Policy"
  "Permissions-Policy"
)

# Fail if any required header is missing
for h in "${CRITICAL_HEADERS[@]}"; do
  curl -s -D - https://example.com/ -o /dev/null | grep -iq "^$h:" || { echo "Missing $h"; exit 1; }
done

# Ensure CSP contains frame-ancestors
CSP_VALUE=$(curl -s -D - https://example.com/ -o /dev/null | awk 'BEGIN{IGNORECASE=1}/^Content-Security-Policy:/{print substr($0,index($0,$2))}')
echo "$CSP_VALUE" | grep -iq "frame-ancestors" || { echo "CSP missing frame-ancestors"; exit 1; }

# Test HSTS preload readiness
echo "HSTS Preload Check:"
curl -s "https://hstspreload.org/api/v2/status?domain=$(echo $URL | sed 's|https://||')" | jq .

Várt eredmények

  • A dokumentumkérés tartalmazza a CSP, HSTS, Referrer-Policy, COOP, COEP, CORP és X-Content-Type-Options fejléceket.
  • Az előzetes kérés a beállított CORS fejléceket mutatja.
  • A grep megtalálja a pontos fejlécet és értéket.

Böngésző DevTools

  • Nyissa meg a Network lapot, töltsön be egy oldalt, válassza ki a dokumentumkérést, majd vizsgálja meg a válaszfejléceket.
  • Tartsa nyitva a Konzolt, hogy a Report-Only módban rögzítse a CSP megsértéseket.
  • Ellenőrizze az Application panelen a sütiket és a jelzőiket.

Gyors lépések

  • Chrome: Network fül, majd válassza a dokumentumot, ezután Response Headers. Szűrés: csp, strict-transport, referrer-policy.
  • Nyissa meg a Konzolt és töltse újra az oldalt, hogy lássa a Content Security Policy megsértéseket Report-Only módban.
  • Firefox: Storage panel, majd Cookies. Ellenőrizze a Secure, HttpOnly és SameSite jelzőket.

Bevezetés és monitorozás

  • Eszközleltár és kiinduló állapot (1. hét)
    • Minden domain és aldomain feltérképezése
    • A jelenlegi fejlécállapot dokumentálása
    • Minden külső függőség azonosítása
  • CSP Report-Only (2–3. hét)
    • CSP bevezetése report-only módban
    • Szabálysértések monitorozása legalább 14 napig
    • Valós megsértések javítása a kódban
  • Alap fejlécek (4. hét)
    • `X-Content-Type-Options: nosniff` bevezetése
    • `Referrer-Policy: strict-origin-when-cross-origin` bevezetése
    • `Permissions-Policy` bevezetése biztonságos alapértékekkel
  • HSTS fokozatosan (5–8. hét)
    • Kezdje `max-age=300` értékkel nem kritikus aldomainen
    • Fokozatosan növelje `max-age=31536000` értékre
    • Az `includeSubDomains` csak akkor kerüljön be, ha minden aldomain ellenőrzött
  • CSP kényszerítése (9. hét+)
    • Váltás CSP enforce módra
    • A jelentésküldés maradjon bekapcsolva
    • Új megsértések monitorozása
  • Fejlett izoláció (opcionális)
    • COOP/COEP/CORP bevezetése csak szükség esetén
    • Cross-origin izolációs követelmények tesztelése

Gyakori hibák

  • Access-Control-Allow-Origin: * használata hitelesítési adatokkal. Ez érvénytelen és nem biztonságos. Használjon engedélyezési listát és Vary: Origin fejlécet.
  • Csak X-Frame-Options küldése. Használja a frame-ancestors direktívát a CSP-ben.
  • A X-Content-Type-Options: nosniff kihagyása.
  • Cookie jelzők be nem állítása. Használja a Secure; HttpOnly; SameSite beállításokat.
  • HSTS előbetöltés túl korán.
  • Harmadik fél widgetek működésének megszakítása COEP vagy CORP miatt. Végezzen auditot és adjon meg explicit engedélyeket.
  • A CSP csodafegyverként kezelése. Továbbra is szükség van kimenet-kódolásra és bemeneti validálásra.

További buktatók és gyors javítások

  • A CSP engedélyezi az 'unsafe-inline'-t. Javítás: használjon nonce-okat vagy hasheket, és távolítsa el az inline eseménykezelőket.
  • Hiányzó frame-ancestors a CSP-ben. Adja hozzá akkor is, ha X-Frame-Options-t is küld.
  • COEP require-corp bevezetve CORP nélkül a statikus erőforrásokon. Adja hozzá a Cross-Origin-Resource-Policy fejlécet a képekre, betűkészletekre és a WASM-re.
  • CORS Access-Control-Allow-Headers értéke *. Cserélje a ténylegesen használt fejlécek listájára.
  • SameSite=None sütik Secure nélkül. A None értéket mindig párosítsa a Secure-rel.

Kérdések

Részesítse előnyben a frame-ancestors direktívát. Egyes csapatok örökségi okokból mindkettőt küldik, de a modern vezérlés a CSP.

Csak a szükséges eredeteket engedélyezze. Használjon nonce-okat a saját beágyazott indítószkriptekhez. Kerülje a helyettesítő karaktereket.

Nem. Csak akkor használja, ha minden aldomain HTTPS-t használ és az is marad.

A strict-origin-when-cross-origin a legtöbb oldalhoz illik. Szigorúbb adatvédelemhez használja a no-referrer értéket.

Mindkettőt használja. A tokenek maradnak elsődlegesek. A Fetch Metadata gyors elutasítási utat ad.

Széles körben teszi hozzáférhetővé az adatokat. Soha ne kombinálja hitelesítési adatokkal. Használjon engedélyezési listákat.

Csak akkor, ha cross-origin izolációra vagy erősebb cross-site szivárgás elleni védelemre van szüksége. Először tesztelje a beágyazásokat.

Nem. Elavult.

A legtöbb böngésző SameSite nélkül Lax-ként kezeli a sütiket. Állítsa be az attribútumokat egyértelműen.

Használjon curl-t OPTIONS-szal, küldje az Origin és az Access-Control-Request-Method fejléceket.

Igen. Rögzítse a verziókat és használjon SRI-t. Ez lefedi a CDN-en történt manipulációkat.

Igen. Az edge jó hely. Tartson alkalmazásszintű felülírásokat azokhoz az útvonalakhoz, amelyek eltérő házirendet igényelnek.

Összegzés

A HTTP fejlécek gyors, mérhető eredményt adnak alacsony kockázattal. Először szállítsa a biztonságos alapértékeket, majd szigorítson, ahogy megismeri az alkalmazás viselkedését. Tartsa a házirendeket kódban, tesztelje őket CI környezetben, és vizsgálja felül ütemezetten.

Erőforrások

Vágjunk bele közösen, és valósítsuk meg elképzeléseit – együtt!

Kérek egy ingyenes árajánlatot

Kapcsolódó cikkek

Olvassa el a(z) "JavaScriptben való szövegformázás mesterfokon a sprintf segítségével" cikket

JavaScriptben való szövegformázás mesterfokon a sprintf segítségével

A szövegformázás a programozás alapvető aspektusa, amely lehetővé teszi a fejlesztők számára, hogy dinamikus és olvasható szöveges kimenetet hozzanak létre változók beágyazásával és specifikus formázási szabályok alkalmazásával. További információ az JavaScriptben való szövegformázás mesterfokon a sprintf segítségével

Olvassa el a(z) "Google Consent Mode V2 Minden, amit érdemes tudnod róla!" cikket

Google Consent Mode V2 Minden, amit érdemes tudnod róla!

Az olyan adatvédelmi szabályozások, mint az Általános Adatvédelmi Rendelet (GDPR) és a Kaliforniai Fogyasztói Adatvédelmi Törvény (CCPA), alapvetően megváltoztatták a vállalatok megközelítését a felhasználói adatok kezelésében. További információ az Google Consent Mode V2 Minden, amit érdemes tudnod róla!

Olvassa el a(z) "Átfogó útmutató az erős és felismerhető márka felépítéséhez" cikket

Átfogó útmutató az erős és felismerhető márka felépítéséhez

A márkakonzisztencia minden sikeres vállalkozás számára alapvető fontosságú elem. Nem csupán egy felismerhető logo vagy fülbemászó szlogen létrehozásáról szól-a márkakonzisztencia arról szól, hogy minden egyes ügyfélkapcsolat a vállalat alapértékeivel és vizuális identitásával összhangban legyen. További információ az Átfogó útmutató az erős és felismerhető márka felépítéséhez