Bulgu Önceliklendirme

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

// 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.

// 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.

// 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ı.