Biznes mantiq zaifliklari: kupon, limit va workflow'ni aylanib o'tish
Qisqacha: Biznes mantiq zaifligi — kod "to'g'ri" ishlaydi, lekin qoidaning o'zini aylanib o'tish mumkin: kuponni ikki marta ishlatish, narxni o'zgartirish, to'lovsiz "yetkazildi" holatiga o'tish. Bunday xatoni skaner topmaydi, chunki u sintaksisda emas, qoidada. Bu darsda
vazifalardagi "ko'pi bilan 5 ta webhook" limitini 20 ta parallel so'rov bilan sinaymiz: bazada 12 ta obuna paydo bo'ldi. Sabab — "sanash → qaror → yozish" orasidagi poyga holati. Tuzatish — foydalanuvchi bo'yicha tranzaksiya qulfi, natija 5. Regressiya testida esa bizning xatoimiz bor: birinchi test eski kodda ham yashil o'tdi.
Bu darsda
- Biznes mantiq zaifliklarining asosiy turlarini aniq misollar bilan ajratasiz.
- TOCTOU poyga holatini modelda va haqiqiy serverda ko'rasiz.
- Limitni
pg_advisory_xact_lockbilan himoyalaysiz va boshqa yo'llarning narxini solishtirasiz. - Poyga uchun regressiya testi haqiqatan parallel ishlayotganini tekshirasiz.
- Holat o'tishlarini (workflow) server tomonda qat'iy jadval bilan cheklaysiz.
Oldin bilishingiz kerak: Amaliyot: race condition'larni hal qilish, Qulflar: row, table va advisory, Read phenomena va izolyatsiya darajalari, Idempotency-Key, Threat modeling va xavfsiz dizayn.
1. Nega bu kerak?
Oldingi darslardagi zaifliklarning umumiy belgisi bor edi: noto'g'ri ma'lumot noto'g'ri joyga yetib bordi. SQL injection'da — satr so'rovga, open redirect'da — manzil brauzerga. Ularni naqsh bilan qidirish mumkin, skanerlar shunday ishlaydi.
Biznes mantiq zaifligida esa hamma so'rov to'g'ri shaklda. Parametrlar sxemadan o'tadi, SQL parametrlangan, foydalanuvchi o'z hisobida. Faqat natija noto'g'ri: chegirma ikki marta qo'llandi, limit oshdi, buyurtma to'lovsiz yetkazildi. Skaner "kupon bir marta ishlatiladi" degan qoidani bilmaydi. Uni faqat qoidani biladigan odam — siz — tekshira oladi.
Tahdid modelida bu T08: "limitni parallel so'rovlar bilan aylanib o'tish (poyga), bekor qilingan holatni qayta ochish". Mavjud nazorat sifatida "tranzaksiya, FOR UPDATE" yozilgan edi. Bugun bu yozuv to'g'ri ekanini har joyda tekshiramiz.
Hayotiy o'xshatish: kinoteatr. Ikki kassir bitta jadvalga qaraydi: 7-qator 5-joy bo'sh. Ikkalasi ham bir vaqtda o'sha joyni sotadi. Jadval to'g'ri edi — qarash va sotish orasida u eskirdi.
2. Biznes mantiq zaifliklari: turlari
| Tur | Misol | To'g'ri yo'l |
|---|---|---|
| Narxni mijozdan olish | Tanada narx: 1 yuboriladi va server uni qabul qiladi |
Narx serverda, mahsulot id'si bo'yicha hisoblanadi |
| Manfiy yoki chegaradan tashqari son | miqdor: -3 — summa kamayadi, chegirma: 120 foiz |
Sxema: int().min(1), foiz 0–100 |
| Kupon va bir martalik amal | Bir kuponni ikki parallel so'rov bilan ikki marta ishlatish | Unique cheklov yoki atomik yangilash |
| Limit (kvota) | "Ko'pi bilan 5 ta" — 20 parallel so'rov bilan 12 ta | Qulf yoki atomik shartli yozuv |
| Holat o'tishlari (workflow) | yaratildi → yetkazildi, to'lov qadami tashlab ketildi |
Ruxsat etilgan o'tishlar jadvali, serverda |
| Qayta yuborish | Bir to'lov xabari ikki marta — ikki marta hisob | Idempotentlik kaliti (Idempotency-Key) |
Birinchi ikki qator — ishonch xatosi: mijoz yuborgan qiymatga ishonildi. Ular sxema va "server o'zi hisoblaydi" qoidasi bilan yopiladi (Backend'dagi injection va mass assignment). Uchinchi va to'rtinchisi — vaqt xatosi: tekshiruv to'g'ri, lekin u paytda qabul qilingan qaror yozuv paytida eskirgan. Bugungi asosiy mavzu shu.
3. TOCTOU: tekshiruv va foydalanish orasida
3.1 Naqsh
TOCTOU (time of check to time of use — "tekshirish vaqti va ishlatish vaqti") — poyga holatining (race condition) eng ko'p uchraydigan shakli. Kod uch qadamdan iborat:
- sana: "foydalanuvchida nechta obuna bor?";
- qaror qil: "5 dan kam — davom et";
- yoz: yangi obuna qo'sh.
Bitta so'rov uchun bu to'g'ri. Ikki so'rov bir vaqtda kelsa-chi?
sequenceDiagram
participant A as So'rov A
participant DB as Postgres
participant B as So'rov B
A->>DB: count, natija 4
B->>DB: count, natija 4
A->>DB: INSERT, endi 5
B->>DB: INSERT, endi 6
Note over A,B: ikkalasi ham 4 ni ko'rdi va limitdan o'tdiIkkala so'rov ham "4" ni ko'rdi, ikkalasi ham "5 dan kam" deb qaror qildi. Natija — 6 ta. Postgres'ning sukut izolyatsiyasi READ COMMITTED: har so'rov faqat tasdiqlangan (commit qilingan) qatorlarni ko'radi. B ning count i A ning hali tasdiqlanmagan INSERT ini ko'rmaydi (Read phenomena va izolyatsiya darajalari). Tranzaksiyaning o'zi bu muammoni hal qilmaydi.
3.2 Model
Xuddi shu naqsh JS modelida. kut() — tarmoq va baza kechikishi: sanash bilan yozish orasida boshqa so'rovlar ishlashga ulguradi:
const MAKS = 5;
const baza = [];
const kut = () => new Promise((r) => setTimeout(r, 0));
async function yaratZaif(egasi) {
const soni = baza.filter((o) => o.egasi === egasi).length;
await kut(); // tarmoq va baza kechikishi
if (soni >= MAKS) return 409;
baza.push({ egasi });
return 201;
}
async function hujum(yarat) {
baza.length = 0;
const javoblar = await Promise.all(
Array.from({ length: 20 }, () => yarat("aziz")),
);
const kodlar = {};
for (const k of javoblar) kodlar[k] = (kodlar[k] ?? 0) + 1;
const s = JSON.stringify(kodlar);
console.log(`20 parallel → ${s}; bazada: ${baza.length} (limit 5)`);
}
await hujum(yaratZaif);
const navbatlar = new Map();
function qulfBilan(kalit, ish) {
const oldingi = navbatlar.get(kalit) ?? Promise.resolve();
const natija = oldingi.then(ish);
navbatlar.set(kalit, natija.catch(() => undefined));
return natija;
}
const yaratQulf = (egasi) => qulfBilan(egasi, () => yaratZaif(egasi));
await hujum(yaratQulf);Konsolda:
20 parallel → {"201":20}; bazada: 20 (limit 5)
20 parallel → {"201":5,"409":15}; bazada: 5 (limit 5)Birinchi hujumda 20 ta so'rovning hammasi sanashni await dan oldin qildi va hammasi 0 ni ko'rdi — 20 ta obuna. Ikkinchisida qulfBilan bir foydalanuvchining ishlarini navbatga qo'yadi: har keyingi ish oldingisi tugagach boshlanadi. Natija — 5 ta yaratildi, 15 tasi 409. Kalit — foydalanuvchi: Aziz o'z navbatida kutadi, Dilnozaning so'rovlari esa boshqa navbatda va Azizni kutmaydi.
Bu model bitta Node jarayoni ichida ishlaydi. Serverda nusxalar bir nechta va holat bazada bo'ladi, shuning uchun qulf ham bazada bo'lishi kerak. Kanon aynan shunday qildi.
4. Kanon tajribasi: webhook limiti
4.1 Qidiruv
Avval "sanash → qaror → yozish" naqshi bor joylar qidirildi (count(*) va MAKS_ bo'yicha grep). Kurs tajribasida (IlmHamroh, 2026-11) to'rtta joy topildi:
| Joy | Limit | Himoya |
|---|---|---|
| fayl ilovalari | vazifaga ko'pi bilan 10 ta | vazifa qatori FOR UPDATE bilan qulflanadi |
| OTP (SMS kod) | soat va kun bo'yicha | pg_advisory_xact_lock(telefon) |
| AI kvota | kunlik so'rovlar | bitta atomik INSERT … ON CONFLICT DO UPDATE |
| webhook obunalari | ko'pi bilan 5 ta | qulf yo'q |
Uchtasi himoyalangan. To'rtinchisi — 29-qismda yozilgan webhook obunalari (Chiquvchi webhook'larni yuborish) — qulfsiz.
Limit nega kerak edi? Har obuna — har hodisada tashqi manzilga chiquvchi so'rov. 5 ta obuna × 100 ta vazifa o'zgarishi = 500 ta so'rov. Limit ishchining yuklamasini va SSRF yuzasini cheklaydi: obuna qancha ko'p bo'lsa, hujumchi ichki manzillarni shuncha ko'p sinaydi (SSRF).
4.2 Hujum
Jonli serverda (vazifalar_api roli, production'dagi kabi ulanishlar pool'i) Aziz 20 ta parallel POST /v1/webhooklar yubordi. Har urinishdan oldin obunalar tozalandi, urinish beshta. Har qatorda ikki songa qarang: "201" — server nechta obunani qabul qildi, bazada obunalar — haqiqatda nechta yozildi:
urinish 1: 20 parallel POST → {"201":12,"409":8}; bazada obunalar: 12 (limit 5)
urinish 2: 20 parallel POST → {"201":11,"409":9}; bazada obunalar: 11 (limit 5)
urinish 3: 20 parallel POST → {"201":10,"409":10}; bazada obunalar: 10 (limit 5)
urinish 4: 20 parallel POST → {"201":10,"409":10}; bazada obunalar: 10 (limit 5)
urinish 5: 20 parallel POST → {"201":10,"409":10}; bazada obunalar: 10 (limit 5)
--- eng ko'p: 12 — LIMIT AYLANIB O'TILDILimit 5, bazada esa 10–12 ta. Modeldagidek 20 emas, chunki haqiqiy serverda so'rovlar bir vaqtda emas, millisekundlar farqi bilan yetib keladi. Kech qolganlari oldingilarining tasdiqlangan qatorlarini ko'rib, 409 oldi. Aniq son har safar boshqacha. Muhimi — u 5 dan katta.
Diqqat: Parallel so'rov hujumlarini faqat o'z lokal stack'ingizda sinang. Begona saytga, hatto bitta "tekshiruv" uchun yuborilgan parallel so'rovlar ham ruxsatsiz sinov hisoblanadi. Bundan tashqari, pul bilan bog'liq poyga sinovi haqiqiy tizimda haqiqiy pul yo'qotishiga olib keladi. Begona tizim — faqat egasining yozma ruxsati bilan (Pentest asoslari).
4.3 Tuzatish
Tuzatish — tranzaksiya boshida foydalanuvchi bo'yicha qulf. webhook.controller.ts dagi o'zgargan joy (qatorlar uzun, shuning uchun oddiy matn):
await c.query("SELECT pg_advisory_xact_lock(hashtext('webhook_obunalari'), $1)", [egasi]);
const n = (await c.query<{ n: number }>("SELECT count(*)::int AS n FROM webhook_obunalari WHERE foydalanuvchi_id = $1", [egasi])).rows[0]?.n ?? 0;
if (n >= MAKS_OBUNA) throw new KonfliktXatosi(`Ko'pi bilan ${String(MAKS_OBUNA)} ta webhook`, { kod: "webhook-limiti", sarlavha: "Webhook'lar soni chegarada" });Yangi qator — faqat birinchisi. Qolgan ikkitasi avvaldan bor edi, ular qulf ostiga o'tdi. SQL tilida butun oqim shunday:
BEGIN;
SELECT pg_advisory_xact_lock(hashtext('webhook_obunalari'), $1);
SELECT count(*)::int AS n FROM webhook_obunalari
WHERE foydalanuvchi_id = $1;
-- n < 5 bo'lsa:
INSERT INTO webhook_obunalari (foydalanuvchi_id, url, sir)
VALUES ($1, $2, $3);
COMMIT; -- qulf shu yerda o'zi bo'shaydiAdvisory lock ("maslahat qulfi") — Postgres'ning jadvalga bog'lanmagan qulfi (Qulflar: row, table va advisory). U ikki son bilan aniqlanadi: hashtext('webhook_obunalari') — "qaysi ish" va $1 — "qaysi foydalanuvchi". Bir foydalanuvchining ikkinchi tranzaksiyasi shu qatorda kutadi, birinchisi tugagach count ni yangidan o'qiydi. _xact_ — tranzaksiya qulfi: COMMIT yoki ROLLBACK da o'zi bo'shaydi. Xato bo'lsa ham qulf "osilib" qolmaydi.
Natija (o'sha hujum, yangi kod):
urinish 1: 20 parallel POST → {"201":5,"409":15}; bazada obunalar: 5 (limit 5)
urinish 2: 20 parallel POST → {"201":5,"409":15}; bazada obunalar: 5 (limit 5)
urinish 3: 20 parallel POST → {"201":5,"409":15}; bazada obunalar: 5 (limit 5)
urinish 4: 20 parallel POST → {"201":5,"409":15}; bazada obunalar: 5 (limit 5)
urinish 5: 20 parallel POST → {"201":5,"409":15}; bazada obunalar: 5 (limit 5)
--- eng ko'p: 5 — limit ushlandiBeshta urinishning hammasida aniq 5 × 201 va 15 × 409. Natija endi tasodifga bog'liq emas.
4.4 Boshqa yo'llar va ularning narxi
Advisory lock yagona yechim emas:
| Yo'l | Qanday | Narxi |
|---|---|---|
| advisory lock (kanon) | foydalanuvchi bo'yicha navbat | faqat shu ish ketma-ket; boshqa yozuvlarga ta'sir yo'q |
SELECT … FOR UPDATE foydalanuvchi qatoriga |
foydalanuvchi qatori qulflanadi | UPDATE huquqi kerak; shu qatorni yangilaydigan boshqa ishlar ham kutadi |
hisoblagich ustuni + shartli UPDATE |
UPDATE … SET soni = soni + 1 WHERE soni < 5 RETURNING |
qo'shimcha ustun, o'chirishda kamaytirish esdan chiqmasin |
SERIALIZABLE izolyatsiya |
Postgres ziddiyatni o'zi aniqlaydi | 40001 xatosida so'rovni qayta urinish kerak |
| unique cheklov | "bir martalik" hollar uchun (bir kupon — bir foydalanuvchi) | faqat "1 ta" limitga mos, "5 ta" ga emas |
Kanonda faqat advisory lock sinaldi. Qolganlari Amaliyot: race condition'larni hal qilish darsida ko'rilgan usullar, bu loyihada sinalmagan. Nega aynan advisory? FOR UPDATE ham ishlardi. Lekin u foydalanuvchi qatorida UPDATE huquqini talab qiladi va shu qatorni o'zgartiradigan boshqa ishlarni ham (masalan, profil tahriri) kuttiradi. Advisory lock hech qanday jadval huquqini talab qilmaydi va faqat aynan shu ishni — webhook yaratishni — navbatga qo'yadi.
Diqqat qiling: INSERT … SELECT … WHERE (SELECT count(*) …) < 5 kabi "bitta so'rovda tekshirish" READ COMMITTED da yechim emas. Ikki parallel so'rov baribir bir-birining tasdiqlanmagan qatorini ko'rmaydi. Bitta SQL — bitta atomik amal degani emas.
Tekshirib ko'ring: Jamoadosh "qulf o'rniga kodga
if (soni >= 5)dan keyin yana bir martacountqo'shamiz — ikki marta tekshirsak, aniq bo'ladi" dedi. Bu ishlaydimi?
Javob
Yo'q. Ikkinchi count ham xuddi birinchisidek boshqa tranzaksiyalarning tasdiqlanmagan qatorlarini ko'rmaydi. Oyna biroz torayadi, lekin yopilmaydi: ikki so'rov ikkala tekshiruvdan ham o'tib, keyin ikkalasi yozadi. Poyga holatini tekshiruvlar soni emas, ketma-ketlik kafolati yopadi — qulf, atomik shartli yozuv yoki unique cheklov.
5. Regressiya testi va bizning xatoimiz
5.1 Test
Tuzatish regressiya testisiz qoldirilmaydi. test/webhook-api.test.ts ga yangi test qo'shildi: 20 ta parallel POST, kutilgan natija — 5 × 201 va 15 × 409, bazada 5 ta, uch raund. Testning asosiy qatorlari (qatorlar uzun, oddiy matn sifatida):
const katta = pgPool(pool.options.connectionString ?? "", { max: 20 });
const app = await expressIlova({ ombor: (e) => new PgOmbori(pool, e), auth: d, webhooklar: { pool: katta, httpRuxsat: true } });
const javoblar = await Promise.all(Array.from({ length: 20 }, (_, i) => fetch(url, {
assert.deepEqual([kodlar.filter((k) => k === 201).length, kodlar.filter((k) => k === 409).length], [5, 15], `urinish ${String(u)}: ${JSON.stringify(kodlar)}`);Test avval eski kodda ishga tushirildi:
× limit parallel so'rovlarda ham ushlanadi: 20 parallel POST → 5 × 201, 15 × 409, bazada 5 ta 995ms
⎯⎯⎯⎯⎯⎯⎯ Failed Tests 1 ⎯⎯⎯⎯⎯⎯⎯
FAIL |asosiy| test/webhook-api.test.ts > limit parallel so'rovlarda ham ushlanadi: 20 parallel POST → 5 × 201, 15 × 409, bazada 5 ta
AssertionError: urinish 0: [201,201,201,201,201,201,201,201,201,201,201,201,201,201,201,201,201,201,201,201]
Tests 1 failed | 2 skipped (3)Tarjimasi: "0-urinishda 20 ta javobning hammasi 201". Test muhitida 20 ta so'rovning hammasi o'tdi — xuddi modeldagidek. Yangi kodda esa:
✓ limit parallel so'rovlarda ham ushlanadi: 20 parallel POST → 5 × 201, 15 × 409, bazada 5 ta 954ms
Tests 3 passed (3)5.2 Biz shunday xato qildik: test eski kodda ham o'tdi
Yuqoridagi test ikkinchi variant. Birinchi variant boshqacha edi: u testlardagi umumiy ulanishlar pool'idan foydalanardi, unda ko'pi bilan 5 ta ulanish bor. Shu test eski, qulfsiz kodda ham yashil o'tdi.
Nega? 20 ta so'rov keldi, lekin bazaga faqat 5 ta ulanish bor. Qolganlari ulanish navbatida kutdi. Natijada tranzaksiyalar deyarli ketma-ket bajarildi va poyga yuz bermadi. Pool tasodifan qulf vazifasini bajardi.
Production'da esa pool kattaroq va so'rovlar haqiqatan parallel bajariladi. Shuning uchun test alohida, 20 ulanishli pool oldi ({ max: 20 }). Testdagi izoh buni yozib qo'ygan: umumiy pool bilan eski kod ham o'tdi, haqiqiy parallellik uchun ko'p ulanish kerak.
Saboq ikki qismli:
- Yashil test ≠ poyga yo'q. Parallel test haqiqatan parallel ishlayaptimi — tekshiring. Eng ishonchli usul — testni avval eski kodda qizartirish.
- Test muhiti production'dan farq qilsa, poyga yashirinadi. Pool hajmi, nusxalar soni, tarmoq kechikishi — hammasi poygaga ta'sir qiladi.
6. Qoldiq: nima ochiq qoldi
Qidiruvda yana ikki narsa ko'rindi:
- API kalitlari soniga chegara yo'q. Har kalit — alohida kirish ma'lumoti. Ming kalit yaratilsa, ularni kuzatish va bekor qilish qiyinlashadi. Hozir ularni faqat umumiy tezlik cheklovi cheklaydi. Bu qoldiq xavf sifatida yakuniy auditga yoziladi (Xavfsizlik audit checklisti).
PUT /v1/vazifalaro'chirilgan vazifani id bilan qayta tiklaydi. Foydalanuvchi faqat o'z vazifasini tiklaydi — bu 25-qismdagi dizayn qarori. Xavf emas, lekin "o'chirilgan holatni qayta ochish" T08 qatorida bor edi, shuning uchun tekshirildi va yozildi.
7. Workflow: holat o'tishlari
Biznes mantiqning ikkinchi katta oilasi — holat o'tishlari. Buyurtma yaratildi → tolandi → yetkazildi yo'lidan yuradi. Har o'tish alohida so'rov. Hujumchi qadamni tashlab ketishga urinadi: to'lov qadamini o'tkazib, yetkazildi so'rovini to'g'ridan yuboradi.
Frontend tugmalari bu yerda himoya emas: "Yetkazildi" tugmasi faqat to'lovdan keyin ko'rinsa ham, so'rovni curl bilan yuborish mumkin. Qoida serverda, ruxsat etilgan o'tishlar jadvali bilan:
const OTISHLAR = {
yaratildi: ["tolandi", "bekor"],
tolandi: ["yetkazildi", "qaytarildi"],
yetkazildi: [],
bekor: [],
qaytarildi: [],
};
function otish(buyurtma, yangi) {
const ruxsat = Object.hasOwn(OTISHLAR, buyurtma.holat)
? OTISHLAR[buyurtma.holat]
: [];
if (!ruxsat.includes(yangi)) {
return `409: ${buyurtma.holat} → ${yangi} mumkin emas`;
}
buyurtma.holat = yangi;
return `200: ${yangi}`;
}
const b = { holat: "yaratildi" };
for (const yangi of [
"yetkazildi",
"tolandi",
"tolandi",
"yetkazildi",
"qaytarildi",
]) {
console.log(otish(b, yangi));
}
const g = { holat: "constructor" };
console.log(otish(g, "tolandi"));Konsolda:
409: yaratildi → yetkazildi mumkin emas
200: tolandi
409: tolandi → tolandi mumkin emas
200: yetkazildi
409: yetkazildi → qaytarildi mumkin emas
409: constructor → tolandi mumkin emasUch narsaga e'tibor bering. Birinchi qator — qadamni tashlab ketish rad etildi. Uchinchisi — ikki marta "to'landi" ham rad: takror to'lov xabari holatni ikkinchi marta o'zgartirmaydi. Oxirgi qatorda Object.hasOwn ishladi: OTISHLAR["constructor"] oddiy obyektda Object funksiyasini qaytarardi va kod yiqilardi (Yaxlitlik (A08) darsidagi prototip tuzog'i).
Haqiqiy loyihada bu jadval bazada ham turadi: UPDATE buyurtmalar SET holat = 'tolandi' WHERE id = $1 AND holat = 'yaratildi'. O'zgargan qatorlar soni 0 bo'lsa — o'tish rad etiladi. Bunday shartli UPDATE atomik: ikki parallel "to'landi" dan faqat bittasi o'tadi. vazifalar da buyurtma yo'q — to'lov oqimini To'lov xavfsizligi darsida modelda ko'ramiz.
8. Loyiha qadami: 4.3.0 relizi
8.1 Nima kiradi
Bu dars bilan uch darsning o'zgarishlari bitta relizga yig'iladi:
- Content Security Policy chuqur —
POST /v1/csp-hisobotqabul qiluvchisi va nginx'dagireport-to/report-uri(yangi imkoniyat); - Open redirect, postMessage va build'dagi sirlar — web'dagi
keyingiManziltuzatishi va testi; - shu dars — webhook limiti qulfi va regressiya testi.
Yangi imkoniyat bor (feat), shuning uchun versiya 4.3.0 (minor). CHANGELOG'dagi yozuv:
## 4.3.0 (2026-11-08)
### Features
* **xavfsizlik:** CSP buzilish hisobotlari — `POST /v1/csp-hisobot` (report-to va report-uri formatlari, xavfsiz log maydonlari, daqiqalik chegara); host nginx CSP'ga `report-to`/`report-uri` va `Reporting-Endpoints`
### Bug Fixes
* **webhook:** "ko'pi bilan 5 ta obuna" limiti parallel so'rovlarda aylanib o'tilardi (count → INSERT poygasi) — foydalanuvchi bo'yicha tranzaksiya qulfiKanon tajribasi git tarixisiz saqlangani uchun bu yozuv qo'lda yozilgan (Threat modeling darsidagi izoh). O'z repo'ngizda u commit xabarlaridan avtomatik hosil bo'ladi.
8.2 Tekshiruv va commit
To'liq tekshiruv (API): tip 0, lint 0, build 0, Vitest — 358 o'tdi + 1 o'tkazib yuborildi, e2e 10/10. Jonli server javoblari oldingi holat bilan aynan. Web: tip, lint va 55 fayldagi 361 test — hammasi o'tdi.
Har tuzatish alohida commit — CHANGELOG'da alohida qator bo'lishi va kerak bo'lsa alohida qaytarilishi uchun. Uchta commit xabari:
feat(xavfsizlik): CSP buzilish hisobotlari (report-to/report-uri) — 4.3.0
fix(auth): ?keyin= — URL parser bilan tahlil va origin tekshiruvi (tab/yangi qator bilan open redirect)
fix(webhook): obuna limiti parallel so'rovlarda aylanib o'tilardi — foydalanuvchi bo'yicha tranzaksiya qulfi (+ regressiya testi)Ikkinchisi web papkasidagi o'zgarish, qolgan ikkitasi — API'da. Reliz tegi — v4.3.0.
9. Hujumchi nigohi
Hujumchi biznes mantiqni qanday sinaydi:
- Har "faqat bir marta" va "ko'pi bilan N" ni sanaydi. Kupon, bonus, sinov muddati, taklif havolasi, ovoz berish, limit — har biriga 20–50 ta parallel so'rov.
- So'rovlarni bitta paketga jamlaydi. Zamonaviy usul — HTTP/2 da ko'p so'rovni bitta TCP paketda yuborish: ular serverga mikrosekundlar farqi bilan yetadi va poyga oynasi juda kichik bo'lsa ham ochiladi.
- Qadamlarni tashlab ketadi. Ko'p bosqichli formada oxirgi qadam so'rovini birinchisidan keyin darhol yuboradi.
- Raqamlar bilan o'ynaydi. Manfiy miqdor, nol narx, juda katta son (to'lib ketish), kasr (
0.001so'm), boshqa valyuta. - Javob farqlarini o'qiydi. Limitga yetganda 409, yetmaganda 201 — qolgan joylar sonini bilib oladi.
10. Ko'p uchraydigan xatolar
10.1 "Sanash → qaror → yozish" qulfsiz
READ COMMITTED da parallel tranzaksiyalar bir-birining yangi qatorini ko'rmaydi. Qulf, atomik shartli yozuv yoki unique cheklov.
10.2 Tekshiruvni ikki marta qilish
Oyna torayadi, yopilmaydi. Ketma-ketlik kafolati kerak.
10.3 Qulfni jarayon xotirasida qilish
Map dagi navbat bitta Node jarayonida ishlaydi. Ikki nusxada — ikki navbat. Qulf ma'lumot qayerda bo'lsa, o'sha yerda.
10.4 Parallel testni kichik pool bilan
Ulanishlar navbati so'rovlarni ketma-ket qiladi va test yolg'on yashil bo'ladi. Testni avval eski kodda qizartiring.
10.5 Mijozdan narx yoki holat olish
Narx, chegirma, holat — serverda hisoblanadi va tekshiriladi. Frontend tugmasi — qulaylik, himoya emas.
11. Mashqlar
Mashqlar kurs/mashqlar/35/07-biznes-mantiq/ da. 2-mashq Node 24.21.0 da, 3-mashq Git Bash'da tekshirilgan (biz ishga tushirdik).
1-mashq (oson): bo'shliqlarni to'ldiring
- "Tekshirish vaqti va ishlatish vaqti" poygasining qisqa nomi —
- Postgres'ning sukut izolyatsiya darajasi — READ
- Tranzaksiya tugashi bilan o'zi bo'shaydigan qulf funksiyasi —
pg_advisory__lock - Kanonda limit aylanib o'tilganda bazada eng ko'p nechta obuna bo'ldi —
- Bir kupon — bir foydalanuvchi qoidasini bazada kafolatlaydigan cheklov —
Yechim
- TOCTOU — time of check to time of use.
- COMMITTED — tasdiqlangan qatorlarnigina ko'radi.
- xact —
COMMIT/ROLLBACKda bo'shaydi. - 12 — limit 5 bo'lsa ham.
- unique — ikkinchi
INSERTxato bilan rad etiladi.
2-mashq (o'rta): bir martalik kupon
Xotiradagi model yozing. kuponZaif(foydalanuvchi, kod) avval ishlatilgan massivida shu juftlik bormi deb tekshirsin. Keyin await bilan kutib, juftlikni qo'shsin va "chegirma" qaytarsin; juftlik bor bo'lsa — "rad". kuponUnique(foydalanuvchi, kod) esa bazadagi unique cheklovni modellashtirsin: Set ga "foydalanuvchi:kod" kalitini kutishdan oldin, bitta qadamda qo'shishga urinsin — kalit bor bo'lsa, "rad". Har ikkalasiga 10 ta parallel so'rov yuboring va natijalarni sanang.
Ishora: Set.prototype.has va add orasida await bo'lmasa, ular bitta qadam — bu xuddi bazadagi unique indeksning atomikligi.
Yechim
const kut = () => new Promise((r) => setTimeout(r, 0));
const ishlatilgan = [];
const indeks = new Set();
async function kuponZaif(kim, kod) {
const bor = ishlatilgan.some((x) => x.kim === kim && x.kod === kod);
await kut();
if (bor) return "rad";
ishlatilgan.push({ kim, kod });
return "chegirma";
}
async function kuponUnique(kim, kod) {
const kalit = `${kim}:${kod}`;
if (indeks.has(kalit)) return "rad";
indeks.add(kalit);
await kut();
return "chegirma";
}
async function sina(nom, f) {
const javoblar = await Promise.all(
Array.from({ length: 10 }, () => f("aziz", "BAHOR50")),
);
const chegirma = javoblar.filter((j) => j === "chegirma").length;
console.log(`${nom}: chegirma ${chegirma}, rad ${10 - chegirma}`);
}
await sina("zaif", kuponZaif);
await sina("unique", kuponUnique);Konsolda:
zaif: chegirma 10, rad 0
unique: chegirma 1, rad 9Zaif variantda 10 ta so'rovning hammasi "hali ishlatilmagan" ni ko'rdi va chegirma oldi. kuponUnique da tekshirish va yozish orasida await yo'q — JS bitta oqimda ishlaydi, shuning uchun bu ikki qator bo'linmaydi. Bazada xuddi shu kafolatni UNIQUE (foydalanuvchi_id, kod) indeksi beradi: ikkinchi INSERT 23505 unique_violation bilan rad etiladi va kod uni "rad" ga aylantiradi.
3-mashq (qiyin): poyga natijasini tahlil qilish
Bash skript yozing. U avval poyga.txt ga kanon hujumi formatidagi besh qatorni yozsin (urinish N: 20 parallel POST → {"201":X,"409":Y}; bazada obunalar: Z (limit 5)). Keyin awk bilan har urinish uchun 201 sonini va bazadagi sonni ajratib, limitdan oshganini belgilasin. Oxirida eng katta qiymat va xulosa chiqsin. Ishora: match($0, /"201":[0-9]+/) dan keyin substr($0, RSTART + 6, RLENGTH - 6); bazadagi son — obunalar: dan keyingi maydon.
Yechim
for q in "1 12 8" "2 11 9" "3 10 10" "4 5 15" "5 5 15"; do
set -- $q
j="{\"201\":$2,\"409\":$3}"
b="bazada obunalar: $2 (limit 5)"
echo "urinish $1: 20 parallel POST → $j; $b"
done > poyga.txt
awk '
/^urinish/ {
match($0, /"201":[0-9]+/)
yaratildi = substr($0, RSTART + 6, RLENGTH - 6) + 0
for (i = 1; i <= NF; i++)
if ($i == "obunalar:") bazada = $(i + 1) + 0
holat = (bazada > 5) ? "OSHDI" : "ok"
if (bazada > maks) maks = bazada
print $1 " " $2 " 201 x " yaratildi ", bazada " bazada " — " holat
}
END {
xulosa = (maks > 5) ? "limit buzildi" : "limit ushlandi"
print "eng katta: " maks " — " xulosa
}
' poyga.txtBiz ishga tushirdik:
urinish 1: 201 x 12, bazada 12 — OSHDI
urinish 2: 201 x 11, bazada 11 — OSHDI
urinish 3: 201 x 10, bazada 10 — OSHDI
urinish 4: 201 x 5, bazada 5 — ok
urinish 5: 201 x 5, bazada 5 — ok
eng katta: 12 — limit buzildiFayl kanon chiqishi shaklida sikl bilan yasaladi. To'rtinchi va beshinchi qatorlar tuzatishdan keyingi natijadan olindi. Shunday qilib bitta faylda "oldin" va "keyin" aralashgan. match topgan joy RSTART va uzunlik RLENGTH o'zgaruvchilariga tushadi; + 6 — "201": qismining uzunligi. + 0 satrni songa aylantiradi, aks holda bazada > 5 satrlarni solishtirardi va "12" > "5" yolg'on bo'lardi. Matnlarda apostrofli so'zlardan qochildi: awk dasturi bash'da bitta tirnoq ichida turadi.
12. Real ishda
- Sovg'a kartalari (2015): tadqiqotchi Egor Homakov Starbucks sovg'a kartalari orasida pul o'tkazishda poyga holatini topdi. U bir kartadagi 5 dollarni ikki parallel tasdiqlash so'rovi bilan ikki marta o'tkazdi — yo'q puldan qo'shimcha 5 dollar paydo bo'ldi. Klassik "sanash → qaror → yozish". Uning o'zi tavsiya qilgan tuzatish —
FOR UPDATEqulfi. - Single-packet attack (2023): PortSwigger tadqiqotchisi James Kettle (Black Hat USA 2023) HTTP/2 da 20–30 ta so'rovni bitta paketda yuborib, millisekunddan kichik poyga oynalarini ham ochish mumkinligini ko'rsatdi. O'shandan beri limit poygalari bug bounty'da tez-tez topiladi.
- Moliyaviy tizimlar balansni hech qachon "o'qi → hisobla → yoz" bilan o'zgartirmaydi. Ular buxgalteriya yozuvlari (har amal — alohida qator), atomik shartli
UPDATEva kunlik solishtiruv (reconciliation) bilan ishlaydi (Refund, reconciliation va moliyaviy hisob). - Intervyu savollari: "Biznes mantiq zaifligini skaner nega topmaydi?", "TOCTOU nima, misol keltiring", "Limitni parallel so'rovlardan qanday himoyalaysiz?", "
SELECT … FOR UPDATEva advisory lock farqi nima?"
Xulosa
- Biznes mantiq zaifligi — so'rovlar to'g'ri, natija noto'g'ri; skaner qoidani bilmaydi, qoidani tekshiradigan — siz.
- Ikki oila: ishonch (narx, miqdor, holat mijozdan) va vaqt (TOCTOU poyga holati).
- READ COMMITTED da "sanash → qaror → yozish" himoyasiz: kanonda 20 parallel so'rov "ko'pi bilan 5 ta" limitida 10–12 ta obuna yaratdi.
- Tuzatish —
pg_advisory_xact_lock(hashtext('webhook_obunalari'), egasi): faqat shu foydalanuvchining yaratishlari ketma-ket, natija har safar 5 × 201, 15 × 409. - Poyga testi kichik pool bilan eski kodda ham o'tdi — testni avval eski kodda qizartiring, parallellik haqiqiy bo'lsin.
- Holat o'tishlari — serverdagi qat'iy jadval va shartli
UPDATE; frontend tugmasi himoya emas. - 4.3.0: CSP kollektori, open redirect tuzatishi, webhook limiti qulfi — uchta commit. Qoldiq: API kalitlari soniga chegara yo'q.
Keyingi dars: Fail-open va fail-closed: xato holatlarida xavfsizlik (A10:2025) — Redis va Postgres'ni haqiqatan o'chirib, login cheklovi nima qilishini ko'ramiz.
Manbalar
- OWASP — Business Logic Vulnerability: https://community.owasp.org/vulnerabilities/Business_logic_vulnerability (tekshirildi, 2026-11)
- PortSwigger Web Security Academy — Race conditions: https://portswigger.net/web-security/race-conditions (tekshirildi, 2026-11)
- PortSwigger Research — Smashing the state machine (James Kettle, 2023-08-09): https://portswigger.net/research/smashing-the-state-machine (tekshirildi, 2026-11)
- PostgreSQL 18 — Advisory Locks: https://www.postgresql.org/docs/18/explicit-locking.html#ADVISORY-LOCKS (tekshirildi, 2026-11)
- PostgreSQL 18 — Transaction Isolation (Read Committed): https://www.postgresql.org/docs/18/transaction-iso.html (tekshirildi, 2026-11)
- Egor Homakov — Hacking Starbucks for unlimited coffee (2015-05-21): https://sakurity.com/blog/2015/05/21/starbucks.html (tekshirildi, 2026-11)
- Kurs tajribasi (IlmHamroh, 2026-11):
vazifalar-api4.3.0, lokal stack (PostgreSQL 18.6,vazifalar_apiroli) — 5 × 20 parallel so'rov eski va yangi kodda; regressiya testi (Vitest 5.0.5) eski va yangi kodda. To'liq tekshiruv: tip, lint, build, Vitest 358 + 1, e2e 10/10; web — 361 test. Model bloklari va mashq yechimlari — biz ishga tushirdik (2026-11-09).
Izohlar · 0
Izoh yozish uchun kiring.