---
title: 'Bulgu Önceliklendirme'
source: 'https://academia.sh/tr/kurslar/guvenlik-otomasyonu/bulgu-onceliklendirme'
course: 'Güvenlik Otomasyonu ve Tedarik Zinciri'
language: tr
updated: '2026-08-17T18:06:43+00:00'
license: 'CC BY-SA 4.0'
---

# Bulgu Önceliklendirme

Kursun bütün denetimlerinden gelen bulgular tek kümede toplanıp ciddiyet, sömürülebilirlik ve maruziyetle üç kez sıralanır; ölçü sıralamanın kendisi değil aralarındaki farktır: kaç çiftte sıra ters dönüyor, ilk ona kaç kalem üçünde de giriyor, en çok kayan kalem kaç sıra yer değiştiriyor ve sonlu kapasite hangi sıralamayla neyi dışarıda bırakıyor.

Politika koşturuldu ve elde otuz işaretli bileşen kaldı. Bu kursun önceki on ölçümü de kendi
listesini bıraktı: tarama bulguları, eşleştirme kalemleri, envanterin cevaplayamadığı sorular,
köken belgesinin sınanamayan alanları. Hepsi ayrı listelerdir ve hepsi aynı kuyruğa düşer.

Kuyruk sonlu olduğuna göre sıra bir yerden gelmek zorundadır. Bu ders üç ölçütü ayrı ayrı
uygular: kalemin kendi ağırlığı, çalışan bir yolun bulunup bulunmadığı ve kaç şeyin etkilendiği.
Test süreci kursunda tekil bulgunun elle doğrulanması ölçülmüştü; o puanlama tekrarlanmaz. Ölçü
sıralamanın kendisi değil, **sıralamalar arasındaki farktır.**

**TZ25.** Birleşik küme kurgudur: otuz dört bulgu tek listede toplanır ve `node` ile modellenir;
tohum `330941` görünürdür. **TZ26.** Ciddiyet doğrudan verilir; sömürülebilirlik üç özellikten
(çağrılıyor mu, dışarıdan erişilir mi, yetki gerekiyor mu), maruziyet üç özellikten (üretimde mi,
kaç servis, kaç uç) hesaplanır. Eşitlik bozucu bulgu numarasıdır.

## Aynı Küme, Üç Sıralama

```js
// olcum-agi/siralama.mjs — ayni bulgu kumesi uc olcutle uc kez siralanir
import { mkdirSync, writeFileSync } from "node:fs";
import { join } from "node:path";

const KOK = join(process.env.TMPDIR ?? "/tmp", "olcum-agi-tz");
mkdirSync(KOK, { recursive: true });
const uretec = (tohum) => () =>
  (tohum = (tohum * 1103515245 + 12345) % 2147483648) / 2147483648;
const r = uretec(330941);                                  // tohum gorunur

// Kurgu birlesik kume: kursun on bir olcumunden gelen otuz dort bulgu tek listede toplanir.
const KAYNAK = ["statik", "calisan uyg", "bagimlilik", "sir tarama",
  "imaj katmani", "sablon", "koken", "politika"];
const BULGU = Array.from({ length: 34 }, (_, i) => {
  const b = { no: i + 1, kaynak: KAYNAK[Math.floor(r() * KAYNAK.length)],
    ciddiyet: 3 + Math.floor(r() * 8),                     // olcut 1: kalemin kendi agirligi
    cagrilir: r() < 0.62, disaridan: r() < 0.45, yetkiGerekir: r() < 0.55,
    uretimde: r() < 0.7, servis: 1 + Math.floor(r() * 3), uc: 1 + Math.floor(r() * 40) };
  // Olcut 2: bu kod tabaninda calisan bir yol var mi. Olcut 3: kac sey etkileniyor.
  b.somuru = (b.cagrilir ? 4 : 0) + (b.disaridan ? 4 : 0) + (b.yetkiGerekir ? 0 : 2);
  b.maruziyet = (b.uretimde ? 4 : 0) + b.servis + (b.uc >= 25 ? 3 : b.uc >= 10 ? 2 : 1);
  return b;
});
writeFileSync(join(KOK, "bulgu.json"), JSON.stringify(BULGU));

// Uc siralama. Esitlik bozucu bulgu numarasidir: siralama kosumdan kosuma ayni kalir.
const sirala = (alan) => [...BULGU].sort((a, b) => b[alan] - a[alan] || a.no - b.no);
const OLCUT = [["ciddiyet", "ciddiyet"], ["somurulebilirlik", "somuru"], ["maruziyet", "maruziyet"]];
const SIRA = Object.fromEntries(OLCUT.map(([ad, alan]) => [ad, sirala(alan)]));

const N = 10;
const S = [6, 22, 22, 0];
const satir = (s) => console.log(s.map((v, i) => String(v).padEnd(S[i])).join(""));
satir(["sira", "ciddiyet", "somurulebilirlik", "maruziyet"]);
const yaz = (b, alan) => `#${String(b.no).padStart(2, "0")} ${b.kaynak} ${b[alan]}`;
for (let i = 0; i < N; i++)
  satir([i + 1, yaz(SIRA.ciddiyet[i], "ciddiyet"), yaz(SIRA.somurulebilirlik[i], "somuru"),
    yaz(SIRA.maruziyet[i], "maruziyet")]);

const ilkOn = Object.fromEntries(OLCUT.map(([ad]) => [ad, new Set(SIRA[ad].slice(0, N).map((b) => b.no))]));
const kume = Object.values(ilkOn);
const kacinda = (no) => kume.filter((k) => k.has(no)).length;
const birlesim = [...new Set(kume.flatMap((k) => [...k]))];
console.log("");
console.log(`bulgu ${BULGU.length}; ilk ${N} listelerinin birlesimi ${birlesim.length} kalem, ` +
  `kesisimi ${birlesim.filter((no) => kacinda(no) === 3).length} kalem; tohum 330941`);
console.log(`ucunde de ilk ${N}: ${birlesim.filter((no) => kacinda(no) === 3).length}, ` +
  `ikisinde: ${birlesim.filter((no) => kacinda(no) === 2).length}, ` +
  `yalniz birinde: ${birlesim.filter((no) => kacinda(no) === 1).length}`);
console.log(`ucunde de ilk ${N}'da olan tek kalem: ` +
  birlesim.filter((no) => kacinda(no) === 3).map((no) => `#${no}`).join(", ") +
  `; hicbir olcutte ilk ${N}'a girmeyen bulgu ${BULGU.length - birlesim.length}`);
```

```
sira  ciddiyet              somurulebilirlik      maruziyet
1     #06 koken 10          #04 bagimlilik 10     #09 koken 10
2     #14 bagimlilik 10     #06 koken 10          #21 calisan uyg 10
3     #20 statik 10         #15 koken 10          #25 koken 10
4     #25 koken 10          #22 imaj katmani 10   #27 bagimlilik 10
5     #27 bagimlilik 10     #24 sir tarama 10     #31 sablon 10
6     #34 sablon 10         #25 koken 10          #05 politika 9
7     #07 politika 9        #03 sablon 8          #16 koken 9
8     #08 koken 9           #09 koken 8           #18 calisan uyg 9
9     #04 bagimlilik 8      #13 politika 8        #22 imaj katmani 9
10    #05 politika 8        #16 koken 8           #29 koken 9

bulgu 34; ilk 10 listelerinin birlesimi 21 kalem, kesisimi 1 kalem; tohum 330941
ucunde de ilk 10: 1, ikisinde: 7, yalniz birinde: 13
ucunde de ilk 10'da olan tek kalem: #25; hicbir olcutte ilk 10'a girmeyen bulgu 13
```

Üç sütun aynı kalemlerin üç görüntüsüdür ve **üçünde de ilk ona giren tek bir kalem
vardır: #25.** Üç listenin birleşimi 21 kalemdir — "ilk on" demek, yirmi bir kalemden onunu
seçmek demektir.

Birleşimin **13 kalemi yalnız bir ölçütte** ilk ona girer; ölçüt seçimi o kalemleri kuyruğun
başına da sonuna da koyabilir. Kuyruğun sessiz kısmı da tabloda: otuz dört bulgunun **13'ü
hiçbir ölçütte ilk ona girmez.**

## Sıralama Kaç Yerde Değişiyor

İlk on karşılaştırması yalnız listenin tepesini görür. Asıl soru, iki sıralamanın **kaç çiftte**
birbirine ters düştüğüdür.

```js
// olcum-agi/kayma.mjs — uc siralama arasinda kac yerde sira degisiyor
import { readFileSync } from "node:fs";
import { join } from "node:path";

const KOK = join(process.env.TMPDIR ?? "/tmp", "olcum-agi-tz");
const BULGU = JSON.parse(readFileSync(join(KOK, "bulgu.json")));

const OLCUT = [["ciddiyet", "ciddiyet"], ["somurulebilirlik", "somuru"], ["maruziyet", "maruziyet"]];
const sirala = (alan) => [...BULGU].sort((a, b) => b[alan] - a[alan] || a.no - b.no);
// Konum: kalemin o siralamadaki yeri (1 en ustte). Esitlik bozucu bulgu numarasidir.
const KONUM = Object.fromEntries(OLCUT.map(([ad, alan]) =>
  [ad, new Map(sirala(alan).map((b, i) => [b.no, i + 1]))]));
const ilkOn = Object.fromEntries(OLCUT.map(([ad]) =>
  [ad, new Set(sirala(OLCUT.find(([a]) => a === ad)[1]).slice(0, 10).map((b) => b.no))]));

const CIFT = [["ciddiyet", "somurulebilirlik"], ["ciddiyet", "maruziyet"],
  ["somurulebilirlik", "maruziyet"]];
const S = [30, 14, 9, 13, 0];
const satir = (s) => console.log(s.map((v, i) => String(v).padEnd(S[i])).join(""));
satir(["karsilastirma", "ters donen", "oran", "ilk 10 ortak", "en buyuk kayma"]);
const toplamCift = (BULGU.length * (BULGU.length - 1)) / 2;
for (const [x, y] of CIFT) {
  let ters = 0, enBuyuk = 0;
  for (let i = 0; i < BULGU.length; i++)
    for (let j = i + 1; j < BULGU.length; j++) {
      const [a, b] = [BULGU[i].no, BULGU[j].no];
      const solda = KONUM[x].get(a) < KONUM[x].get(b);
      if (solda !== (KONUM[y].get(a) < KONUM[y].get(b))) ters++;
    }
  for (const b of BULGU)
    enBuyuk = Math.max(enBuyuk, Math.abs(KONUM[x].get(b.no) - KONUM[y].get(b.no)));
  const ortak = [...ilkOn[x]].filter((no) => ilkOn[y].has(no)).length;
  satir([`${x} - ${y}`, `${ters}/${toplamCift}`, `%${Math.round((100 * ters) / toplamCift)}`,
    `${ortak}/10`, `${enBuyuk} sira`]);
}

// En cok kayan bes kalem: uc siradaki en yuksek ve en dusuk konumun farki.
const yayilim = (b) => {
  const k = OLCUT.map(([ad]) => KONUM[ad].get(b.no));
  return { b, k, fark: Math.max(...k) - Math.min(...k) };
};
const T = [8, 16, 12, 12, 0];
const satir2 = (s) => console.log(s.map((v, i) => String(v).padEnd(T[i])).join(""));
console.log("");
satir2(["bulgu", "kaynak", "ciddiyet", "somuru", "maruziyet"]);
for (const { b, k } of BULGU.map(yayilim).sort((x, y) => y.fark - x.fark || x.b.no - y.b.no).slice(0, 5))
  satir2([`#${b.no}`, b.kaynak, `${b.ciddiyet} (${k[0]}.)`, `${b.somuru} (${k[1]}.)`,
    `${b.maruziyet} (${k[2]}.)`]);
console.log("");
const enYayik = BULGU.map(yayilim).sort((x, y) => y.fark - x.fark)[0];
console.log(`otuz dort kalemin ${BULGU.filter((b) => yayilim(b).fark >= 15).length} tanesi uc ` +
  `siralamada 15 siradan fazla yer degistiriyor; en yayigi #${enYayik.b.no} ile ${enYayik.fark} sira`);
```

```
karsilastirma                 ters donen    oran     ilk 10 ortak en buyuk kayma
ciddiyet - somurulebilirlik   295/561       %53      3/10         31 sira
ciddiyet - maruziyet          290/561       %52      3/10         29 sira
somurulebilirlik - maruziyet  277/561       %49      4/10         29 sira

bulgu   kaynak          ciddiyet    somuru      maruziyet
#14     bagimlilik      10 (2.)     0 (33.)     7 (25.)
#15     koken           5 (26.)     10 (3.)     3 (32.)
#22     imaj katmani    3 (33.)     10 (4.)     9 (9.)
#31     sablon          3 (34.)     6 (24.)     10 (5.)
#9      koken           4 (29.)     8 (8.)      10 (1.)

otuz dort kalemin 21 tanesi uc siralamada 15 siradan fazla yer degistiriyor; en yayigi #14 ile 31 sira
```

Ters dönen çift oranı üç karşılaştırmada da **%49 ile %53 arasındadır**: 561 çiftin yaklaşık
yarısında iki ölçüt birbirine ters düşer. **Ciddiyetle sıralanmış bir liste, sömürülebilirlikle
sıralanmış listenin yaklaşık yarısını ters çevirir.** Ölçütler birbirinin yaklaşımı değildir; ayrı
şeyler ölçerler.

İkinci tablo bunu kalemlerde gösterir. **#14 ciddiyette ikinci, sömürülebilirlikte otuz
üçüncüdür** — ağırlığı en yüksek kalemlerden biridir ve ona giden çalışan bir yol yoktur. Karşıt
uç **#31**'dir: ciddiyette otuz dördüncü, maruziyette beşinci. Kalemlerin **21'i** on beş sıradan
fazla yer değiştirir.

## Sonlu Kapasite

Sıralama tek başına sonuç değildir; sonucu doğuran şey listenin nerede kesildiğidir.

**TZ27.** Birleşik sıra üç sıradaki konumların toplamıdır; ağırlık yoktur.
**TZ28.** Kapasite on iki kalemdir; kalem başına 45 dakika düzeltme veridir, ölçülmüş değildir.

```js
// olcum-agi/kapasite.mjs — sonlu kuyruk: hangi siralama ilk on ikiye neyi aliyor
import { readFileSync } from "node:fs";
import { join } from "node:path";

const KOK = join(process.env.TMPDIR ?? "/tmp", "olcum-agi-tz");
const BULGU = JSON.parse(readFileSync(join(KOK, "bulgu.json")));

const OLCUT = [["ciddiyet", "ciddiyet"], ["somurulebilirlik", "somuru"], ["maruziyet", "maruziyet"]];
const sirala = (alan) => [...BULGU].sort((a, b) => b[alan] - a[alan] || a.no - b.no);
const KONUM = Object.fromEntries(OLCUT.map(([ad, alan]) =>
  [ad, new Map(sirala(alan).map((b, i) => [b.no, i + 1]))]));
// Birlesik sira: uc siralamadaki konumlarin toplami. Agirlik yok, uc olcut esit sayilir.
const toplamKonum = (b) => OLCUT.reduce((n, [ad]) => n + KONUM[ad].get(b.no), 0);
const birlesik = [...BULGU].sort((a, b) => toplamKonum(a) - toplamKonum(b) || a.no - b.no);

const KAPASITE = 12, DUZELTME_DK = 45;                     // sure VERI olarak verilmistir
const LISTE = [...OLCUT.map(([ad, alan]) => [ad, sirala(alan)]), ["birlesik", birlesik]]
  .map(([ad, dizi]) => [ad, dizi.slice(0, KAPASITE)]);
const ort = (kume, alan) => (kume.reduce((n, b) => n + b[alan], 0) / kume.length).toFixed(1);

const S = [20, 14, 13, 15, 0];
const satir = (s) => console.log(s.map((v, i) => String(v).padEnd(S[i])).join(""));
satir(["siralama", "ort. ciddiyet", "ort. somuru", "ort. maruziyet", "birlesikle ortak"]);
const birlesikNo = new Set(LISTE.at(-1)[1].map((b) => b.no));
for (const [ad, kume] of LISTE)
  satir([ad, ort(kume, "ciddiyet"), ort(kume, "somuru"), ort(kume, "maruziyet"),
    `${kume.filter((b) => birlesikNo.has(b.no)).length}/${KAPASITE}`]);

const hicbirinde = BULGU.filter((b) => LISTE.every(([, k]) => k.every((x) => x.no !== b.no)));
const somurusuz = LISTE[0][1].filter((b) => b.somuru <= 2).length;
const disarida = sirala("somuru").slice(0, KAPASITE).filter((b) => !birlesikNo.has(b.no)).length;
console.log("");
console.log(`kapasite ${KAPASITE} kalem, kalem basina ${DUZELTME_DK} dk duzeltme (veri): ` +
  `${KAPASITE * DUZELTME_DK} dk; kuyrukta kalan ${BULGU.length - KAPASITE} kalem`);
console.log(`yalniz ciddiyetle siralanan ilk ${KAPASITE}'nin ${somurusuz} kaleminde calisan bir ` +
  `yol yok; somurulebilirlik sirasinin ${disarida} kalemi birlesik sirada disarida kaliyor`);
console.log(`hicbir siralamanin ilk ${KAPASITE}'sine girmeyen bulgu ${hicbirinde.length}/` +
  `${BULGU.length}; ${hicbirinde.filter((b) => b.uretimde).length} tanesi uretimde duruyor`);
```

```
siralama            ort. ciddiyet ort. somuru  ort. maruziyet birlesikle ortak
ciddiyet            9.2           6.0          7.3            7/12
somurulebilirlik    6.8           9.0          7.5            8/12
maruziyet           6.1           6.3          9.3            7/12
birlesik            8.0           7.5          8.8            12/12

kapasite 12 kalem, kalem basina 45 dk duzeltme (veri): 540 dk; kuyrukta kalan 22 kalem
yalniz ciddiyetle siralanan ilk 12'nin 2 kaleminde calisan bir yol yok; somurulebilirlik sirasinin 4 kalemi birlesik sirada disarida kaliyor
hicbir siralamanin ilk 12'sine girmeyen bulgu 9/34; 5 tanesi uretimde duruyor
```

Her sıralama kendi ölçütünde en yükseği seçer, ötekilerde ortalamaya düşer: ciddiyet sırası 9,2
ortalama ciddiyet getirir, sömürülebilirlik ortalaması 6,0'da kalır. Birleşik sıra hiçbir sütunda
en yüksek değildir, üçünde de sekizin üstündedir. **Üç ölçütü birleştirmek en iyi listeyi değil,
en az kötü listeyi verir.**

Yalnız ciddiyetle sıralanan ilk on ikinin **2 kaleminde çalışan bir yol yoktur**: doksan dakika
harcanır, kapanan yol sıfırdır. Son satır kuyruğun kör noktasını yazar:
**9 bulgu hiçbir sıralamanın ilk on ikisine girmez ve 5'i üretimde durur.**

## Özet

- Aynı 34 bulgu üç ölçütle sıralandığında üçünde de ilk ona giren tek kalem vardır; birleşim 21
  kalem, 13'ü yalnız bir ölçütte.
- Ters dönen çift oranı %49 ile %53 arasındadır; 34 kalemin 21'i on beşten fazla sıra kayar.
  Ciddiyette ikinci olan kalem sömürülebilirlikte otuz üçüncüdür.
- Birleşik sıra hiçbir sütunda en yüksek değildir ama üçünde de sekizin üstündedir; yalnız
  ciddiyetle seçilen ilk on ikinin 2 kaleminde çalışan bir yol yoktur.
- Kapasite 12 kalem ve 540 dakikadır; 22 kalem kuyrukta kalır, 9 bulgu hiçbir sıralamanın ilk
  on ikisine girmez ve 5'i üretimde durur.

## Kurs Kapanışı

| Ders | Taranan / bulgu | Gerçek / yanlış pozitif / görülmeyen | Hattan aldığı süre |
|---|---|---|---|
| Statik uygulama güvenlik testi | 720 nokta / 418 bulgu | 101 / 317 / 62 | 2 085 dk, 61 yanlış bloke |
| Dinamik uygulama güvenlik testi | 84 uç / 17 bulgu | 10 / 7 / 18 | 5 316 dk, gecelik 443 dk |
| Bağımlılık bileşen analizi | 210 bileşen / 139 eşleşme | 31 / 108 / 12 | 1 870 dk, 57 bloke yapı |
| Depo geçmişinde sır tarama | 1 800 işleme / 677 eşleşme | 260 / 417 / 50 | 57 dk tarama, 1 668 dk inceleme |
| Konteyner imaj tarama | 348 bileşen / 144 bulgu | 144 / ölçülmedi / 18 | 1 805 dk, 49 bloke yapı |
| Kod olarak altyapı taraması | 420 kalem / 55 kesin bulgu | 55 / 0 / 19 | 800 dk, 34 bloke yapı |
| Yazılım malzeme listesi | 73 kayıt / 12 soru | 8 cevaplanan / 3 eksik alanla / 4 sorulamayan | 820 s, seyrekte 41 s |
| Yapı çıktısı imzalama | 124 çıktı / 8 iddia | 3 kanıtlanan / 5 geçen yanlış / 4 sahte imza | 120 çıktı yeniden üretim |
| Köken bilgisi | 14 alan / 12 yapı | 4 kanıt alanı / 3 yanlış işaret / 7 sınanamaz beyan | 480 s, yeniden üretimle 9 040 s |
| Derleme ortamı yalıtımı | 18 kalem / 90 erişim çifti | 15 gerekli / 75 gereksiz / 25 kapatılamayan | 1 380 s, 30 koşum |
| Bağımlılık politikası | 48 bileşen / 46 işaret | 10 gerçek / 20 yanlış işaret / 3 görülmeyen | 270 s, 96 dk müdahale |
| Bulgu önceliklendirme | 34 bulgu / 3 sıralama | 1 üçünde de üstte / 13 yalnız birinde / 9 hiçbir listede | 540 dk, 22 kalem kuyrukta |

Üçüncü sütun on iki satırda da doludur; kursun kuralı odur: **otomatik denetimin değeri bulduğu
bulgu sayısı değil, kaçırdığını bilmen ve hattan aldığı sürenin karşılığını almandır.** Kaçırdığı
yazılmayan tarama bir güvence değil, bir yanılsamadır. Erişim denetimi açıkları iki denetimde de
sıfır bulguyla kapandı, 50 sır hiçbir desene takılmadı, 19 ihlal için kural yoktu ve bakım devri
hiçbir alanda görünmedi; bu sayılar raporlanmadıkça "sıfır bulgu" ile "hiç bakılmadı" ayırt
edilemez.

Dördüncü sütun aynı sertlikte okunur: hattan alınan sürenin karşılığı her zaman alınmaz. Köken
belgesinin varlığını aramak 480 saniye harcayıp dört bozuk isteğin dördünü de geçirdi. Bir
denetimin ölçülmüş sayılması için üç sütunun üçünün de yazılması gerekir.

Kod tarandı, bileşenler envanterlendi ve yapı çıktısı imzalandı. Bütün bu denetimlerin ortak bir
sınırı var: hepsi **dağıtımdan önce** duruyordu. Yirmi iki bulgu kuyrukta kaldı, dokuzu hiçbir
listeye girmedi ve onlar üretime kendi hâlleriyle gidiyor. **M25/K04 Çalışma Zamanı Güvenliği ve
Sır Yönetimi** o andan sonrasını sorar: uygulama çalışmaya başladığı andan itibaren onu neyin
koruduğu bu kursta hiç sorulmadı.
