Tinklalapio saugumo antraščių diegimas: „JavaScript“ turinio saugumo politika (CSP)

Šiuolaikiniame skaitmeniniame pasaulyje tinklalapių saugumas yra svarbiausias dalykas. Svetainės ir jos naudotojų apsauga nuo kenkėjiškų atakų nebėra pasirinkimas, o būtinybė. Kryžminis scenarijų kūrimas (XSS) išlieka paplitusia grėsme, o viena veiksmingiausių apsaugos priemonių yra griežtos turinio saugumo politikos (CSP) įdiegimas. Šiame vadove daugiausia dėmesio skiriama „JavaScript“ naudojimui CSP valdymui ir diegimui, suteikiant dinamišką ir lankstų požiūrį į jūsų žiniatinklio programų saugumą visame pasaulyje.

Kas yra turinio saugumo politika (CSP)?

Turinio saugumo politika (CSP) yra HTTP atsakymo antraštė, leidžianti kontroliuoti, kokius išteklius naudotojo agentui (naršyklei) leidžiama įkelti konkrečiame puslapyje. Iš esmės tai veikia kaip baltasis sąrašas, apibrėžiantis šaltinius, iš kurių galima įkelti scenarijus, stilių lenteles, paveikslėlius, šriftus ir kitus išteklius. Aiškiai apibrėždami šiuos šaltinius, galite žymiai sumažinti savo svetainės atakos plotą, todėl užpuolikams tampa daug sunkiau įterpti kenkėjišką kodą ir vykdyti XSS atakas. Tai svarbus gynybinės strategijos sluoksnis.

Kodėl CSP diegimui naudoti „JavaScript“?

Nors CSP galima konfigūruoti tiesiogiai jūsų žiniatinklio serverio konfigūracijoje (pvz., „Apache“ .htaccess arba „Nginx“ konfigūracijos faile), „JavaScript“ naudojimas suteikia keletą pranašumų, ypač sudėtingose ar dinamiškose programose:

• Dinaminis politikos generavimas: „JavaScript“ leidžia dinamiškai generuoti CSP politikas, atsižvelgiant į naudotojų vaidmenis, programos būseną ar kitas vykdymo laiko sąlygas. Tai ypač naudinga vieno puslapio programose (SPA) arba programose, kurios labai priklauso nuo kliento pusės atvaizdavimo.
• „Nonce“ pagrįsta CSP: „Nonce“ (kriptografiškai atsitiktinių, vienkartinių žetonų) naudojimas yra labai veiksmingas būdas apsaugoti įterptuosius scenarijus ir stilius. „JavaScript“ gali generuoti šiuos „nonce“ ir pridėti juos tiek prie CSP antraštės, tiek prie įterptųjų scenarijų/stilių žymų.
• Maišos pagrįsta CSP: Statiniams įterptiesiems scenarijams ar stiliams galite naudoti maišos funkcijas (hashes), kad į baltąjį sąrašą įtrauktumėte konkrečius kodo fragmentus. „JavaScript“ gali apskaičiuoti šias maišas ir įtraukti jas į CSP antraštę.
• Lankstumas ir kontrolė: „JavaScript“ suteikia jums smulkiagrūdę CSP antraštės kontrolę, leidžiančią ją keisti realiuoju laiku, atsižvelgiant į konkrečius programos poreikius.
• Derinimas ir ataskaitų teikimas: „JavaScript“ galima naudoti CSP pažeidimų ataskaitoms rinkti ir siųsti į centrinį registravimo serverį analizei, padedant jums nustatyti ir ištaisyti saugumo problemas.

„JavaScript“ CSP nustatymas

Bendras požiūris apima CSP antraštės eilutės generavimą naudojant „JavaScript“ ir tada atitinkamos HTTP atsakymo antraštės nustatymą serverio pusėje (paprastai per jūsų serverio karkasą). Pažvelgsime į konkrečius pavyzdžius skirtingiems scenarijams.

1. „Nonce“ generavimas

„Nonce“ (vieną kartą naudojamas skaičius) yra atsitiktinai sugeneruota, unikali reikšmė, naudojama konkretiems įterptiesiems scenarijams ar stiliams įtraukti į baltąjį sąrašą. Štai kaip galite sugeneruoti „nonce“ naudojant „JavaScript“:

            function generateNonce() {
  const crypto = window.crypto || window.msCrypto; // For IE support
  if (!crypto || !crypto.getRandomValues) {
    // Fallback for older browsers without crypto API
    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
  }
  const arr = new Uint32Array(1);
  crypto.getRandomValues(arr);
  return btoa(String.fromCharCode.apply(null, new Uint8Array(arr.buffer)));
}

const nonce = generateNonce();
console.log("Generated Nonce:", nonce);

            

              
                Copy
              
            
          

Šis kodo fragmentas generuoja kriptografiškai saugų „nonce“ naudojant naršyklės integruotą crypto API (jei yra) ir, jei API nepalaikoma, naudoja mažiau saugų atsarginį metodą. Sugeneruotas „nonce“ tada yra koduojamas base64 formatu, kad būtų galima naudoti CSP antraštėje.

2. „Nonce“ įterpimas į įterptuosius scenarijus

Kai turite „nonce“, jį reikia įterpti tiek į CSP antraštę, tiek į <script> žymą:

HTML:

            <script nonce="YOUR_NONCE_HERE">
  // Your inline script code here
  console.log("Hello from inline script!");
</script>
            

              
                Copy
              
            
          

„JavaScript“ (serverio pusė):

            const nonce = generateNonce();
const cspHeader = `default-src 'self'; script-src 'self' 'nonce-${nonce}' 'strict-dynamic' 'unsafe-inline'; object-src 'none'; base-uri 'self'; upgrade-insecure-requests;`;

// Example using Node.js with Express:
app.use((req, res, next) => {
  res.setHeader('Content-Security-Policy', cspHeader);
  // Pass the nonce to the view or template engine
  res.locals.nonce = nonce;
  next();
});

            

              
                Copy
              
            
          

Svarbios pastabos:

• Pakeiskite YOUR_NONCE_HERE HTML kode faktiniu sugeneruotu „nonce“. Tai dažnai daroma serverio pusėje naudojant šablonų variklį. Aukščiau pateiktas pavyzdys iliustruoja, kaip „nonce“ perduodamas šablonų varikliui.
• Direktyva script-src CSP antraštėje dabar apima 'nonce-${nonce}', leidžiančią vykdyti scenarijus su atitinkamu „nonce“.
• Prie `script-src` direktyvos pridedama 'strict-dynamic'. Ši direktyva nurodo naršyklei pasitikėti scenarijais, kuriuos įkelia patikimi scenarijai. Jei scenarijaus žyma turi galiojantį „nonce“, tuomet bet koks scenarijus, kurį jis dinamiškai įkelia (pvz., naudojant `document.createElement('script')`), taip pat bus laikomas patikimu. Tai sumažina poreikį į baltąjį sąrašą įtraukti daugybę atskirų domenų ir CDN URL adresų ir labai supaprastina CSP priežiūrą.
• Naudojant „nonce“, 'unsafe-inline' paprastai nerekomenduojama, nes tai silpnina CSP. Tačiau čia ji įtraukta demonstraciniais tikslais ir turėtų būti pašalinta gamybinėje aplinkoje. Pašalinkite tai kuo greičiau.

3. Maišos generavimas įterptiesiems scenarijams

Statiniams įterptiesiems scenarijams, kurie retai keičiasi, galite naudoti maišas vietoj „nonce“. Maiša (hash) yra kriptografinis scenarijaus turinio santrauka. Jei scenarijaus turinys pasikeis, pasikeis ir maiša, ir naršyklė užblokuos scenarijų.

Maišos apskaičiavimas:

Galite naudoti internetinius įrankius arba komandinės eilutės įrankius, pvz., OpenSSL, kad sugeneruotumėte savo įterptojo scenarijaus SHA256 maišą. Pavyzdžiui:

            openssl dgst -sha256 -binary your_script.js | openssl base64
            

              
                Copy
              
            
          

Pavyzdys:

Tarkime, jūsų įterptasis scenarijus yra:

            <script>
  console.log("Hello from inline script!");
</script>
            

              
                Copy
              
            
          

Šio scenarijaus (be <script> žymų) SHA256 maiša gali būti:

            sha256-YOUR_HASH_HERE
            

              
                Copy
              
            
          

CSP antraštė:

            const cspHeader = `default-src 'self'; script-src 'self' 'sha256-YOUR_HASH_HERE'; object-src 'none'; base-uri 'self'; upgrade-insecure-requests;`;
            

              
                Copy
              
            
          

Pakeiskite YOUR_HASH_HERE faktine savo scenarijaus turinio SHA256 maiša.

Svarbūs aspektai naudojant maišas:

• Maiša turi būti apskaičiuota pagal tikslų scenarijaus turinį, įskaitant tarpus. Bet kokie scenarijaus pakeitimai, net vienas simbolis, padarys maišą negaliojančią.
• Maišos geriausiai tinka statiniams scenarijams, kurie retai keičiasi. Dinamiškiems scenarijams geresnis pasirinkimas yra „nonce“.

4. CSP antraštės nustatymas serveryje

Paskutinis žingsnis yra nustatyti Content-Security-Policy HTTP atsakymo antraštę jūsų serveryje. Tikslus metodas priklauso nuo jūsų serverio pusės technologijos.

Node.js su Express:

            app.use((req, res, next) => {
  const nonce = generateNonce();
  const cspHeader = `default-src 'self'; script-src 'self' 'nonce-${nonce}' 'strict-dynamic' 'unsafe-inline'; object-src 'none'; base-uri 'self'; upgrade-insecure-requests;`;
  res.setHeader('Content-Security-Policy', cspHeader);
  res.locals.nonce = nonce; // Make nonce available to templates
  next();
});
            

              
                Copy
              
            
          

Python su Flask:

            from flask import Flask, make_response, render_template, g
import os
import base64

app = Flask(__name__)

def generate_nonce():
    return base64.b64encode(os.urandom(16)).decode('utf-8')

@app.before_request
def before_request():
    g.nonce = generate_nonce()

@app.after_request
def after_request(response):
    csp = "default-src 'self'; script-src 'self' 'nonce-{nonce}' 'strict-dynamic' 'unsafe-inline'; object-src 'none'; base-uri 'self'; upgrade-insecure-requests".format(nonce=g.nonce)
    response.headers['Content-Security-Policy'] = csp
    return response

@app.route('/')
def index():
    return render_template('index.html', nonce=g.nonce)

            

              
                Copy
              
            
          

PHP:

            <?php
function generateNonce() {
  return base64_encode(random_bytes(16));
}

$nonce = generateNonce();
header("Content-Security-Policy: default-src 'self'; script-src 'self' 'nonce-" . $nonce . "' 'strict-dynamic' 'unsafe-inline'; object-src 'none'; base-uri 'self'; upgrade-insecure-requests");
?>
<!DOCTYPE html>
<html>
<head>
  <title>CSP Example</title>
</head>
<body>
  <script nonce="<?php echo htmlspecialchars($nonce, ENT_QUOTES, 'UTF-8'); ?>">
    console.log("Hello from inline script!");
  </script>
</body>
</html>
            

              
                Copy
              
            
          

Apache (.htaccess):

Nors dinamiškam CSP tai nerekomenduojama, *galite* nustatyti statinį CSP naudodami .htaccess:

            <IfModule mod_headers.c>
  Header always set Content-Security-Policy "default-src 'self'; script-src 'self'; object-src 'none'; base-uri 'self'; upgrade-insecure-requests;"
</IfModule>
            

              
                Copy
              
            
          

Nginx:

            add_header Content-Security-Policy "default-src 'self'; script-src 'self'; object-src 'none'; base-uri 'self'; upgrade-insecure-requests;";
            

              
                Copy
              
            
          

Svarbios pastabos:

• Pakeiskite 'self' faktiniais domenais, iš kurių norite leisti įkelti išteklius.
• Būkite ypač atsargūs naudodami 'unsafe-inline' ir 'unsafe-eval'. Šios direktyvos žymiai silpnina CSP ir jų reikėtų vengti, kai tik įmanoma.
• Naudokite upgrade-insecure-requests, kad automatiškai atnaujintumėte visas HTTP užklausas į HTTPS.
• Apsvarstykite galimybę naudoti report-uri arba report-to, kad nurodytumėte galinį punktą CSP pažeidimų ataskaitoms gauti.

CSP direktyvų paaiškinimas

CSP naudoja direktyvas, kad nurodytų leidžiamus šaltinius skirtingų tipų ištekliams. Štai trumpa kai kurių dažniausiai naudojamų direktyvų apžvalga:

• default-src: Nurodo numatytąjį šaltinį visiems ištekliams, kurių aiškiai neapima kitos direktyvos.
• script-src: Nurodo leidžiamus „JavaScript“ šaltinius.
• style-src: Nurodo leidžiamus stilių lentelių šaltinius.
• img-src: Nurodo leidžiamus paveikslėlių šaltinius.
• font-src: Nurodo leidžiamus šriftų šaltinius.
• media-src: Nurodo leidžiamus garso ir vaizdo įrašų šaltinius.
• object-src: Nurodo leidžiamus papildinių (pvz., Flash) šaltinius. Paprastai turėtumėte nustatyti tai į 'none', kad išjungtumėte papildinius.
• frame-src: Nurodo leidžiamus rėmelių ir iframe šaltinius.
• connect-src: Nurodo leidžiamus XMLHttpRequest, WebSocket ir EventSource jungčių šaltinius.
• base-uri: Nurodo leidžiamus pagrindinius URI dokumentui.
• form-action: Nurodo leidžiamus galinius punktus formų pateikimui.
• upgrade-insecure-requests: Nurodo naudotojo agentui elgtis su visais svetainės nesaugiais URL adresais (pateiktais per HTTP) taip, tarsi jie būtų pakeisti saugiais URL adresais (pateiktais per HTTPS). Ši direktyva skirta svetainėms, kurios visiškai perėjo prie HTTPS.
• report-uri: Nurodo URI, į kurį naršyklė turėtų siųsti CSP pažeidimų ataskaitas. Ši direktyva yra pasenusi, pirmenybė teikiama `report-to`.
• report-to: Nurodo pavadintą galinį punktą, į kurį naršyklė turėtų siųsti CSP pažeidimų ataskaitas.

CSP šaltinių sąrašo raktiniai žodžiai

Kiekviena direktyva naudoja šaltinių sąrašą, kad nurodytų leidžiamus šaltinius. Šaltinių sąraše gali būti šie raktiniai žodžiai:

• 'self': Leidžia išteklius iš to paties šaltinio (schemos, pagrindinio kompiuterio ir prievado).
• 'none': Draudžia išteklius iš bet kurio šaltinio.
• 'unsafe-inline': Leidžia įterptuosius scenarijus ir stilius. Venkite to, kai tik įmanoma.
• 'unsafe-eval': Leidžia naudoti eval() ir susijusias funkcijas. Venkite to, kai tik įmanoma.
• 'strict-dynamic': Nurodo, kad pasitikėjimas, kurį naršyklė suteikia scenarijui puslapyje dėl pridedamo „nonce“ ar maišos, būtų perduotas scenarijams, kuriuos įkelia tas scenarijus.
• 'data:': Leidžia išteklius, įkeltus per data: schemą (pvz., įterptuosius paveikslėlius). Naudokite atsargiai.
• 'mediastream:': Leidžia išteklius, įkeltus per mediastream: schemą.
• https:: Leidžia išteklius, įkeltus per HTTPS.
• http:: Leidžia išteklius, įkeltus per HTTP. Paprastai nerekomenduojama.
• *: Leidžia išteklius iš bet kurio šaltinio. Venkite to; tai paneigia CSP tikslą.

CSP pažeidimų ataskaitų teikimas

CSP pažeidimų ataskaitų teikimas yra labai svarbus jūsų CSP stebėjimui ir derinimui. Kai išteklius pažeidžia CSP, naršyklė gali nusiųsti ataskaitą į nurodytą URI.

Ataskaitų galinio punkto nustatymas:

Jums reikės serverio pusės galinio punkto, kad galėtumėte gauti ir apdoroti CSP pažeidimų ataskaitas. Ataskaita siunčiama kaip JSON duomenys.

Pavyzdys (Node.js su Express):

            app.post('/csp-report', (req, res) => {
  console.log('CSP Violation Report:', req.body);
  // Process the report (e.g., log to a file or database)
  res.status(204).end(); // Respond with a 204 No Content status
});
            

              
                Copy
              
            
          

Direktyvos report-uri arba report-to konfigūravimas:

Pridėkite report-uri arba `report-to` direktyvą prie savo CSP antraštės. `report-uri` yra pasenusi, todėl pirmenybę teikite `report-to`.

            const cspHeader = `default-src 'self'; script-src 'self' 'nonce-${nonce}' 'strict-dynamic'; object-src 'none'; base-uri 'self'; upgrade-insecure-requests; report-to csp-endpoint;`;
            

              
                Copy
              
            
          

Taip pat turite sukonfigūruoti „Reporting API“ galinį punktą, naudodami `Report-To` antraštę.

            Report-To: { "group": "csp-endpoint", "max_age": 10886400, "endpoints": [{"url": "/csp-report"}], "include_subdomains": true }
            

              
                Copy
              
            
          

Pastaba:

• `Report-To` antraštė turi būti nustatyta kiekvienoje užklausoje jūsų serveriui, kitaip naršyklė gali atmesti konfigūraciją.
• `report-uri` yra mažiau saugus nei `report-to`, nes neleidžia TLS šifruoti ataskaitos, be to, ji yra pasenusi, todėl pirmenybę teikite `report-to`.

CSP pažeidimo ataskaitos pavyzdys (JSON):

            {
  "csp-report": {
    "document-uri": "https://example.com/page.html",
    "referrer": "",
    "violated-directive": "script-src 'self' 'nonce-YOUR_NONCE_HERE'",
    "effective-directive": "script-src",
    "original-policy": "default-src 'self'; script-src 'self' 'nonce-YOUR_NONCE_HERE'; object-src 'none'; base-uri 'self'; upgrade-insecure-requests; report-uri /csp-report;",
    "blocked-uri": "https://evil.com/malicious.js",
    "status-code": 200,
    "script-sample": ""
  }
}
            

              
                Copy
              
            
          

Analizuodami šias ataskaitas, galite nustatyti ir ištaisyti CSP pažeidimus, užtikrindami, kad jūsų svetainė išliktų saugi.

Geriausios CSP diegimo praktikos

• Pradėkite nuo griežtos politikos: Pradėkite nuo politikos, kuri leidžia išteklius tik iš jūsų pačių šaltinio, ir palaipsniui ją švelninkite pagal poreikį.
• Naudokite „nonce“ arba maišas įterptiesiems scenarijams ir stiliams: Venkite naudoti 'unsafe-inline', kai tik įmanoma.
• Naudokite 'strict-dynamic', kad supaprastintumėte CSP priežiūrą.
• Venkite naudoti 'unsafe-eval': Jei reikia naudoti eval(), apsvarstykite alternatyvius metodus.
• Naudokite upgrade-insecure-requests: Automatiškai atnaujinkite visas HTTP užklausas į HTTPS.
• Įdiekite CSP pažeidimų ataskaitų teikimą: Stebėkite savo CSP pažeidimus ir greitai juos ištaisykite.
• Kruopščiai išbandykite savo CSP: Naudokite naršyklės kūrėjų įrankius, kad nustatytumėte ir išspręstumėte bet kokias CSP problemas.
• Naudokite CSP validatorių: Internetiniai įrankiai gali padėti jums patikrinti CSP antraštės sintaksę ir nustatyti galimas problemas.
• Apsvarstykite galimybę naudoti CSP karkasą ar biblioteką: Keletas karkasų ir bibliotekų gali padėti jums supaprastinti CSP diegimą ir valdymą.
• Reguliariai peržiūrėkite savo CSP: Jūsų programai tobulėjant, gali prireikti atnaujinti jūsų CSP.
• Švieskite savo komandą: Įsitikinkite, kad jūsų kūrėjai supranta CSP ir jo svarbą.
• Diekite CSP etapais: Pradėkite diegti CSP tik ataskaitų režimu (report-only), kad stebėtumėte pažeidimus neblokuodami išteklių. Kai būsite tikri, kad jūsų politika yra teisinga, galite ją įjungti priverstinio vykdymo režimu.
• Dokumentuokite savo CSP: Saugokite savo CSP politikos ir kiekvienos direktyvos pagrindimo įrašus.
• Atsižvelkite į naršyklių suderinamumą: CSP palaikymas skiriasi įvairiose naršyklėse. Išbandykite savo CSP skirtingose naršyklėse, kad įsitikintumėte, jog ji veikia kaip tikėtasi.
• Teikite pirmenybę saugumui: CSP yra galingas įrankis žiniatinklio saugumui gerinti, tačiau tai nėra stebuklinga kulka. Naudokite jį kartu su kitomis saugumo gerosiomis praktikomis, kad apsaugotumėte savo svetainę nuo atakų.
• Apsvarstykite galimybę naudoti žiniatinklio programų užkardą (WAF): WAF gali padėti jums įgyvendinti CSP politikas ir apsaugoti jūsų svetainę nuo kitų tipų atakų.

Dažniausi CSP diegimo iššūkiai

• Trečiųjų šalių scenarijai: Nustatyti ir įtraukti į baltąjį sąrašą visus domenus, reikalingus trečiųjų šalių scenarijams, gali būti sudėtinga. Kur įmanoma, naudokite `strict-dynamic`.
• Įterptieji stiliai ir įvykių tvarkytuvai: Įterptųjų stilių ir įvykių tvarkytuvų konvertavimas į išorines stilių lenteles ir „JavaScript“ failus gali užtrukti.
• Naršyklių suderinamumo problemos: CSP palaikymas skiriasi įvairiose naršyklėse. Išbandykite savo CSP skirtingose naršyklėse, kad įsitikintumėte, jog ji veikia kaip tikėtasi.
• Priežiūros našta: Išlaikyti savo CSP atnaujintą, kai jūsų programa tobulėja, gali būti iššūkis.
• Poveikis našumui: CSP gali šiek tiek sumažinti našumą dėl poreikio tikrinti išteklius pagal politiką.

Globalūs CSP aspektai

Diegiant CSP pasaulinei auditorijai, atsižvelkite į šiuos dalykus:

• CDN teikėjai: Jei naudojate CDN, įsitikinkite, kad įtraukėte į baltąjį sąrašą atitinkamus CDN domenus. Daugelis CDN siūlo regioninius galinius punktus; jų naudojimas gali pagerinti našumą vartotojams skirtingose geografinėse vietovėse.
• Kalbai būdingi ištekliai: Jei jūsų svetainė palaiko kelias kalbas, įsitikinkite, kad įtraukėte į baltąjį sąrašą reikalingus išteklius kiekvienai kalbai.
• Regioniniai reglamentai: Būkite informuoti apie bet kokius regioninius reglamentus, kurie gali turėti įtakos jūsų CSP reikalavimams.
• Prieinamumas: Įsitikinkite, kad jūsų CSP netyčia neužblokuoja išteklių, reikalingų prieinamumo funkcijoms.
• Testavimas įvairiuose regionuose: Išbandykite savo CSP skirtinguose geografiniuose regionuose, kad įsitikintumėte, jog ji veikia kaip tikėtasi visiems vartotojams.

Išvada

Tvirtos turinio saugumo politikos (CSP) įdiegimas yra esminis žingsnis siekiant apsaugoti jūsų žiniatinklio programas nuo XSS atakų ir kitų grėsmių. Naudodami „JavaScript“ dinamiškai generuoti ir valdyti savo CSP, galite pasiekti didesnį lankstumą ir kontrolę, užtikrindami, kad jūsų svetainė išliktų saugi ir apsaugota šiandieniniame nuolat besikeičiančiame grėsmių pasaulyje. Nepamirškite laikytis geriausių praktikų, kruopščiai išbandyti savo CSP ir nuolat stebėti pažeidimus. Saugus programavimas, gynybinė strategija ir gerai įdiegta CSP yra raktas į saugų naršymą pasaulinei auditorijai.