--- title: 'Siber Güvenliğe Giriş' source: 'https://academia.sh/tr/kurslar/siber-guvenlige-giris' language: tr updated: '2026-08-17T04:39:54+00:00' license: 'CC BY-SA 4.0' lessons: 15 outcomes: - 'Varlık, tehdit, açık, istismar ve risk terimlerini sayıya bağlayarak ayırır' - 'Saldırı yüzeyini sayılabilir birim olarak ölçer ve azaltmanın bedelini hesaplar' - 'Her savunma ilkesinin kaç yolu kapattığını ve kaç meşru işi durdurduğunu karşılaştırır' --- # Siber Güvenliğe Giriş Güvenliğin ölçü birimlerinin kurulması: gizlilik, bütünlük ve erişilebilirliğin aynı varlık üzerinde çakışması, varlık, tehdit, açık ve istismar terimlerinin ayrılması, riskin olasılık ile etkinin bileşimi olarak hesaplanması, açıktan etkiye giden zincirin adımlanması, saldırı yüzeyinin sayılabilir birime çevrilmesi, derinlemesine savunma, en az yetki, yalıtım, sıfır güven, kimlik doğrulama ile yetkilendirme ayrımı ve güvenli varsayılanların her birinin kaç yolu kapattığı, mavi, kırmızı ve mor takımların işlevi, güvenlik rolleri, yetkilendirme ve yasal sınır, mesleki yetkinlik yolları. ## Temel Kavramlar Güvenliğin ölçü birimlerinin kurulması: gizlilik, bütünlük ve erişilebilirlik ekseninin aynı varlık üzerinde çakışması, varlık, tehdit ve açık terimlerinin aynı envanterde ayrılması, riskin olasılık ile etkinin bileşimi olarak hesaplanıp sıralamaya çevrilmesi, açıktan etkiye giden zincirin adımlanması ve saldırı yüzeyinin erişim grafiğinde sayılabilir yol sayısına indirgenmesi. ### Gizlilik, Bütünlük ve Erişilebilirlik Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/gizlilik-butunluk-erisilebilirlik Üç eksenin aynı varlık üzerinde çakışması: sekiz varlık ve altı kararlık modelde 27 (kalem, eksen) çiftinin yükselirken 22'sinin düşmesi, gizlilik toplamının 34'ten 41'e, bütünlüğün 44'ten 63'e ve erişilebilirliğin 47'den 51'e çıkması, net etkisi sıfır olan bir kararın erişilebilirliği dokuz puan yükseltip gizliliği altı puan düşürmesi, anahtar kaybında erişilebilirlik toplamının 51'den 24'e inip sekiz varlıktan dördünün sıfırlanması ve bu sırada ortalama puanın yalnız 6,5'ten 5,3'e düşmesi. Önceki müfredat beş kurs boyunca aynı şeyi ölçtü: bir katman kiralandığında hangi kararın devredildiğini ve karşılığında hangi sayının düzeldiğini. Kiralanan da satın alınan da aynı sessiz varsayımı taşıyordu — o katmana **yalnız yetkili olanın eriştiği**. Bu ders o varsayımı kaldırır ve yerine üç ayrı soru koyar: veriyi kim görebiliyor, kim değiştirebiliyor, gerektiğinde kim ulaşabiliyor. Bu üç soru güvenliğin üç eksenidir: **gizlilik (confidentiality)**, **bütünlük (integrity)** ve **erişilebilirlik (availability)**. Ayrı ayrı ele alındıklarında üçü de itiraz edilemez görünür. Aynı varlığın üstüne birlikte konduklarında ise birbirlerine bastırırlar: bir ekseni yükselten karar çoğu zaman ötekini düşürür. Bu dersin ölçtüğü şey o bastırmadır — kaç kalem hangi eksende kazanıyor, kaçı kaybediyor. #### Üç Eksen Aynı Varlığın Üstündedir Örnek, müfredat boyunca sürecek kurgu **bölgesel ölçüm ağı**dır: su sayacı okumalarını toplayan bir servis, okumaları doğrulayan bir servis, faturalama ve iş emri servisleri, saha ekipleri ve şube uçları. Ağ da varlıklar da kurgudur; aşağıdaki puanlar bir **modeldir**, gerçek bir sistemde yapılmış ölçüm değildir. **GK1:** varlık envanteri sekiz kalemdir. **GK2:** her varlık üç eksende 0 ile 10 arasında bir taban puan taşır; puan, o eksenin o kalemde ne kadar sağlandığını gösterir. **GK3:** her güvenlik kararı belirli kalemlere dokunur ve üç eksende ayrı ayrı bir fark (delta) yazar; puan 0'ın altına inmez, 10'un üstüne çıkmaz. **GK4:** iki kararın bir **kırılma koşulu** vardır — koşul gerçekleşirse o kararın dokunduğu kalemlerin erişilebilirliği sıfırlanır. **GK5:** kararlar listedeki sırayla uygulanır; sınırlama her adımda işler. ```js // guvenlik/eksen.mjs — kurgu bolgesel olcum aginin varlik envanteri ve uc eksen modeli (model): // gercek bir ag, gercek bir varlik kaydi ya da gercek bir guvenlik olcumu yok. Rastgelelik yok. export const EKSEN = ["giz", "but", "eri"]; export const SINIR = (x) => Math.max(0, Math.min(10, x)); // GK2: her varlik uc eksende 0..10 taban puan tasir; puanlar kurgudur. export const VARLIK = ` okuma-verisi 4 5 6 fatura-kaydi 5 6 5 is-emri-kuyrugu 3 5 7 kimlik-deposu 6 6 5 yapilandirma 4 6 6 denetim-gunlugu 5 4 5 sayac-urun-yazilimi 3 7 6 saha-uygulamasi 4 5 7` .trim().split("\n").map((r) => { const [ad, ...p] = r.trim().split(/\s+/); return { ad, taban: Object.fromEntries(EKSEN.map((e, i) => [e, +p[i]])) }; }); // GK3: her karar bir kalem altkumesine dokunur ve uc eksende delta yazar. // GK4: kirilma kosulu gerceklesirse o kalemlerin erisilebilirligi sifirlanir. export const KARAR = [ { ad: "duragan-sifreleme", d: { giz: 4, but: 0, eri: -1 }, kirilma: "anahtar-kaybi", kalem: ["okuma-verisi", "fatura-kaydi", "kimlik-deposu", "denetim-gunlugu"] }, { ad: "gecelik-yedek", d: { giz: -2, but: 1, eri: 3 }, kirilma: null, kalem: ["okuma-verisi", "fatura-kaydi", "is-emri-kuyrugu", "yapilandirma", "denetim-gunlugu"] }, { ad: "eklemeli-gunluk", d: { giz: 0, but: 4, eri: -1 }, kirilma: null, kalem: ["denetim-gunlugu", "fatura-kaydi"] }, { ad: "cok-etmenli-giris", d: { giz: 3, but: 1, eri: -2 }, kirilma: "etmen-kaybi", kalem: ["kimlik-deposu", "yapilandirma", "saha-uygulamasi"] }, { ad: "imzali-urun-yazilimi", d: { giz: 0, but: 4, eri: -2 }, kirilma: null, kalem: ["sayac-urun-yazilimi", "saha-uygulamasi"] }, { ad: "ikinci-kopya", d: { giz: -2, but: -1, eri: 3 }, kirilma: null, kalem: ["okuma-verisi", "fatura-kaydi", "is-emri-kuyrugu"] }, ]; export function uygula(kirilan = []) { const s = Object.fromEntries(VARLIK.map((v) => [v.ad, { ...v.taban }])); for (const k of KARAR) for (const ad of k.kalem) for (const e of EKSEN) s[ad][e] = SINIR(s[ad][e] + k.d[e]); for (const k of KARAR) if (k.kirilma && kirilan.includes(k.kirilma)) for (const ad of k.kalem) s[ad].eri = 0; return s; } // Bir kararin tek basina kac (kalem, eksen) ciftini yukselttigi ve dusurdugu. export function etki(k) { const yuk = k.kalem.length * EKSEN.filter((e) => k.d[e] > 0).length; const dus = k.kalem.length * EKSEN.filter((e) => k.d[e] < 0).length; return { yuk, dus, net: k.kalem.length * EKSEN.reduce((a, e) => a + k.d[e], 0), enKotu: Math.min(...EKSEN.map((e) => k.d[e])) }; } export const toplam = (s, e) => VARLIK.reduce((a, v) => a + s[v.ad][e], 0); ``` ```js // guvenlik/olc.mjs — uc eksen ayni varlik uzerinde: kim yukseliyor, kim dusuyor, ne kiriliyor. import { EKSEN, VARLIK, KARAR, uygula, etki, toplam } from "./eksen.mjs"; const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const taban = Object.fromEntries(VARLIK.map((v) => [v.ad, { ...v.taban }])); const son = uygula(); console.log(`${VARLIK.length} varlik x ${EKSEN.length} eksen, ${KARAR.length} karar; ` + `puan araligi 0..10 (giz gizlilik, but butunluk, eri erisilebilirlik)`); const A = [-21, 6, 6, 6, 4, 7, 6, 6]; console.log("\n1. taban puan ve alti karar uygulandiktan sonraki puan"); yaz(A, "varlik", "giz", "but", "eri", "", "giz'", "but'", "eri'"); for (const v of VARLIK) yaz(A, v.ad, ...EKSEN.map((e) => taban[v.ad][e]), "", ...EKSEN.map((e) => son[v.ad][e])); yaz(A, "toplam", ...EKSEN.map((e) => toplam(taban, e)), "", ...EKSEN.map((e) => toplam(son, e))); const B = [-22, 7, 10, 8, 7, 15]; console.log("\n2. karar basina kac (kalem, eksen) cifti yukseliyor, kaci dusuyor"); yaz(B, "karar", "kalem", "yukselen", "dusen", "net", "en kotu eksen"); for (const k of KARAR) { const e = etki(k); yaz(B, k.ad, k.kalem.length, e.yuk, e.dus, (e.net > 0 ? "+" : "") + e.net, EKSEN.find((x) => k.d[x] === e.enKotu) + " " + e.enKotu); } const T = KARAR.map(etki); yaz(B, "TOPLAM", KARAR.reduce((a, k) => a + k.kalem.length, 0), T.reduce((a, e) => a + e.yuk, 0), T.reduce((a, e) => a + e.dus, 0), "+" + T.reduce((a, e) => a + e.net, 0), "-"); const C = [-16, 12, 12, 12, 16]; console.log("\n3. kirilma kosulu gerceklesince (erisilebilirlik sifirlanir)"); yaz(C, "kosul", "giz toplam", "but toplam", "eri toplam", "eri = 0 kalem"); for (const [ad, ks] of [["kirilma yok", []], ["anahtar-kaybi", ["anahtar-kaybi"]], ["etmen-kaybi", ["etmen-kaybi"]], ["ikisi birden", ["anahtar-kaybi", "etmen-kaybi"]]]) { const s = uygula(ks); yaz(C, ad, ...EKSEN.map((e) => toplam(s, e)), VARLIK.filter((v) => s[v.ad].eri === 0).length + "/" + VARLIK.length); } const D = [-21, 10, 11, 8]; console.log("\n4. varlik basina en dusuk eksen (kirilma yok, sonra anahtar kaybi)"); yaz(D, "varlik", "en dusuk", "kirilinca", "eksen"); const kir = uygula(["anahtar-kaybi"]); for (const v of VARLIK) { const a = Math.min(...EKSEN.map((e) => son[v.ad][e])); const b = Math.min(...EKSEN.map((e) => kir[v.ad][e])); yaz(D, v.ad, a, b, EKSEN.find((e) => kir[v.ad][e] === b)); } const ort = (s) => (EKSEN.reduce((a, e) => a + toplam(s, e), 0) / (VARLIK.length * 3)).toFixed(1); yaz(D, "ortalama puan", ort(son), ort(kir), "-"); ``` ``` 8 varlik x 3 eksen, 6 karar; puan araligi 0..10 (giz gizlilik, but butunluk, eri erisilebilirlik) 1. taban puan ve alti karar uygulandiktan sonraki puan varlik giz but eri giz' but' eri' okuma-verisi 4 5 6 4 5 10 fatura-kaydi 5 6 5 5 9 9 is-emri-kuyrugu 3 5 7 0 5 10 kimlik-deposu 6 6 5 10 7 2 yapilandirma 4 6 6 5 8 7 denetim-gunlugu 5 4 5 7 9 6 sayac-urun-yazilimi 3 7 6 3 10 4 saha-uygulamasi 4 5 7 7 10 3 toplam 34 44 47 41 63 51 2. karar basina kac (kalem, eksen) cifti yukseliyor, kaci dusuyor karar kalem yukselen dusen net en kotu eksen duragan-sifreleme 4 4 4 +12 eri -1 gecelik-yedek 5 10 5 +10 giz -2 eklemeli-gunluk 2 2 2 +6 eri -1 cok-etmenli-giris 3 6 3 +6 eri -2 imzali-urun-yazilimi 2 2 2 +4 eri -2 ikinci-kopya 3 3 6 0 giz -2 TOPLAM 19 27 22 +38 - 3. kirilma kosulu gerceklesince (erisilebilirlik sifirlanir) kosul giz toplam but toplam eri toplam eri = 0 kalem kirilma yok 41 63 51 0/8 anahtar-kaybi 41 63 24 4/8 etmen-kaybi 41 63 39 3/8 ikisi birden 41 63 14 6/8 4. varlik basina en dusuk eksen (kirilma yok, sonra anahtar kaybi) varlik en dusuk kirilinca eksen okuma-verisi 4 0 eri fatura-kaydi 5 0 eri is-emri-kuyrugu 0 0 giz kimlik-deposu 2 0 eri yapilandirma 5 5 giz denetim-gunlugu 6 0 eri sayac-urun-yazilimi 3 3 giz saha-uygulamasi 3 3 eri ortalama puan 6.5 5.3 - ``` Sayılar **ölçüm** sınıfındadır; girdileri GK1–GK5'tir. #### Bir Karar İki Yöne Birden Çalışır İkinci tablo altı kararı tek ölçüye indirir: her karar kaç (kalem, eksen) çiftini yükseltiyor, kaçını düşürüyor. Toplamda **27 çift yükselir, 22 çift düşer.** Altı kararın hiçbiri yalnız yükseltmez; en yüksek net değeri olan durağan şifreleme bile dokunduğu dört kalemin erişilebilirliğini birer puan indirir. Birinci tablonun `okuma-verisi` satırı bu bastırmanın en açık biçimidir. Gizlilik puanı 4'ten başlar, şifreleme onu 8'e çıkarır, gecelik yedek 6'ya, ikinci kopya 4'e indirir. **Kalem şifrelenmiştir ve gizlilik puanı tam olarak başladığı yerdedir.** Neden açıktır: şifreleme veriyi bir yerde korurken, yedek ve kopya aynı veriyi iki yerde daha çoğaltır. Aynı satırın erişilebilirliği 6'dan 10'a çıkar — kazanç gerçektir, ama gizlilik ekseninde ödenmiştir. `is-emri-kuyrugu` satırı sınırın işlediği yerdir: gizlilik 3'ten başlar, iki karar ikişer puan alır ve puan 0'da durur. Bir eksen tabana oturduğunda o eksende ödenecek bir şey kalmaz; sonraki karar aynı bedeli **başka bir kalemden** almaya başlar. Ters uç `kimlik-deposu`dur: gizlilik 6'dan 10'a, yani tavana çıkar, karşılığında erişilebilirlik 5'ten 2'ye iner. Tavana dayanmış bir eksen, o kalem üzerinde daha fazla gizlilik kararı almanın **yalnız erişilebilirlik maliyeti ürettiği** anlamına gelir. #### Net Sıfır Olan Bir Karar `ikinci-kopya` satırı ikinci tablonun en öğretici kalemidir: net değeri **tam olarak sıfırdır**. Üç kaleme dokunur, üç çifti yükseltir, altı çifti düşürür. Erişilebilirlikte kalem başına üç puan kazandırır (toplam +9), gizlilikte ikişer (−6), bütünlükte birer (−3) puan kaybettirir. Toplamı tek sayıya indiren bir okuma bu kararı "etkisiz" sayar ve gündemden düşürür. Oysa kararın anlamı toplamında değil, dağılımındadır. Aynı satırda üç ayrı soru vardır: kopya bir arıza durumunda okumaların ulaşılabilir kalmasını sağlar; aynı kopya veriyi bir yerde daha görünür kılar; kopyalar arasında geçici tutarsızlık bütünlüğü zayıflatır. Bu üçü birbirini sadeleştirmez, çünkü **farklı olaylarda ödenirler**. Net sıfır, üç ayrı riskin birbirini götürdüğü anlamına gelmez; üç ayrı defterin tek satırda toplandığı anlamına gelir. Aynı ölçü karşılaştırma için de işler. `gecelik-yedek` on çift yükseltip beş çift düşürür ve net +10 yazar; `duragan-sifreleme` dört yükseltip dört düşürür ve net +12 yazar. Çift sayısına bakıldığında yedek daha geniş, net değere bakıldığında şifreleme daha derindir. İkisi karşılaştırılabilir değildir; **hangi eksende ölçüldüğü söylenmeden bir savunmanın "daha iyi" olduğu söylenemez.** #### Her Varlığın Baskın Ekseni Ayrıdır Birinci tablonun son sütunları üçüncü bir okuma daha verir: aynı kararlar uygulandığında sekiz varlık üç eksende **aynı yere gelmez**. `sayac-urun-yazilimi` bütünlükte 10, erişilebilirlikte 4'tür; `is-emri-kuyrugu` erişilebilirlikte 10, gizlilikte 0. Bu iki kalem aynı ağın parçasıdır ve aynı karar kümesinden geçmiştir, ama biri bütünlük, öteki erişilebilirlik yönünde toplanmıştır. Fark rastlantı değildir, kalemin işlevinden gelir. Sayaç ürün yazılımı sahadaki aygıtta koşar: üstünde yanlış bir sürümün çalışması bütün okumaları bozar, birkaç saat güncellenememesi ise hiçbir okumayı bozmaz. İş emri kuyruğu ters yöndedir: içindeki kaydın kim tarafından görüldüğü düşük bir bedeldir, kuyruğun durması ise saha ekiplerini bekletir. Aynı üç eksen, iki kalemde iki ayrı sıralamaya girer. Bunun pratik sonucu, tek bir güvenlik hedefinin bütün envanterde geçerli olamayacağıdır. "Gizlilik önce gelir" kuralı `is-emri-kuyrugu` için zaten tabana oturmuştur ve orada uygulanacak bir şey kalmamıştır; aynı kural `kimlik-deposu`nda tavana dayanmış ve yalnız erişilebilirlik maliyeti üretmeye başlamıştır. **Eksen sıralaması varlık başına belirlenir**, kurum başına değil — ve bu ders boyunca sayılan puanlar, o sıralamanın hangi kalemde nereye oturduğunu gösteren tek kayıttır. #### Kırılma Bir Ekseni Sıfırlar Üçüncü tablo kararların kırılma koşullarını çalıştırır. Şifreleme anahtarı kaybolduğunda gizlilik toplamı 41'de kalır — hatta korunmuş sayılır, çünkü veriyi kimse okuyamaz. Aynı anda erişilebilirlik toplamı **51'den 24'e** iner ve sekiz varlığın **dördü sıfırlanır**. Çok etmenli girişin etmen aygıtı kaybolduğunda erişilebilirlik 39'a iner, üç kalem sıfırlanır. İki koşul birlikte gerçekleştiğinde toplam 14'tür ve sekiz kalemin altısına ulaşılamaz. Bu satırların ortak yanı, gizlilik ve bütünlük sütunlarının **hiç değişmemesidir**. Kırılan savunma kendi ekseninde bozulmaz; verdiği sözü fazlasıyla tutar. Bedel bütünüyle üçüncü eksene yazılır. Erişilebilirliği bir güvenlik ekseni saymayan bir okuma, bu tabloda hiçbir sorun görmez — çünkü baktığı iki sütun sabittir. #### Ortalama Neyi Saklar Dördüncü tablo aynı durumu varlık başına okur ve tek bir sayının nasıl yanılttığını gösterir. Anahtar kaybında sekiz varlığın dördü en düşük eksende sıfıra iner. Aynı anda **ortalama puan yalnız 6,5'ten 5,3'e düşer.** Yirmi dört hücreden dördü sıfırlanmıştır ve tek sayıya bakan bir gösterge bunu bir puanlık gerileme olarak yazar. Nedeni tablodaki dağılımdır: sıfırlanan kalemlerin öteki iki ekseni yüksek kaldığı için ortalamayı yukarıda tutarlar. `okuma-verisi` gizlilikte 4, bütünlükte 5, erişilebilirlikte 0'dır; ortalaması 3'tür ve "orta" görünür. Oysa o kaleme ulaşılamıyorsa gizlilik puanının pratik bir karşılığı yoktur. **Üç eksen toplanabilir değildir; en düşük eksen kalemin gerçek durumunu belirler.** Tablodaki iki satır bunun sınırını da gösterir: `yapilandirma` ve `sayac-urun-yazilimi` anahtar kaybından hiç etkilenmez, çünkü şifreleme kararının dokunduğu kalemler arasında değildirler. Bir kırılmanın kapsamı, kırılan savunmanın **dokunduğu kalem kümesidir** — daha geniş değil. Bu ders boyunca sayılan her şey bu kümelerin üzerinde durur ve sonraki dersler aynı kümeye başka adlar verecektir. #### Özet - Üç eksen aynı varlığın üstünde çakışır: sekiz varlık ve altı kararlık modelde 27 (kalem, eksen) çifti yükselirken 22 çift düşer; altı kararın hiçbiri tek yönlü değildir. - Şifrelenen `okuma-verisi` kaleminin gizlilik puanı 4'ten çıkıp 4'e döner, çünkü yedek ve ikinci kopya aynı veriyi çoğaltır; erişilebilirliği ise 6'dan 10'a çıkar. - Net etkisi sıfır olan `ikinci-kopya` kararı erişilebilirlikte +9, gizlilikte −6, bütünlükte −3 puan yazar; toplam tek satıra indirildiğinde üç ayrı defter görünmez olur. - Anahtar kaybında gizlilik ve bütünlük toplamları hiç değişmez, erişilebilirlik 51'den 24'e iner ve sekiz varlığın dördü sıfırlanır; iki kırılma birlikte 14 ve altı kalem yazar. - Aynı sıfırlanma ortalamada yalnız 6,5'ten 5,3'e düşüş olarak görünür; kalemin durumunu ortalama değil **en düşük eksen** belirler. - Bir kırılmanın kapsamı, kırılan kararın dokunduğu kalem kümesidir; iki varlık anahtar kaybından hiç etkilenmez. #### Sonraki Adım Bu ders sekiz kalemi puanladı ve altı kararın bu puanları hangi yönde değiştirdiğini saydı. Ancak bütün hesap tek bir listenin üstünde koştu ve o listenin adı belirsiz kaldı: "varlık" denen şey neydi, kararların karşı koyduğu şeyin adı neydi, puanı düşüren şeyin kendisine ne deniyordu. Sonraki ders aynı envanteri üç ayrı listeye böler — **varlık**, **tehdit** ve **açık** — ve bu üçünün çarpımının neden ulaşılabilecek yol sayısını vermediğini gösterir. ### Varlık, Tehdit ve Açık Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/varlik-tehdit-ve-acik Üç terimin aynı envanterde ayrılması: 8 varlık, 6 tehdit ve 12 açığın kartezyen çarpımı 576 iken geçerli üçlü sayısının 19'a, yani %3,3'e inmesi, ikişer açık taşıyan iki varlığın 1 ve 4 üçlü üretmesi, hiçbir tehdidin ulaşamadığı bir açığın sıfır üçlü taşıması, aynı beş üçlüyü taşıyan iki tehdidin 4 ve 5 ayrı varlığa dokunması, on iki açıktan beşinin kapatılmasının 19 üçlünün 12'sini kapatması ve bir varlığın bölgesini daraltmanın 3, 2, 1 ya da hiç üçlü kapatmaması. Önceki ders sekiz kalemi puanladı ve altı kararın bu puanları hangi yönde değiştirdiğini saydı. Bütün hesap tek bir listenin üstünde koştu ve o listenin parçalarının adı belirsiz kaldı: korunan şeye "varlık" dendi, ama puanı düşürecek olan neydi, düşmesine izin veren şey neydi. Bu ders aynı envanteri üç ayrı listeye böler ve üçünün nasıl birleştiğini sayar. **Varlık (asset)** korunan şeydir: veri, servis, aygıt, kayıt. **Tehdit (threat)** zarar verebilecek etkendir; bunu yapabilecek taraf **tehdit aktörü (threat actor)** olarak anılır. **Açık (vulnerability)** varlıktaki, o zararın gerçekleşmesine izin veren zayıflıktır. Üçü ayrı listedir ve ayrı sayılır. Günlük konuşmada birbirinin yerine kullanılırlar; sayıldıklarında birbirinin yerine geçmedikleri görülür. #### Üç Liste Üç Ayrı Soruya Karşılık Gelir Örnek yine kurgu **bölgesel ölçüm ağı**dır ve varlık listesi bir önceki dersle aynı sekiz kalemdir. Aşağıdaki envanter bir **modeldir**: gerçek bir ağ, gerçek bir tehdit kaydı ya da gerçek bir açık listesi yoktur. **GK6:** her varlık, dışarıdan ulaşılabildiği en geniş bölgeyle anılır — `dis`, `saha`, `ic`. **GK7:** her açık tek bir varlıkta bulunur ve bir tür taşır. **GK8:** her tehdit, ulaşabildiği bölge kümesi ve kullanabildiği açık türleriyle tanımlanır. **GK9:** bir `(varlık, açık, tehdit)` üçlüsü ancak üç koşul birlikte sağlanırsa geçerlidir — açık o varlıkta bulunur, tehdit o bölgeye ulaşır, tehdit o açık türünü kullanabilir. ```js // guvenlik/envanter.mjs — kurgu olcum aginin varlik, tehdit ve acik envanteri (model): gercek bir // ag, gercek bir tehdit kaydi ya da gercek bir acik listesi yok. Rastgelelik yok. // GK6: her varlik, disaridan ulasilabildigi en genis bolgeyle anilir (dis, saha, ic). export const VARLIK = ` okuma-verisi ic fatura-kaydi dis is-emri-kuyrugu saha kimlik-deposu ic yapilandirma ic denetim-gunlugu ic sayac-urun-yazilimi saha saha-uygulamasi dis` .trim().split("\n").map((r) => { const [ad, bolge] = r.trim().split(/\s+/); return { ad, bolge }; }); // GK7: her acik tek bir varlikta bulunur ve bir tur tasir. export const ACIK = ` eski-surum-kitapligi fatura-kaydi surum varsayilan-parola yapilandirma kimlik genis-okuma-yetkisi okuma-verisi yetki dogrulanmayan-girdi saha-uygulamasi girdi acik-yonetim-ucu yapilandirma yapilandirma imzasiz-guncelleme sayac-urun-yazilimi butunluk paylasilan-hesap kimlik-deposu kimlik sifresiz-aktarim is-emri-kuyrugu aktarim tutulmayan-gunluk denetim-gunlugu gorunurluk eski-surum-etmen saha-uygulamasi surum fiziksel-erisim-noktasi sayac-urun-yazilimi fiziksel dogrulanmayan-alan denetim-gunlugu girdi` .trim().split("\n").map((r) => { const [ad, varlik, tur] = r.trim().split(/\s+/); return { ad, varlik, tur, bolge: VARLIK.find((v) => v.ad === varlik).bolge }; }); // GK8: her tehdit, ulasabildigi bolge kumesi ve kullanabildigi acik turleriyle tanimlanir. export const TEHDIT = [ { ad: "dis-firsatci", bolge: ["dis"], tur: ["surum", "kimlik", "girdi", "yapilandirma"] }, { ad: "hedefli-dis", bolge: ["dis", "saha"], tur: ["surum", "kimlik", "girdi", "yapilandirma", "aktarim", "butunluk"] }, { ad: "saha-yakini", bolge: ["saha"], tur: ["fiziksel", "butunluk", "aktarim"] }, { ad: "ic-kullanici-hatasi", bolge: ["ic", "saha"], tur: ["yapilandirma", "yetki"] }, { ad: "kotu-niyetli-ic", bolge: ["ic", "saha", "dis"], tur: ["yetki", "kimlik", "gorunurluk", "aktarim"] }, { ad: "tedarik-zinciri", bolge: ["saha", "ic"], tur: ["butunluk", "surum"] }, ]; // GK9: uclu ancak acik o varlikta bulunuyorsa, tehdit o bolgeye ulasabiliyorsa ve o acik // turunu kullanabiliyorsa gecerlidir. export const gecerli = (a, t) => t.bolge.includes(a.bolge) && t.tur.includes(a.tur); export const UCLU = ACIK.flatMap((a) => TEHDIT.filter((t) => gecerli(a, t)) .map((t) => ({ varlik: a.varlik, acik: a.ad, tehdit: t.ad }))); export const acikSay = (v) => ACIK.filter((a) => a.varlik === v).length; export const ucluSay = (alan, ad) => UCLU.filter((u) => u[alan] === ad).length; // GK10: bir varligin bolgesi bir kademe daraltilabilir (dis -> saha -> ic); daraltma // o varliktaki aciklarin ulasilabilirligini degistirir, aciklari kapatmaz. export const DAR = { dis: "saha", saha: "ic", ic: "ic" }; export function darUclu(ad) { return ACIK.reduce((n, a) => n + TEHDIT.filter((t) => t.bolge.includes(a.varlik === ad ? DAR[a.bolge] : a.bolge) && t.tur.includes(a.tur)).length, 0); } ``` ```js // guvenlik/say.mjs — uc liste ayni envanterde: kac varlik, kac tehdit, kac acik, kac gecerli uclu. import { VARLIK, ACIK, TEHDIT, UCLU, DAR, acikSay, ucluSay, darUclu } from "./envanter.mjs"; const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const kartezyen = VARLIK.length * TEHDIT.length * ACIK.length; console.log(`${VARLIK.length} varlik, ${TEHDIT.length} tehdit, ${ACIK.length} acik; ` + `kartezyen carpim ${kartezyen}, acik zaten bir varliga bagli oldugundan aday ` + `${ACIK.length * TEHDIT.length}, gecerli uclu ${UCLU.length}`); const A = [-21, 8, 8, 8, 10]; console.log("\n1. varlik basina acik ve gecerli uclu"); yaz(A, "varlik", "bolge", "acik", "uclu", "uclu/acik"); for (const v of VARLIK) yaz(A, v.ad, v.bolge, acikSay(v.ad), ucluSay("varlik", v.ad), acikSay(v.ad) ? (ucluSay("varlik", v.ad) / acikSay(v.ad)).toFixed(1) : "-"); yaz(A, "toplam", "-", ACIK.length, UCLU.length, (UCLU.length / ACIK.length).toFixed(1)); const B = [-25, 14, 8, 7]; console.log("\n2. acik basina kac tehdit kullanabiliyor"); yaz(B, "acik", "tur", "bolge", "uclu"); for (const a of [...ACIK].sort((x, y) => ucluSay("acik", y.ad) - ucluSay("acik", x.ad))) yaz(B, a.ad, a.tur, a.bolge, ucluSay("acik", a.ad)); const C = [-21, 8, 7, 7, 10]; console.log("\n3. tehdit basina erisim ve kullanim"); yaz(C, "tehdit", "bolge", "tur", "uclu", "varlik"); for (const t of TEHDIT) yaz(C, t.ad, t.bolge.length, t.tur.length, ucluSay("tehdit", t.ad), new Set(UCLU.filter((u) => u.tehdit === t.ad).map((u) => u.varlik)).size); const D = [-38, 9, 9]; console.log("\n4. carpim nerede daraliyor"); yaz(D, "adim", "aday", "kalan %"); const yuzde = (n) => ((n / kartezyen) * 100).toFixed(1); for (const [ad, n] of [["varlik x tehdit x acik", kartezyen], ["acik zaten bir varlikta (acik x tehdit)", ACIK.length * TEHDIT.length], ["tehdit o bolgeye ulasabiliyor", ACIK.reduce((a, x) => a + TEHDIT.filter((t) => t.bolge.includes(x.bolge)).length, 0)], ["tehdit o acik turunu kullanabiliyor", UCLU.length]]) yaz(D, ad, n, yuzde(n)); const sirali = [...ACIK].map((a) => ucluSay("acik", a.ad)).sort((x, y) => y - x); const birikim = sirali.map(((s) => (n) => (s += n))(0)); console.log(`\nen cok uclu tasiyan acik sirasi: ${sirali.join(" ")}`); console.log(`kapatma birikimi: ${birikim.join(" ")} (12 acigin 5'i ${birikim[4]}/${UCLU.length}` + ` ucluyu kapatir); hic uclu tasimayan acik: ` + ACIK.filter((a) => ucluSay("acik", a.ad) === 0).map((a) => a.ad).join(", ")); const E = [-21, 8, 9, 9, 9]; console.log("\n5. bir varligin bolgesi bir kademe daraltilirsa (acik sayisi degismez)"); yaz(E, "varlik", "bolge", "yeni", "uclu", "kapanan"); for (const v of VARLIK) yaz(E, v.ad, v.bolge, DAR[v.bolge], darUclu(v.ad), UCLU.length - darUclu(v.ad)); ``` ``` 8 varlik, 6 tehdit, 12 acik; kartezyen carpim 576, acik zaten bir varliga bagli oldugundan aday 72, gecerli uclu 19 1. varlik basina acik ve gecerli uclu varlik bolge acik uclu uclu/acik okuma-verisi ic 1 2 2.0 fatura-kaydi dis 1 2 2.0 is-emri-kuyrugu saha 1 3 3.0 kimlik-deposu ic 1 1 1.0 yapilandirma ic 2 2 1.0 denetim-gunlugu ic 2 1 0.5 sayac-urun-yazilimi saha 2 4 2.0 saha-uygulamasi dis 2 4 2.0 toplam - 12 19 1.6 2. acik basina kac tehdit kullanabiliyor acik tur bolge uclu imzasiz-guncelleme butunluk saha 3 sifresiz-aktarim aktarim saha 3 eski-surum-kitapligi surum dis 2 genis-okuma-yetkisi yetki ic 2 dogrulanmayan-girdi girdi dis 2 eski-surum-etmen surum dis 2 varsayilan-parola kimlik ic 1 acik-yonetim-ucu yapilandirma ic 1 paylasilan-hesap kimlik ic 1 tutulmayan-gunluk gorunurluk ic 1 fiziksel-erisim-noktasi fiziksel saha 1 dogrulanmayan-alan girdi ic 0 3. tehdit basina erisim ve kullanim tehdit bolge tur uclu varlik dis-firsatci 1 4 3 2 hedefli-dis 2 6 5 4 saha-yakini 1 3 3 2 ic-kullanici-hatasi 2 2 2 2 kotu-niyetli-ic 3 4 5 5 tedarik-zinciri 2 2 1 1 4. carpim nerede daraliyor adim aday kalan % varlik x tehdit x acik 576 100.0 acik zaten bir varlikta (acik x tehdit) 72 12.5 tehdit o bolgeye ulasabiliyor 42 7.3 tehdit o acik turunu kullanabiliyor 19 3.3 en cok uclu tasiyan acik sirasi: 3 3 2 2 2 2 1 1 1 1 1 0 kapatma birikimi: 3 6 8 10 12 14 15 16 17 18 19 19 (12 acigin 5'i 12/19 ucluyu kapatir); hic uclu tasimayan acik: dogrulanmayan-alan 5. bir varligin bolgesi bir kademe daraltilirsa (acik sayisi degismez) varlik bolge yeni uclu kapanan okuma-verisi ic ic 19 0 fatura-kaydi dis saha 19 0 is-emri-kuyrugu saha ic 17 2 kimlik-deposu ic ic 19 0 yapilandirma ic ic 19 0 denetim-gunlugu ic ic 19 0 sayac-urun-yazilimi saha ic 16 3 saha-uygulamasi dis saha 18 1 ``` Sayılar **ölçüm** sınıfındadır; girdileri GK6–GK9'dur. #### Çarpım Yol Sayısı Değildir Dördüncü tablo bu dersin ana bulgusudur. Üç listenin uzunluğu çarpıldığında 576 çıkar. Bu sayı hiçbir şeyi ölçmez, çünkü listeler bağımsız değildir. İlk daralma tanım gereğidir: her açık zaten tek bir varlıkta bulunur, o yüzden varlık boyutu ayrı bir çarpan değildir — 72 aday kalır, yani çarpımın **%12,5'i**. İkinci daralma erişimden gelir: tehdidin açığın bulunduğu bölgeye ulaşması gerekir, aday 42'ye iner. Üçüncüsü yetenektendir: tehdit o açık türünü kullanabilmelidir, geriye **19 üçlü**, yani başlangıçtaki çarpımın **%3,3'ü** kalır. Aradaki fark ölçek farkı değil, tür farkıdır. "Sekiz varlığımız, altı tehdit türümüz ve on iki açığımız var" cümlesi bir envanterdir; kaç yerden ne olabileceğini söylemez. Üçünü çarpmak bir korku sayısı üretir. Gerçekte sayılabilir olan, üçünün **kesiştiği** yerdir ve o kesişim iki koşulla daralır: erişim ve yetenek. Yine de 19 sayısı **hâlâ bir yol sayısı değildir**. Her üçlü, tehdidin varlığa doğrudan dokunabildiğini varsayar; bölge bir etiket olarak verilmiştir, geçilecek bir kapı olarak sayılmamıştır. Gerçekte `ic` bölgedeki bir varlığa ulaşmak, önce başka varlıkların üstünden geçmeyi gerektirir ve o geçişlerin her biri ayrı bir adımdır. Bu dersin bıraktığı sayı bir **kesişim sayısıdır**; yol sayımı bu konunun son dersinde yapılacaktır. #### Aynı Sayıda Açık, Dört Kat Fark Birinci tablo açık sayısının tek başına neden bir gösterge olmadığını gösterir. `denetim-gunlugu` ve `saha-uygulamasi` ikisi de **ikişer açık** taşır. Birincisi 1 üçlü üretir, ikincisi 4. Üçlü başına oran 0,5'e karşı 2,0'dır — aynı açık sayısında **dört kat fark**. Farkın kaynağı ikinci tabloda görülür. `saha-uygulamasi` `dis` bölgededir ve açıkları `girdi` ile `surum` türündedir; dış bölgeye ulaşan üç tehdidin ikisi bu türleri kullanabilir. `denetim-gunlugu` `ic` bölgededir ve açıkları `gorunurluk` ile `girdi` türündedir; iç bölgeye ulaşan üç tehditten yalnız biri `gorunurluk` kullanır, `girdi` türünü hiçbiri kullanmaz. Son satır bu dersin en keskin kalemidir: `dogrulanmayan-alan` açığı **sıfır üçlü** taşır. Açık gerçektir, listede durur, denetimde işaretlenir — ama ona ulaşabilen ve onu kullanabilen bir tehdit yoktur. Bu, açığın kapatılmaması gerektiği anlamına gelmez; bölge sınırı değişirse üçlü sayısı sıfır olmaktan çıkar. Anlamı şudur: **açık sayısı bir maruziyet ölçüsü değildir.** On iki açığın biri hiçbir şeye açık değildir ve bir başkası üçüne birden. #### Tehdidin İki Ayrı Genişliği Üçüncü tablo tehditleri iki eksende ölçer: kaç bölgeye ulaşıyor ve kaç açık türünü kullanabiliyor. `hedefli-dis` iki bölgeye ulaşır ama altı tür kullanır; `kotu-niyetli-ic` üç bölgeye ulaşır ve dört tür kullanır. İkisi de **beş üçlü** üretir — aynı sayı, iki ayrı yoldan. Fark son sütundadır: `hedefli-dis` dört ayrı varlığa dokunur, `kotu-niyetli-ic` beşine. Erişim genişliği ile yetenek genişliği toplamda aynı üçlü sayısını verse de **yayılımı farklıdır**. Yetenek genişliği aynı varlıkta birden çok açığı kullanılabilir kılar; erişim genişliği daha çok varlığa dokunur. Bir savunma kararı bu ikisinden hangisini daralttığını bilmeden yazılamaz. `tedarik-zinciri` ters uçtadır: iki bölgeye ulaşır, iki tür kullanır, tek üçlü üretir ve tek varlığa dokunur. Bu satır tehdit listesinin uzunluğunun da bir gösterge olmadığını yazar — altı tehditten biri envanterin **on dokuzda birini** taşır. Son iki satır kapatmanın getirisini sıralar. On iki açık, üçlü sayısına göre sıralandığında `3 3 2 2 2 2 1 1 1 1 1 0` dizisi çıkar. En çok taşıyan beş açığı kapatmak 19 üçlünün **12'sini** kapatır; kalan yedi üçlü için yedi ayrı açık daha kapatmak gerekir ve on ikincisi hiçbir şey eklemez. Kapatma sırası açık sayısına göre değil, **taşınan üçlü sayısına** göre kurulur. #### Üç Listeden Hangisi Elde Beşinci tablo üçüncü bir kaldıraç dener. Açık kapatmak bir listeyi kısaltır; tehdit listesi kısaltılamaz, çünkü kimin ne yapabileceği kurumun kararı değildir. Geriye **erişim** kalır: bir varlığın bölgesini bir kademe daraltmak, açıklarının hiçbirini kapatmadan onlara ulaşabilen tehdit kümesini değiştirir. Sonuçlar dört ayrı davranış gösterir. `sayac-urun-yazilimi` `saha`dan `ic`e çekildiğinde 3 üçlü kapanır — bu, tek bir açığı kapatmanın en yüksek getirisine eşittir ve iki açık da yerinde durur. `is-emri-kuyrugu` 2, `saha-uygulamasi` 1 üçlü kapatır. Zaten `ic` bölgede olan dört varlıkta daraltacak bir kademe kalmamıştır ve kapanan üçlü sıfırdır. İkinci satır tablonun en öğretici kalemidir: `fatura-kaydi` `dis`ten `saha`ya çekildiğinde kapanan üçlü **sıfırdır**. Kalem daha dar bir bölgeye taşınmıştır, ama üstündeki `surum` türü açığı hem dış bölgeye ulaşan bir tehdit hem de saha bölgesine ulaşan bir başkası kullanabilir; kapanan bir üçlünün yerine bir yenisi açılır. **Daraltmanın getirisi kalemin ne kadar gizlendiğine değil, hangi tehdit kümesinin dışarıda kaldığına bağlıdır.** Üç kaldıraç bu yüzden aynı şey değildir: açık kapatmak listeden bir satır siler, bölge daraltmak aynı satırı yerinde bırakıp ona ulaşan tehdit kümesini değiştirir, tehdit listesi ise elde değildir. Bu dersin sayabildiği son şey budur; ikinci kaldıracın gerçek ölçüsü, bölgeler arasında kaç adım olduğu bilinmeden verilemez. #### Özet - Varlık korunan şey, tehdit zarar verebilecek etken, açık ise varlıktaki zayıflıktır; üçü ayrı listedir ve ayrı sayılır. - Sekiz varlık, altı tehdit ve on iki açığın çarpımı 576'dır; geçerli üçlü 19, yani çarpımın %3,3'üdür. Daralma iki koşuldan gelir: tehdit o bölgeye ulaşıyor mu, o açık türünü kullanıyor mu. - On dokuz üçlü hâlâ bir yol sayısı değildir; her üçlü tehdidin varlığa doğrudan dokunduğunu varsayar ve bölgeler arası geçişleri adım olarak saymaz. - İkişer açık taşıyan iki varlık 1 ve 4 üçlü üretir; bir açık sıfır üçlü taşır, bir başkası üç. Açık sayısı tek başına bir maruziyet ölçüsü değildir. - Beş üçlü üreten iki tehditten biri dört, öteki beş varlığa dokunur; erişim genişliği ile yetenek genişliği aynı toplamda farklı yayılım verir. - Bir varlığın bölgesini bir kademe daraltmak hiçbir açığı kapatmadan 3, 2, 1 ya da 0 üçlü kapatır; dar bölgeye başka tehditler ulaştığında getiri sıfır kalır. #### Sonraki Adım Bu ders on dokuz üçlüyü saydı ve hepsini eşit ağırlıkta yazdı. Oysa `fiziksel-erisim-noktasi` üzerinden gelen tek üçlü ile `sifresiz-aktarim` üzerinden gelen üç üçlü ne aynı sıklıkta gerçekleşir ne de gerçekleştiğinde aynı şeye mal olur. Kapatma sırası bu derste yalnız taşınan üçlü sayısına göre kuruldu; oysa az taşıyan bir kalem çok daha ağır olabilir. Sonraki ders bu iki boyutu — **olasılık** ve **etki** — bir kalem kümesi üzerinde birleştirir ve iki farklı puanlamanın aynı listeyi nasıl farklı sıraladığını gösterir. ### Risk Tanımı Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/risk-tanimi Riskin olasılık ile etkinin bileşimi olarak hesaplanması: 12 kalemlik listede toplam beklenen kaybın 176,05 kurgu birim çıkması, bantlı puanlamanın aynı listede 9 kalemin sırasını değiştirip en büyük kaymayı 6 basamağa taşıması ve ilk beşin yalnız 2'sini ortak bırakması, eşik puanlamasında bu sayıların 7, 4 ve 4 olması, dört kalemlik bütçenin üç puanlamada 77,00, 67,60 ve 71,40 birim kapatması ve aynı 18,00 beklenen kaybı taşıyan iki kalemin on yılda 4,0 ve 0,3 olay üretmesi. Önceki ders on dokuz üçlüyü saydı ve hepsini eşit ağırlıkta yazdı. Kapatma sırası yalnız taşınan üçlü sayısına göre kurulmuştu; oysa bir kalemin ne sıklıkta gerçekleştiği ve gerçekleştiğinde neye mal olduğu o sayının içinde yoktu. Bu ders o iki boyutu ekler ve listeyi sıraya sokar. **Risk**, bir olayın **olasılığı** ile **etkisinin** bileşimidir. En sade biçimiyle risk = olasılık × etki yazılır ve çıkan sayıya **beklenen kayıp** denir. Açık bir listedir, risk bir sayıdır; ikisi karıştırıldığında sıfır olasılıklı bir açık ile sık gerçekleşen bir kalem aynı satıra yazılır. Bu dersin gösterdiği şey, bileşimin **tek bir biçimi olmadığıdır**: aynı iki girdiden üç ayrı sıralama çıkar ve sıralama seçimi bütçenin nereye gideceğini belirler. #### Risk Bir Çarpımdır Kalemler önceki dersin açık listesidir. Aşağıdaki olasılık ve etki değerleri bir **modeldir**: gerçek bir olay kaydı, gerçek bir olasılık kestirimi ya da gerçek bir para birimi yoktur. Etki **kurgu birim** cinsindendir. **GK11:** her kalem bir olasılık ve bir etkiyle anılır; olasılık bir yıllık pencerede gerçekleşme olasılığı, etki kurgu birim cinsinden kayıptır. **GK12:** beklenen kayıp olasılık ile etkinin çarpımıdır. **GK13:** bantlı puanlama olasılığı ve etkiyi 1–5 arası bir banda indirir ve iki bandı çarpar. **GK14:** eşik puanlaması etkisi 100 kurgu birim ve üstü olan kalemleri öne alır, kendi içinde beklenen kayba göre sıralar. **GK15:** bütçe bir turda dört kalem ele alır. Eşitlikte liste sırası bozulmaz. ```js // guvenlik/risk.mjs — kurgu olcum aginin risk kalemleri (model): gercek bir olay kaydi, gercek // bir olasilik kestirimi ya da gercek para birimi yok. Etki "kurgu birim" cinsindendir. // GK11: kalemler onceki dersin acik listesidir; olasilik bir yillik pencerede gerceklesme // olasiligi, etki kurgu birim cinsinden kayiptir. export const KALEM = ` eski-surum-kitapligi 0.40 45 varsayilan-parola 0.60 28 genis-okuma-yetkisi 0.18 110 dogrulanmayan-girdi 0.50 40 acik-yonetim-ucu 0.12 160 imzasiz-guncelleme 0.03 600 paylasilan-hesap 0.45 30 sifresiz-aktarim 0.25 55 tutulmayan-gunluk 0.70 14 eski-surum-etmen 0.55 20 fiziksel-erisim-noktasi 0.06 240 dogrulanmayan-alan 0.02 90` .trim().split("\n").map((r, i) => { const [ad, o, e] = r.trim().split(/\s+/); return { i, ad, o: +o, e: +e, beklenen: +(+o * +e).toFixed(2) }; }); // GK13: bantli puanlama olasiligi ve etkiyi 1..5 bandina indirir ve bantlari carpar. const bant = (x, sinir) => sinir.findIndex((s) => x < s) + 1 || sinir.length + 1; export const oBant = (k) => bant(k.o, [0.05, 0.15, 0.30, 0.50]); export const eBant = (k) => bant(k.e, [20, 50, 100, 200]); export const bantPuan = (k) => oBant(k) * eBant(k); // GK14: esik puanlamasi etkisi 100 kurgu birim ve ustu olan kalemleri one alir. export const ESIK = 100; // Siralamalar: esitlikte liste sirasi bozulmaz (kararli siralama). export const SIRA = { A: [...KALEM].sort((x, y) => y.beklenen - x.beklenen || x.i - y.i), B: [...KALEM].sort((x, y) => bantPuan(y) - bantPuan(x) || x.i - y.i), C: [...KALEM].sort((x, y) => (y.e >= ESIK) - (x.e >= ESIK) || y.beklenen - x.beklenen || x.i - y.i), }; export const sira = (ad, k) => SIRA[ad].findIndex((x) => x.ad === k.ad) + 1; export const TOPLAM = +KALEM.reduce((a, k) => a + k.beklenen, 0).toFixed(2); ``` ```js // guvenlik/sirala.mjs — ayni kalem kumesi, uc puanlama: sira nasil degisiyor, butceye ne oluyor. import { KALEM, SIRA, ESIK, TOPLAM, oBant, eBant, bantPuan, sira } from "./risk.mjs"; const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const BUTCE = 4; // GK15: butce bir turda dort kalem ele alir console.log(`${KALEM.length} kalem; risk = olasilik x etki (kurgu birim). ` + `toplam beklenen kayip ${TOPLAM} birim; A beklenen kayip, B bantli carpim (1..5 x 1..5), ` + `C etkisi ${ESIK} ve ustu olani one alan esik`); const A = [-25, 7, 6, 10, 5, 8, 7, 5, 5, 5]; console.log("\n1. ayni kalemler, uc puanlama"); yaz(A, "kalem", "olasi", "etki", "beklenen", "o-b", "e-b", "bant", "A", "B", "C"); for (const k of KALEM) yaz(A, k.ad, k.o.toFixed(2), k.e, k.beklenen.toFixed(2), oBant(k), eBant(k), bantPuan(k), sira("A", k), sira("B", k), sira("C", k)); const B = [-30, 9, 9]; console.log("\n2. A ile karsilastirildiginda"); yaz(B, "olcu", "B", "C"); const kayma = (ad) => KALEM.map((k) => Math.abs(sira("A", k) - sira(ad, k))); const ilkBes = (ad) => SIRA[ad].slice(0, 5).filter((k) => SIRA.A.slice(0, 5).includes(k)).length; for (const [ad, f] of [["sirasi degisen kalem", (s) => kayma(s).filter((x) => x > 0).length], ["en buyuk sira kaymasi", (s) => Math.max(...kayma(s))], ["toplam mutlak kayma", (s) => kayma(s).reduce((a, x) => a + x, 0)], ["ilk besin kaci ortak", (s) => ilkBes(s) + "/5"]]) yaz(B, ad, f("B"), f("C")); const C = [-11, 26, 10, 9, 10]; console.log(`\n3. butce ${BUTCE} kalem: hangi puanlama neyi secer`); yaz(C, "puanlama", "secilenlerin A sirasi", "kapanan", "oran %", "kuyruk"); const enBuyuk = KALEM.reduce((a, k) => (k.e > a.e ? k : a)); for (const ad of ["A", "B", "C"]) { const sec = SIRA[ad].slice(0, BUTCE); const kap = +sec.reduce((a, k) => a + k.beklenen, 0).toFixed(2); yaz(C, ad, sec.map((k) => sira("A", k)).join(" "), kap.toFixed(2), ((kap / TOPLAM) * 100).toFixed(1), sec.includes(enBuyuk) ? "iceride" : "disarida"); } console.log(`kuyruk = en buyuk tek etki (${enBuyuk.ad}, ${enBuyuk.e} birim)`); const D = [-25, 9, 8, 11, 8]; console.log("\n4. ayni beklenen kayip, ayri karar"); yaz(D, "kalem", "olasi", "etki", "beklenen", "bant"); const esit = KALEM.filter((k) => KALEM.some((x) => x !== k && x.beklenen === k.beklenen)); for (const k of esit) yaz(D, k.ad, k.o.toFixed(2), k.e, k.beklenen.toFixed(2), bantPuan(k)); console.log(`on yilda beklenen toplam esittir; tek olayda kaybedilen ` + `${esit.map((k) => k.e).join(" ve ")} birimdir, on yilda beklenen olay sayisi ` + `${esit.map((k) => (k.o * 10).toFixed(1)).join(" ve ")}`); const birikim = SIRA.A.map(((s) => (k) => (((s += k.beklenen) / TOPLAM) * 100).toFixed(1))(0)); console.log(`\nA sirasinda birikimli kapsam (%): ${birikim.join(" ")}`); ``` ``` 12 kalem; risk = olasilik x etki (kurgu birim). toplam beklenen kayip 176.05 birim; A beklenen kayip, B bantli carpim (1..5 x 1..5), C etkisi 100 ve ustu olani one alan esik 1. ayni kalemler, uc puanlama kalem olasi etki beklenen o-b e-b bant A B C eski-surum-kitapligi 0.40 45 18.00 4 2 8 4 7 6 varsayilan-parola 0.60 28 16.80 5 2 10 6 2 7 genis-okuma-yetkisi 0.18 110 19.80 3 4 12 2 1 1 dogrulanmayan-girdi 0.50 40 20.00 5 2 10 1 3 5 acik-yonetim-ucu 0.12 160 19.20 2 4 8 3 8 2 imzasiz-guncelleme 0.03 600 18.00 1 5 5 5 10 3 paylasilan-hesap 0.45 30 13.50 4 2 8 9 9 9 sifresiz-aktarim 0.25 55 13.75 3 3 9 8 6 8 tutulmayan-gunluk 0.70 14 9.80 5 1 5 11 11 11 eski-surum-etmen 0.55 20 11.00 5 2 10 10 4 10 fiziksel-erisim-noktasi 0.06 240 14.40 2 5 10 7 5 4 dogrulanmayan-alan 0.02 90 1.80 1 3 3 12 12 12 2. A ile karsilastirildiginda olcu B C sirasi degisen kalem 9 7 en buyuk sira kaymasi 6 4 toplam mutlak kayma 30 14 ilk besin kaci ortak 2/5 4/5 3. butce 4 kalem: hangi puanlama neyi secer puanlama secilenlerin A sirasi kapanan oran % kuyruk A 1 2 3 4 77.00 43.7 disarida B 2 6 1 10 67.60 38.4 disarida C 2 3 5 7 71.40 40.6 iceride kuyruk = en buyuk tek etki (imzasiz-guncelleme, 600 birim) 4. ayni beklenen kayip, ayri karar kalem olasi etki beklenen bant eski-surum-kitapligi 0.40 45 18.00 8 imzasiz-guncelleme 0.03 600 18.00 5 on yilda beklenen toplam esittir; tek olayda kaybedilen 45 ve 600 birimdir, on yilda beklenen olay sayisi 4.0 ve 0.3 A sirasinda birikimli kapsam (%): 11.4 22.6 33.5 43.7 54.0 63.5 71.7 79.5 87.2 93.4 99.0 100.0 ``` Sayılar **ölçüm** sınıfındadır; girdileri GK11–GK15'tir. #### Aynı Liste, Üç Ayrı Sıra İkinci tablo bu dersin ana bulgusudur. Girdi değişmemiştir — aynı on iki kalem, aynı olasılık, aynı etki. Yalnız bileşim biçimi değişmiştir. Bantlı puanlama **dokuz kalemin sırasını değiştirir**, en büyük kayma **altı basamaktır** ve toplam mutlak kayma 30'dur. İlk beşin yalnız **ikisi** ortaktır. Eşik puanlaması daha ılımlıdır: yedi kalem yer değiştirir, en büyük kayma dört, ilk beşin dördü ortaktır. Birinci tablo kaymanın nereden geldiğini kalem kalem gösterir. `eski-surum-etmen` beklenen kayıp sıralamasında **onuncudur** (11,00 birim), bantlı sıralamada **dördüncü**. Nedeni bantların sınırlarıdır: 0,55 olasılık en üst banda (5) düşer, 20 birimlik etki ikinci banda (2) düşer ve çarpım 10 olur. Aynı 10 puanı 240 birim etkili `fiziksel-erisim-noktasi` da alır — beklenen kaybı 14,40 birimdir. **Bantlama iki ucu birbirine yaklaştırır.** Ters yönde `acik-yonetim-ucu` durur: beklenen kaybı 19,20 birimle üçüncü sıradadır, bantlı sıralamada sekizinciye iner. Olasılığı 0,12'dir ve ikinci banda düşer; oysa 0,12 ile 0,18 arasında gerçek bir uçurum yoktur, yalnız 0,15 sınırı vardır. `genis-okuma-yetkisi` 0,18 ile üçüncü banda girer ve bantlı sıralamada birinci olur. **İki kalemin sırasını belirleyen şey, aralarındaki fark değil, sınırın nereye konduğudur.** Bandın kendisi bir kusur değildir; olasılığı iki hanelik kesinlikle kestirmek çoğu kalemde mümkün değildir ve bant o sahte kesinliği kaldırır. Ölçülen şey şudur: bandın kaldırdığı sahte kesinliğin yerine **başka bir sahte kesinlik** gelir ve bu ikincisi sıralamayı dokuz kalemde değiştirecek kadar güçlüdür. #### Bütçe Sıralamayı Karara Çevirir Sıra farkı tek başına bir tartışmadır; üçüncü tablo onu bir karara bağlar. Bir turda dört kalem ele alınabiliyorsa, beklenen kayıp sıralaması ilk dördü seçer ve 176,05 birimlik toplamın **77,00 birimini**, yani **%43,7'sini** kapatır. Bantlı sıralama aynı bütçeyle beklenen kayıp sırasının 2., 6., 1. ve 10. kalemlerini seçer ve **67,60 birim** (%38,4) kapatır. Aradaki 9,40 birim, puanlama biçiminin bedelidir. Eşik puanlaması ortada durur: 71,40 birim (%40,6) kapatır. Buna karşılık üç puanlamadan **yalnız o** en büyük tek etkiyi — 600 kurgu birimlik `imzasiz-guncelleme` kalemini — bütçenin içine alır. Beklenen kayıp sıralaması onu beşinci sıraya koyar ve dört kalemlik bütçe onu dışarıda bırakır; bantlı sıralama onuncu sıraya koyar. Bu satır, beklenen kaybın kendi içinde bir kör noktası olduğunu gösterir. Beklenen kayıp **ortalamayı** ölçer; ortalama, uzun bir zaman diliminde tekrarlanan olaylar için doğru sayıdır. Tek seferde 600 birim kaybettiren bir olay için ortalama, kurumun o kaybı taşıyıp taşıyamayacağını söylemez. Eşik puanlaması bunu kaba bir kuralla düzeltir ve karşılığında beklenen kayıp kapsamından 5,60 birim verir. #### Listede Kuyruk Yok Son satır sıralamanın bir varsayımını sınar. Öncelik listeleri çoğu zaman şu beklentiyle kurulur: birkaç kalem toplamın büyük kısmını taşır, o birkaçı düzeltmek işin çoğunu bitirir. Birikimli kapsam dizisi bu listede o beklentinin karşılanmadığını yazar. İlk kalem toplamın **%11,4'ünü**, ilk üç kalem **%33,5'ini**, ilk altı kalem **%63,5'ini** taşır. Kapsamın %90'ını geçmek için on kalem gerekir. Dağılım bu kadar düzken öncelik listesinin anlamı değişir. Yoğun bir kuyruğu olan listede sıralama biçimi tartışılmaz, çünkü hangi biçimle bakılırsa bakılsın aynı iki üç kalem tepede kalır. Düz bir listede ise sıralama biçiminin kendisi karardır — nitekim bu dersin ikinci tablosu dokuz kalemin yer değiştirdiğini yazar ve üçüncü tablo aradaki farkın 9,40 birim olduğunu. Aynı diziden ikinci bir sonuç çıkar: listenin sonundaki kalemler ihmal edilebilir değildir. Son üç kalem toplamın %12,8'ini taşır; en alttaki `dogrulanmayan-alan` bile 1,80 birim yazar ve önceki derste sıfır üçlü taşıyan kalem tam olarak budur. **Sıfır erişim yolu sıfır risk demek değildir**, çünkü olasılık yalnız bugünkü erişim durumundan gelmez. Düz bir dağılımda kesme noktası nereye konursa konsun, dışarıda bırakılan kalemler toplamın azımsanmayacak bir payını taşır ve bu pay **kabul edilmiş** sayılır — sayılıp yazılmadığında kabul edildiği bile fark edilmez. #### Aynı Çarpım, Ayrı Karar Dördüncü tablo iki kalemi yan yana koyar: `eski-surum-kitapligi` ve `imzasiz-guncelleme`. Beklenen kayıpları **tam olarak eşittir** — 18,00 kurgu birim. Bantlı puanları 8'e karşı 5'tir. On yıllık bir pencerede ikisinden beklenen toplam kayıp da eşittir. Eşit olmayan tek şey dağılımdır. Birincisi on yılda ortalama **4,0 kez** gerçekleşir ve her seferinde 45 birim yazar; ikincisi **0,3 kez** gerçekleşir ve gerçekleşirse 600 birim yazar. Birinci kalem bir işletme gideridir: öngörülebilir, bütçelenebilir, tek seferde taşınabilir. İkincisi bir kesintidir: çoğu on yılda hiç olmaz, olduğu on yılda tek kalemde bütün yıllık beklenen kaybın üç katından fazlasını yazar. Aynı sayıya indirilmiş iki kalem böylece iki ayrı karar gerektirir. Birincisi için doğru soru "kaç kez olacak ve toplamı ne kadar tutacak"; ikincisi için "olduğunda ayakta kalınabilir mi". İki soru iki ayrı savunma biçimine bakar: sık ve küçük olan kalemde ölçülecek şey birim başına azaltmadır — her olayın maliyetini 45'ten 30'a indirmek on yılda 4,0 olayda gerçek bir kazançtır. Seyrek ve büyük olan kalemde aynı azaltma neredeyse hiçbir şey ifade etmez; orada ölçülecek şey olayın **hiç gerçekleşmemesi** ya da gerçekleştiğinde 600 birimin bölünebilmesidir. **Beklenen kayıp bir sıralama aracıdır, bir eşik aracı değildir.** Risk sayısı bu yüzden hiçbir zaman tek başına yeterli olmaz; yanında hangi bileşimle üretildiği ve hangi dağılımı sakladığı yazılmadıkça, aynı 18,00 iki farklı kararı gizler. #### Özet - Risk olasılık ile etkinin bileşimidir; en sade biçimi beklenen kayıptır ve on iki kalemlik listede toplam 176,05 kurgu birimdir. - Aynı girdiden üç sıralama çıkar: bantlı puanlama dokuz kalemin sırasını değiştirir, en büyük kayma altı basamaktır, ilk beşin yalnız ikisi ortaktır; eşik puanlamasında bu sayılar 7, 4 ve 4. - Bantlama iki ucu yaklaştırır: 11,00 birimlik kalem ile 14,40 birimlik kalem aynı 10 puanı alır; sırayı belirleyen fark değil, sınırın nereye konduğudur. - Dört kalemlik bütçe üç puanlamada 77,00 (%43,7), 67,60 (%38,4) ve 71,40 (%40,6) birim kapatır; aradaki 9,40 birim puanlama biçiminin bedelidir. - En büyük tek etkiyi yalnız eşik puanlaması bütçeye alır ve karşılığında beklenen kayıp kapsamından 5,60 birim verir. - Aynı 18,00 beklenen kaybı taşıyan iki kalem on yılda 4,0 ve 0,3 olay üretir; biri işletme gideri, öteki taşıma sorusudur. #### Sonraki Adım Bu ders her kalemi tek bir olay gibi saydı: olasılık verildi, etki verildi, çarpıldı. Oysa `imzasiz-guncelleme` kaleminin 600 birimlik etkisi tek bir anda doğmaz. Önce bir yere erişilir, sonra bir zayıflık tetiklenir, sonra bir şey çalıştırılır, sonra yetki genişler ve etki ancak bunların hepsi tamamlandığında yazılır. Olasılık dediğimiz sayı, aslında bu zincirin **baştan sona tamamlanma** olasılığıdır. Sonraki ders zinciri adımlarına ayırır ve hangi adımı kırmanın kaç yolu kapattığını sayar. ### İstismar ve Yük Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/istismar-ve-yuk Açıktan etkiye giden zincirin adımlanması: 5 istismar ile 4 yükün 12 geçerli zincir üretmesi, zincir uzunluğunun 2 ile 7 arasında değişip toplam 53 adım tutması, tek bir adımı kırmanın en çok 8 zinciri kesmesi, bir yükü engellemenin en çok 5 ve bir istismarı engellemenin en çok 4 zinciri kesmesi, aynı kırılmanın erişimde 0 ve etkide 41 tamamlanmış adım bırakması, altı orta adımın tamamı kırıldığında bile 12 zincirden birinin ayakta kalması ve o tek zincirin toplam olasılık kütlesinin %25,7'sini taşıması. Önceki ders her kalemi tek bir olay gibi saydı: olasılık verildi, etki verildi, çarpıldı. Oysa 600 kurgu birimlik bir etki tek bir anda doğmaz. Önce bir yere erişilir, sonra bir zayıflık tetiklenir, sonra bir şey çalıştırılır, yetki genişler ve etki ancak bunların hepsi tamamlandığında yazılır. Olasılık dediğimiz sayı, aslında bu **zincirin baştan sona tamamlanma** olasılığıdır. **İstismar (exploit)**, bir açığı fiilen kullanan adım dizisidir. **Yük (payload)**, istismar tamamlandıktan sonra yazılan etkidir. İkisi ayrı şeylerdir ve bu ayrım bu dersin ölçtüğü şeyi belirler: aynı istismar birden çok yük taşıyabilir, aynı yük birden çok istismarla gelebilir. Bu ders zinciri model olarak kurar ve tek soruya bağlar — **hangi adımı kırmak kaç zinciri kesiyor**. #### Zincir Bir Adım Dizisidir Aşağıdaki yapı bir **modeldir**: çalışan bir istismar, bir araç ya da bir yük yoktur; yalnızca adım adlarından oluşan bir veri yapısı vardır. Açık adları önceki iki dersin listesinden gelir. Bu adımların gerçek bir sistem üzerinde denenmesi **yazılı yetki ve tanımlı kapsam olmadan hem yasadışı hem meslek dışıdır**. **GK16:** zincir sekiz adımlık kanonik sırayı izler ve her zincir bu sıranın bir alt dizisidir. **GK17:** istismar bir açığı kullanan adım dizisidir; yük, istismar tamamlandıktan sonra yazılan etkidir ve kendi ek adımlarını getirir. **GK18:** bir yük ancak gerektirdiği adım istismarda varsa o istismarla eşleşir. **GK19:** bir adım kırılırsa o adımı içeren her zincir kesilir; kesildiği anda zincirin kendinden önceki adımları tamamlanmıştır. ```js // guvenlik/zincir.mjs — actan etkiye giden zincirin adim modeli (model): burada calisan bir // istismar yoktur, yalnizca adim adlarindan olusan bir veri yapisi vardir. Rastgelelik yok. // GK16: zincir sekiz adimlik kanonik sirayi izler; her zincir bu siranin bir alt dizisidir. export const ADIM = ["erisim", "kesif", "tetikleme", "yurutme", "yetki-yukseltme", "yanal-gecis", "kalicilik", "etki"]; export const HARF = { erisim: "E", kesif: "K", tetikleme: "T", yurutme: "Y", "yetki-yukseltme": "P", "yanal-gecis": "G", kalicilik: "L", etki: "I" }; // GK17: istismar, bir acigi kullanan adim dizisidir; yuk, istismar tamamlandiktan sonra // yazilan etkidir ve kendi ek adimlarini getirir. export const ISTISMAR = [ { ad: "kimlik-yeniden-kullanimi", acik: "varsayilan-parola", adim: ["erisim", "kesif"] }, { ad: "girdi-tetikleme", acik: "dogrulanmayan-girdi", adim: ["erisim", "tetikleme", "yurutme"] }, { ad: "imzasiz-paket", acik: "imzasiz-guncelleme", adim: ["erisim", "kesif", "tetikleme", "yurutme"] }, { ad: "hesap-paylasimi", acik: "paylasilan-hesap", adim: ["erisim", "kesif"] }, { ad: "aktarim-dinleme", acik: "sifresiz-aktarim", adim: ["erisim"] }, ]; // GK18: bir yuk ancak gerektirdigi adim istismarda varsa o istismarla eslesir. export const YUK = [ { ad: "veri-cikarma", gerek: [], ek: ["etki"] }, { ad: "kayit-degistirme", gerek: ["kesif"], ek: ["yetki-yukseltme", "etki"] }, { ad: "hizmet-durdurma", gerek: ["yurutme"], ek: ["etki"] }, { ad: "kalici-erisim", gerek: ["yurutme"], ek: ["yanal-gecis", "kalicilik", "etki"] }, ]; export const ZINCIR = ISTISMAR.flatMap((i) => YUK .filter((y) => y.gerek.every((g) => i.adim.includes(g))) .map((y) => ({ istismar: i.ad, acik: i.acik, yuk: y.ad, adim: ADIM.filter((a) => i.adim.includes(a) || y.ek.includes(a)) }))); export const maske = (z) => ADIM.map((a) => (z.adim.includes(a) ? HARF[a] : ".")).join(""); export const gecen = (a) => ZINCIR.filter((z) => z.adim.includes(a)); // GK19: bir adim kirilirsa o adimi iceren her zincir kesilir; kesilene dek o zincirin // kendinden onceki adimlari tamamlanmistir. export const oncekiToplam = (a) => gecen(a).reduce((n, z) => n + z.adim.indexOf(a), 0); export const kapanan = (kume) => ZINCIR.filter((z) => z.adim.some((a) => kume.includes(a))).length; // GK20: her adimin tamamlanma olasiligi vardir ve adimlar bagimsiz sayilir (model); // zincirin tamamlanma olasiligi adim olasiliklarinin carpimidir. export const ADIM_P = { erisim: 0.5, kesif: 0.7, tetikleme: 0.4, yurutme: 0.6, "yetki-yukseltme": 0.35, "yanal-gecis": 0.5, kalicilik: 0.6, etki: 0.9 }; export const olasilik = (z) => z.adim.reduce((p, a) => p * ADIM_P[a], 1); export const KUTLE = ZINCIR.reduce((s, z) => s + olasilik(z), 0); export const kapananKutle = (kume) => ZINCIR .filter((z) => z.adim.some((a) => kume.includes(a))) .reduce((s, z) => s + olasilik(z), 0); ``` ```js // guvenlik/kir.mjs — hangi adimi kirmak kac zinciri kesiyor, kesildiginde ne kadari olmustu. import { ADIM, HARF, ISTISMAR, YUK, ZINCIR, KUTLE, maske, gecen, oncekiToplam, kapanan, olasilik, kapananKutle } from "./zincir.mjs"; const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const uzunluk = ZINCIR.map((z) => z.adim.length); console.log(`${ISTISMAR.length} istismar x ${YUK.length} yuk -> ${ZINCIR.length} gecerli zincir; ` + `adim sirasi ${ADIM.map((a) => HARF[a]).join("")} = ${ADIM.join(", ")}; ` + `zincir uzunlugu ${Math.min(...uzunluk)}..${Math.max(...uzunluk)}, ` + `toplam adim ${uzunluk.reduce((a, x) => a + x, 0)}`); const A = [-26, 18, 10, 7]; console.log("\n1. gecerli zincirler"); yaz(A, "istismar", "yuk", "maske", "adim"); for (const z of ZINCIR) yaz(A, z.istismar, z.yuk, maske(z), z.adim.length); const B = [-18, 10, 10, 8, 12]; console.log("\n2. bir adim kirilirsa"); yaz(B, "adim", "zincirde", "kapanan", "kalan", "olmus adim"); for (const a of ADIM) yaz(B, a, gecen(a).length, kapanan([a]), ZINCIR.length - kapanan([a]), oncekiToplam(a)); const C = [-20, 10, 10, 8]; console.log("\n3. yuk engellenirse (istismar yerinde kalir)"); yaz(C, "yuk", "zincirde", "kapanan", "kalan"); for (const y of YUK) { const n = ZINCIR.filter((z) => z.yuk === y.ad).length; yaz(C, y.ad, n, n, ZINCIR.length - n); } for (const i of ISTISMAR) { const n = ZINCIR.filter((z) => z.istismar === i.ad).length; yaz(C, "istismar " + i.ad.slice(0, 11), n, n, ZINCIR.length - n); } const ORTA = ADIM.slice(1, -1); // erisim ve etki mesru isin uclaridir, tumden kaldirilamaz const D = [-24, 10, 8]; console.log("\n4. orta adimlardan en iyi tekli ve ikili (erisim ve etki disarida)"); yaz(D, "kirilan adim kumesi", "kapanan", "kalan"); const tekli = ORTA.map((a) => [a]).sort((x, y) => kapanan(y) - kapanan(x))[0]; const ikili = ORTA.flatMap((a, i) => ORTA.slice(i + 1).map((b) => [a, b])) .sort((x, y) => kapanan(y) - kapanan(x))[0]; for (const k of [tekli, ikili, ORTA]) yaz(D, k.map((a) => HARF[a]).join("+"), kapanan(k), ZINCIR.length - kapanan(k)); const acik = ZINCIR.filter((z) => !z.adim.some((a) => ORTA.includes(a))); console.log(`butun orta adimlar kirildiginda ayakta kalan zincir: ` + acik.map((z) => `${z.istismar} + ${z.yuk} (${maske(z)})`).join(", ")); const E = [-18, 11, 11, 12, 15]; console.log("\n5. kapanan zincir sayisi ile kapanan olasilik kutlesi"); yaz(E, "adim", "kapanan", "zincir %", "kutle %", "kutle/zincir"); for (const a of ADIM) { const z = (kapanan([a]) / ZINCIR.length) * 100, k = (kapananKutle([a]) / KUTLE) * 100; yaz(E, a, kapanan([a]), z.toFixed(1), k.toFixed(1), (k / z).toFixed(2)); } const enOlasi = [...ZINCIR].sort((x, y) => olasilik(y) - olasilik(x)); console.log(`toplam kutle ${KUTLE.toFixed(4)}; en olasi zincir ${enOlasi[0].istismar} + ` + `${enOlasi[0].yuk} (${olasilik(enOlasi[0]).toFixed(4)}, kutlenin ` + `%${((olasilik(enOlasi[0]) / KUTLE) * 100).toFixed(1)}'i), en olasi olmayan ` + `${enOlasi.at(-1).istismar} + ${enOlasi.at(-1).yuk} (${olasilik(enOlasi.at(-1)).toFixed(4)})`); ``` ``` 5 istismar x 4 yuk -> 12 gecerli zincir; adim sirasi EKTYPGLI = erisim, kesif, tetikleme, yurutme, yetki-yukseltme, yanal-gecis, kalicilik, etki; zincir uzunlugu 2..7, toplam adim 53 1. gecerli zincirler istismar yuk maske adim kimlik-yeniden-kullanimi veri-cikarma EK.....I 3 kimlik-yeniden-kullanimi kayit-degistirme EK..P..I 4 girdi-tetikleme veri-cikarma E.TY...I 4 girdi-tetikleme hizmet-durdurma E.TY...I 4 girdi-tetikleme kalici-erisim E.TY.GLI 6 imzasiz-paket veri-cikarma EKTY...I 5 imzasiz-paket kayit-degistirme EKTYP..I 6 imzasiz-paket hizmet-durdurma EKTY...I 5 imzasiz-paket kalici-erisim EKTY.GLI 7 hesap-paylasimi veri-cikarma EK.....I 3 hesap-paylasimi kayit-degistirme EK..P..I 4 aktarim-dinleme veri-cikarma E......I 2 2. bir adim kirilirsa adim zincirde kapanan kalan olmus adim erisim 12 12 0 0 kesif 8 8 4 8 tetikleme 7 7 5 11 yurutme 7 7 5 18 yetki-yukseltme 3 3 9 8 yanal-gecis 2 2 10 7 kalicilik 2 2 10 9 etki 12 12 0 41 3. yuk engellenirse (istismar yerinde kalir) yuk zincirde kapanan kalan veri-cikarma 5 5 7 kayit-degistirme 3 3 9 hizmet-durdurma 2 2 10 kalici-erisim 2 2 10 istismar kimlik-yeni 2 2 10 istismar girdi-tetik 3 3 9 istismar imzasiz-pak 4 4 8 istismar hesap-payla 2 2 10 istismar aktarim-din 1 1 11 4. orta adimlardan en iyi tekli ve ikili (erisim ve etki disarida) kirilan adim kumesi kapanan kalan K 8 4 K+T 11 1 K+T+Y+P+G+L 11 1 butun orta adimlar kirildiginda ayakta kalan zincir: aktarim-dinleme + veri-cikarma (E......I) 5. kapanan zincir sayisi ile kapanan olasilik kutlesi adim kapanan zincir % kutle % kutle/zincir erisim 12 100.0 100.0 1.00 kesif 8 66.7 60.1 0.90 tetikleme 7 58.3 25.7 0.44 yurutme 7 58.3 25.7 0.44 yetki-yukseltme 3 25.0 14.1 0.56 yanal-gecis 2 16.7 3.1 0.19 kalicilik 2 16.7 3.1 0.19 etki 12 100.0 100.0 1.00 toplam kutle 1.7492; en olasi zincir aktarim-dinleme + veri-cikarma (0.4500, kutlenin %25.7'i), en olasi olmayan imzasiz-paket + kalici-erisim (0.0227) ``` Sayılar **ölçüm** sınıfındadır; girdileri GK16–GK19'dur. #### Beş İstismar, On İki Zincir Birinci tablo çarpımın nasıl daraldığını yeniden gösterir. Beş istismar ve dört yük yirmi kombinasyon eder; geçerli olan **on ikisidir**, çünkü her yük her istismarla eşleşmez. `hizmet-durdurma` ve `kalici-erisim` yürütme adımı gerektirir; `aktarim-dinleme` yalnız erişim adımından oluştuğu için tek yük taşır ve iki adımlık en kısa zinciri üretir. Zincir uzunlukları 2 ile 7 arasında değişir ve toplam 53 adım tutar. Uzunluk yükten gelir: `imzasiz-paket` istismarı dört adımdır, üstüne `kalici-erisim` yükü üç adım ekler ve zincir yediye çıkar. Aynı istismar `veri-cikarma` yüküyle beş adımda biter. **İstismar sabittir, zincirin boyunu yük belirler.** Bu, ayrımın neden önemli olduğunu yazar. `girdi-tetikleme` maskesi üç zincirde `E.TY...I`, `E.TY...I` ve `E.TY.GLI` biçimindedir — ilk ikisi **tamamen aynı adım dizisidir** ve yalnız yük adında ayrılır. Savunma tarafından bakıldığında bu iki zincir aynı yerlerden geçer, aynı kayıtları üretir ve aynı denetimle kesilir; farkları yalnız gerçekleşince yazılan etkidedir. #### Hangi Adımı Kırmak Kaç Zinciri Kesiyor İkinci tablo bu dersin ana ölçümüdür. Sekiz adımın her biri için iki sayı vardır: kaç zinciri keser ve kesildiğinde kaç adım tamamlanmış olur. Kesme gücü sırası `erisim` ve `etki` (12), `kesif` (8), `tetikleme` ve `yurutme` (7), `yetki-yukseltme` (3), `yanal-gecis` ve `kalicilik` (2) biçimindedir. Sıra zincirin başından sonuna doğru azalır, çünkü zincirler önce ortaktır sonra dallanır. **Erken adım daha çok yol kapatır.** Son sütun aynı sıralamayı tersine çevirir. `erisim` kırıldığında **hiçbir adım tamamlanmamıştır**; `etki` kırıldığında 12 zincir boyunca **41 adım** çoktan tamamlanmıştır. `yurutme` 7 zincir keser ve arkasında 18 tamamlanmış adım bırakır; `kesif` 8 zincir keser ve arkasında yalnız 8 adım. Aynı kesme gücüne yakın iki adım, çok farklı miktarda gerçekleşmiş iş bırakır. İki uç adımın tablodaki 12 sayısı yanıltıcıdır. `erisim` her zincirdedir, ama onu tümden kırmak servisin kendisini kapatmaktır — meşru istekler de aynı adımdan geçer. `etki` de her zincirdedir, ama orada kırmak olay olduktan sonra zararı sınırlamaktır, yolu kapatmak değil. Sayılabilir kaldıraç **ortadaki altı adımdadır**. #### Yükü Engellemek Zinciri Kesmez Üçüncü tablo üç kaldıracı yan yana koyar. Bir yükü engellemek en çok **5 zincir** kapatır (`veri-cikarma`); bir istismarı engellemek en çok **4** (`imzasiz-paket`); bir adımı kırmak **8**. Üç sütun aynı on iki zincir üzerinde koşar ve aradaki fark yalnız kaldıracın nereye konduğundan gelir. Yük en zayıf kaldıraçtır ve bunun nedeni tabloda görülür: yük, zincirin **sonunda** oturur ve değiştirilebilir. `imzasiz-paket` istismarı dört yük taşır; bunlardan birini engellemek kalan üç zinciri yerinde bırakır. Aynı istismarı kesmek dördünü birden kapatır. Adım kırmak daha da geniştir, çünkü bir adım birden çok istismarda ortaktır: `kesif` adımı üç ayrı istismarda geçer ve sekiz zinciri birden keser. Bu sıralamanın pratik karşılığı, savunmanın nereye yazılacağıdır. Belirli bir etkiyi tanıyıp durduran bir denetim tek bir sütunu kapatır; aynı emeği zincirin ortak adımına koymak dört kat fazlasını kapatır. **Zincirin sonuna konan savunma, zincirin kaç kolu olduğu kadar kere tekrarlanmak zorundadır.** #### Orta Adımların Yetmediği Zincir Dördüncü tablo kaldıracın sınırını gösterir. Ortadaki en iyi tek adım `kesif`tir ve 8 zincir kapatır, 4 zincir kalır. En iyi ikili `kesif` ile `tetikleme`dir: **11 zincir kapanır, 1 kalır.** Altı orta adımın **tamamı** kırıldığında da sonuç değişmez — yine 11 kapanır, 1 kalır. Ayakta kalan zincir `aktarim-dinleme` istismarı ile `veri-cikarma` yüküdür ve maskesi `E......I`dır. Bu zincirin ortasında hiçbir adım yoktur: erişimden doğrudan etkiye gider. Ortadaki altı adıma yazılan bütün savunmalar ona hiç dokunmaz, çünkü o adımların hiçbirinden geçmez. Bu satır zincir modelinin kendi sınırını yazar. Zinciri adımlamak, savunmanın nereye konulacağını seçmeyi sağlar; ama adım kümesi boş olan bir zincir bu seçimin dışında kalır. Onu kapatmanın tek yolu ilk adıma, yani **erişime** dokunmaktır — ve erişim tam da tabloda "tümden kaldırılamaz" diye dışarıda bırakılan adımdır. Bir sonraki soru bu yüzden kaçınılmazdır: erişim tek bir adım gibi yazıldı, oysa bir varlığa erişmenin kaç ayrı biçimi var. #### Zincir Sayısı ile Olasılık Kütlesi Aynı Şey Değil Beşinci tablo her zincire bir tamamlanma olasılığı verir — adım olasılıklarının çarpımı — ve kırılan adımın kaç zinciri değil, **ne kadar olasılık kütlesini** kapattığını sayar. On iki zincirin toplam kütlesi 1,7492'dir. İki sütun aynı yöne gitmez. `kesif` zincirlerin %66,7'sini ve kütlenin %60,1'ini kapatır; oran 0,90 ile dengelidir. `tetikleme` ve `yurutme` zincirlerin %58,3'ünü kapatır ama kütlenin yalnız **%25,7'sini** — oran 0,44. Sayı olarak neredeyse aynı işi yapan iki denetim, gerçekleşme olasılığı cinsinden iki buçuk kat farklıdır. Nedeni uzunluktur: yürütme geçen zincirler uzundur, her ek adım olasılığı bir kez daha çarparak düşürür. `yanal-gecis` ve `kalicilik` en uçtaki örnektir — zincirlerin %16,7'sini kapatır, kütlenin %3,1'ini. Son satır önceki dersin sayısına bağlanır. En olası zincir `aktarim-dinleme` ile `veri-cikarma` çiftidir: iki adımlık, 0,4500 olasılıklı ve tek başına toplam kütlenin **%25,7'sini** taşır. En olası olmayanı yedi adımlık `imzasiz-paket` ile `kalici-erisim`tir: 0,0227. Üçüncü derste `imzasiz-guncelleme` kaleminin olasılığı 0,03, `sifresiz-aktarim` kaleminin 0,25 yazılmıştı; o iki sayının nereden geldiği burada görünür — **zincir uzadıkça olasılık düşer, etki büyür**. Bu, dördüncü tablonun bulgusunu daha da keskinleştirir. Bütün orta adımlar kırıldığında ayakta kalan tek zincir, aynı zamanda **kütlenin dörtte birini taşıyan** zincirdir. Sayarak bakıldığında 12'de 1'lik bir artıktır; olasılıkla tartıldığında savunmanın dışarıda bıraktığı en büyük tek paydır. #### Özet - İstismar bir açığı kullanan adım dizisi, yük ise istismar tamamlandıktan sonra yazılan etkidir; beş istismar ile dört yük 12 geçerli zincir üretir, uzunlukları 2 ile 7 arası, toplam 53 adım. - Bir adımı kırmak zincirin başına yaklaştıkça daha çok yol kapatır: 12, 8, 7, 7, 3, 2, 2. Aynı istismarın iki zinciri aynı adım dizisini izleyip yalnız yük adında ayrılabilir. - Aynı kırılma zincirin neresinde olduğuna göre farklı miktarda tamamlanmış iş bırakır: erişimde 0, keşifte 8, yürütmede 18, etkide 41 adım. - Üç kaldıraç eşit değildir: bir yükü engellemek en çok 5, bir istismarı engellemek en çok 4, bir adımı kırmak 8 zincir kapatır; yük en zayıf kaldıraçtır, çünkü zincirin sonunda oturur. - Altı orta adımın tamamı kırıldığında 12 zincirden biri ayakta kalır — ortasında hiç adım olmayan, erişimden doğrudan etkiye giden zincir. - Zincir sayısı ile olasılık kütlesi ayrı ölçülerdir: tetikleme zincirlerin %58,3'ünü ama kütlenin %25,7'sini kapatır; ayakta kalan tek zincir kütlenin %25,7'sini taşır. #### Sonraki Adım Bu dersin bütün ölçümleri tek bir varsayımın üstünde durdu: `erisim` bir adımdır. On iki zincirin on ikisi de o adımdan başladı ve o adım hiç açılmadı. Oysa bir varlığa erişmek tek bir kapıdan geçmek değildir — şube ucundan, saha uygulamasından, ortak arayüzünden ya da yönetim ucundan başlayan ayrı ayrı yollar vardır ve her biri farklı sayıda durak üzerinden geçer. Konunun son dersi bu yolları bir grafta modeller, **yol sayımını gerçekten koşturur** ve saldırı yüzeyini azaltmanın kaç yol kapatıp kaç meşru işi durdurduğunu sayar. ### Saldırı Yüzeyi Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/saldiri-yuzeyi Yüzeyin sayılabilir birime çevrilmesi: 13 düğüm ve 21 kenarlık erişim grafında dört giriş ucundan iki hedefe 35 ayrı yol çıkması, toplam meşru işin %1,4'ünü taşıyan giriş ucunun yolların %37,1'ini açması, tek bir kenarın 14 yol kapatabilmesi, bir kenarın 4 meşru işi durdurup hiçbir yol kapatmaması, oran sıralamasına göre açgözlü daraltmanın 31 meşru iş bedeliyle yolu sıfırlaması ve aynı sonucun bütün giriş uçlarını kapatmakla 27 bedele mal olması. Önceki dersin bütün ölçümleri tek bir varsayımın üstünde durdu: `erisim` bir adımdır. On iki zincirin on ikisi de o adımdan başladı ve o adım hiç açılmadı. Oysa bir varlığa erişmek tek bir kapıdan geçmek değildir. Bu ders o adımı açar ve müfredatın geri kalanının üzerinde duracağı ölçü birimini kurar. **Saldırı yüzeyi (attack surface)**, bir varlığa ulaşmak için kullanılabilecek giriş noktalarının ve aralarındaki geçişlerin bütünüdür. "Yüzey geniştir" bir karar taşımaz. Yüzeyin sayılabilir karşılığı **saldırı yolu (attack path)** sayısıdır: kaynaktan hedefe giden kaç ayrı dizi var. Bu dersten sonra her savunma aynı soruyla ölçülecektir — **kaç yol kapatıyor, kaç yol kalıyor, kaç meşru iş duruyor**. #### Yüzey Bir Yol Sayısıdır Aşağıdaki graf bir **modeldir**: gerçek bir ağ, gerçek bir ana makine adı ya da gerçek bir hizmet ucu yoktur. Böyle bir sayımın gerçek bir ağ üzerinde yapılması **yazılı yetki ve tanımlı kapsam olmadan hem yasadışı hem meslek dışıdır**. **GK21:** her kenar bir erişim geçişidir ve üstünde günde geçen kurgu **meşru iş** kalemi sayısını taşır. **GK22:** yol, kaynaktan bir hedefe giden ve hiçbir düğümü iki kez ziyaret etmeyen dizidir; yol sayımı aşağıdaki derine yürüyüşle gerçekten koşturulur. **GK23:** bir kenar kaldırıldığında o kenardan geçen bütün yollar kapanır ve o kenarın taşıdığı meşru iş durur. ```js // guvenlik/graf.mjs — kurgu olcum aginin erisim grafi (model): gercek bir ag, gercek bir ana // makine adi ya da gercek bir hizmet ucu yok. Graf yonlu ve cevrimsizdir. Rastgelelik yok. // GK21: kenar "kaynak hedef mesru-is" biciminde yazilir; mesru is, o kenardan gunde gecen // kurgu is kalemi sayisidir. export const KENAR = ` dis-ag sube-ucu 12 dis-ag saha-uygulamasi 9 dis-ag ortak-arayuzu 4 dis-ag yonetim-ucu 2 sube-ucu ag-gecidi 12 saha-uygulamasi ag-gecidi 9 ortak-arayuzu faturalama 4 yonetim-ucu ag-gecidi 2 yonetim-ucu dogrulayici 1 ag-gecidi toplayici 15 ag-gecidi faturalama 6 ag-gecidi is-emri 5 ag-gecidi rapor-ucu 4 toplayici dogrulayici 15 toplayici olcum-deposu 14 dogrulayici olcum-deposu 13 dogrulayici faturalama 7 faturalama olcum-deposu 5 faturalama kimlik-deposu 3 is-emri dogrulayici 2 is-emri kimlik-deposu 4` .trim().split("\n").map((r) => { const [a, b, is] = r.trim().split(/\s+/); return { a, b, is: +is, ad: `${a}->${b}` }; }); export const KAYNAK = "dis-ag"; export const HEDEF = ["olcum-deposu", "kimlik-deposu"]; export const DUGUM = [...new Set(KENAR.flatMap((k) => [k.a, k.b]))]; // GK22: yol, kaynaktan bir hedefe giden ve hicbir dugumu iki kez ziyaret etmeyen dizidir. // Yol sayimi asagidaki derine yuruyusle gercekten kosturulur. export function yollar(kenarlar = KENAR) { const komsu = {}; for (const k of kenarlar) (komsu[k.a] ||= []).push(k.b); const bulunan = [], iz = [KAYNAK], gorulen = new Set([KAYNAK]); (function yuru(d) { if (HEDEF.includes(d)) return bulunan.push([...iz]); for (const s of komsu[d] || []) { if (gorulen.has(s)) continue; gorulen.add(s); iz.push(s); yuru(s); iz.pop(); gorulen.delete(s); } })(KAYNAK); return bulunan; } export const YOL = yollar(); export const kalanYol = (kaldirilan) => yollar(KENAR.filter((k) => !kaldirilan.includes(k.ad))).length; export const duranIs = (kaldirilan) => KENAR.filter((k) => kaldirilan.includes(k.ad)).reduce((s, k) => s + k.is, 0); export const TOPLAM_IS = KENAR.reduce((s, k) => s + k.is, 0); ``` ```js // guvenlik/yuzey.mjs — yuzey bir yol sayisidir: kac yol var, ne kapatiyor, kac mesru is duruyor. import { KENAR, DUGUM, HEDEF, YOL, KAYNAK, TOPLAM_IS, kalanYol, duranIs } from "./graf.mjs"; const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const uz = YOL.map((y) => y.length - 1); const giris = [...new Set(KENAR.filter((k) => k.a === KAYNAK).map((k) => k.b))]; console.log(`${DUGUM.length} dugum, ${KENAR.length} kenar, ${giris.length} giris ucu, ` + `${HEDEF.length} hedef; yol sayisi ${YOL.length}, yol uzunlugu ` + `${Math.min(...uz)}..${Math.max(...uz)}, toplam mesru is ${TOPLAM_IS}`); const A = [-18, 9, 9, 11]; console.log("\n1. yollar nereden giriyor, nereye cikiyor"); yaz(A, "uc", "yol", "en kisa", "en uzun"); for (const g of giris) { const y = YOL.filter((p) => p[1] === g); yaz(A, g, y.length, Math.min(...y.map((p) => p.length - 1)), Math.max(...y.map((p) => p.length - 1))); } for (const h of HEDEF) { const y = YOL.filter((p) => p.at(-1) === h); yaz(A, h, y.length, Math.min(...y.map((p) => p.length - 1)), Math.max(...y.map((p) => p.length - 1))); } const B = [-32, 8, 9, 8, 9]; console.log("\n2. bir kenar kaldirilirsa (yol/is orani buyukten kucuge)"); yaz(B, "kenar", "mesru is", "kapanan", "kalan", "yol/is"); const olc = KENAR.map((k) => ({ ...k, kap: YOL.length - kalanYol([k.ad]) })); for (const k of [...olc].sort((x, y) => y.kap / y.is - x.kap / x.is)) yaz(B, k.ad, k.is, k.kap, YOL.length - k.kap, (k.kap / k.is).toFixed(2)); const C = [-32, 10, 11, 12, 13]; console.log("\n3. acgozlu daraltma: her turda yol/is orani en yuksek kenar kaldirilir"); yaz(C, "kaldirilan kenar", "mesru is", "kalan yol", "biriken is", "kalan is %"); const kaldir = []; while (kalanYol(kaldir) > 0) { const aday = KENAR.filter((k) => !kaldir.includes(k.ad)) .map((k) => ({ k, kap: kalanYol(kaldir) - kalanYol([...kaldir, k.ad]) })) .sort((x, y) => y.kap / y.k.is - x.kap / x.k.is)[0]; kaldir.push(aday.k.ad); yaz(C, aday.k.ad, aday.k.is, kalanYol(kaldir), duranIs(kaldir), (((TOPLAM_IS - duranIs(kaldir)) / TOPLAM_IS) * 100).toFixed(1)); } const D = [-30, 11, 11, 13]; console.log("\n4. uc yuzey azaltma bicimi"); yaz(D, "bicim", "kalan yol", "duran is", "kalan is %"); const girisKenar = KENAR.filter((k) => k.a === KAYNAK).map((k) => k.ad); const bedava = olc.filter((k) => k.kap === 0).map((k) => k.ad); for (const [ad, kume] of [["hicbir sey", []], ["kapatani sifir olan kenarlar", bedava], ["butun giris uclari", girisKenar], ["acgozlu secim", kaldir]]) yaz(D, ad, kalanYol(kume), duranIs(kume), (((TOPLAM_IS - duranIs(kume)) / TOPLAM_IS) * 100).toFixed(1)); console.log(`kapattigi yol sifir olan kenar: ${bedava.join(", ") || "yok"}`); const E = [-18, 11, 13, 12, 12]; console.log("\n5. yuzey olcusu olarak ne sayilir (giris ucu kaldirilirsa)"); yaz(E, "giris ucu", "uc payi %", "kapanan yol", "yol payi %", "is payi %"); for (const g of giris) { const k = KENAR.find((x) => x.a === KAYNAK && x.b === g); const kap = YOL.length - kalanYol([k.ad]); yaz(E, g, (100 / giris.length).toFixed(1), kap, ((kap / YOL.length) * 100).toFixed(1), ((k.is / TOPLAM_IS) * 100).toFixed(1)); } ``` ``` 13 dugum, 21 kenar, 4 giris ucu, 2 hedef; yol sayisi 35, yol uzunlugu 3..6, toplam mesru is 148 1. yollar nereden giriyor, nereye cikiyor uc yol en kisa en uzun sube-ucu 10 4 6 saha-uygulamasi 10 4 6 ortak-arayuzu 2 3 3 yonetim-ucu 13 3 6 olcum-deposu 21 3 6 kimlik-deposu 14 3 6 2. bir kenar kaldirilirsa (yol/is orani buyukten kucuge) kenar mesru is kapanan kalan yol/is dis-ag->yonetim-ucu 2 13 22 6.50 yonetim-ucu->ag-gecidi 2 10 25 5.00 is-emri->dogrulayici 2 9 26 4.50 faturalama->kimlik-deposu 3 11 24 3.67 yonetim-ucu->dogrulayici 1 3 32 3.00 ag-gecidi->is-emri 5 12 23 2.40 faturalama->olcum-deposu 5 11 24 2.20 dogrulayici->faturalama 7 14 21 2.00 dis-ag->saha-uygulamasi 9 10 25 1.11 saha-uygulamasi->ag-gecidi 9 10 25 1.11 ag-gecidi->faturalama 6 6 29 1.00 dis-ag->sube-ucu 12 10 25 0.83 sube-ucu->ag-gecidi 12 10 25 0.83 ag-gecidi->toplayici 15 12 23 0.80 is-emri->kimlik-deposu 4 3 32 0.75 toplayici->dogrulayici 15 9 26 0.60 dogrulayici->olcum-deposu 13 7 28 0.54 dis-ag->ortak-arayuzu 4 2 33 0.50 ortak-arayuzu->faturalama 4 2 33 0.50 toplayici->olcum-deposu 14 3 32 0.21 ag-gecidi->rapor-ucu 4 0 35 0.00 3. acgozlu daraltma: her turda yol/is orani en yuksek kenar kaldirilir kaldirilan kenar mesru is kalan yol biriken is kalan is % dis-ag->yonetim-ucu 2 22 2 98.6 is-emri->dogrulayici 2 16 4 97.3 faturalama->kimlik-deposu 3 11 7 95.3 faturalama->olcum-deposu 5 6 12 91.9 is-emri->kimlik-deposu 4 4 16 89.2 ag-gecidi->toplayici 15 0 31 79.1 4. uc yuzey azaltma bicimi bicim kalan yol duran is kalan is % hicbir sey 35 0 100.0 kapatani sifir olan kenarlar 35 4 97.3 butun giris uclari 0 27 81.8 acgozlu secim 0 31 79.1 kapattigi yol sifir olan kenar: ag-gecidi->rapor-ucu 5. yuzey olcusu olarak ne sayilir (giris ucu kaldirilirsa) giris ucu uc payi % kapanan yol yol payi % is payi % sube-ucu 25.0 10 28.6 8.1 saha-uygulamasi 25.0 10 28.6 6.1 ortak-arayuzu 25.0 2 5.7 2.7 yonetim-ucu 25.0 13 37.1 1.4 ``` Sayılar **ölçüm** sınıfındadır; girdileri GK21–GK23'tür. #### Otuz Beş Yol On üç düğüm ve yirmi bir kenar **35 yol** üretir. Bu, yüzeyin bu derste ve müfredatın geri kalanında kullanılacak sayısıdır. Ne düğüm sayısı ne kenar sayısı onun yerine geçer: kenarlar %5 artsa yol sayısı iki katına çıkabilir, çünkü yol sayısı kenarların **birleşim biçimine** bağlıdır. Birinci tablo yolların nereden girip nereye çıktığını ayırır. Ölçüm deposuna 21, kimlik deposuna 14 yol gider. Giriş uçlarında ise beklenmedik bir dağılım vardır: `sube-ucu` ve `saha-uygulamasi` onar yol taşır, `ortak-arayuzu` yalnız iki, `yonetim-ucu` ise **on üç** — dördünün en yükseği. Yönetim ucu ağın en küçük kapısıdır ve en çok yolu açar, çünkü grafın ortasındaki iki düğüme birden bağlanır. En kısa yol üç adımdır ve iki uçtan çıkar — `ortak-arayuzu` ile `yonetim-ucu`; en uzun yol altı adımdır. Uzunluk dağılımı savunmanın nereye konacağını değiştirir: üç adımlık bir yolda ara denetim koyacak iki nokta vardır, altı adımlıkta beş. #### Bir Kenarın İki Sayısı İkinci tablo bu dersin ana ölçümüdür ve her kenarı iki sayıyla anar: kaç yol kapatıyor, kaç meşru iş durduruyor. Sıralama ikisinin oranına göredir. En üstteki satır `dis-ag->yonetim-ucu` kenarıdır: **13 yol kapatır ve yalnız 2 meşru iş durdurur** — oran 6,50. En çok yol kapatan kenar bu değildir; o `dogrulayici->faturalama` kenarıdır ve 14 yol kapatır, ama 7 meşru iş durdurur (oran 2,00). Tek başına "en çok kapatan" ölçütü seçilirse ikincisi kazanır; bedel de sayıldığında birincisi üç kat verimlidir. Tablonun alt ucu ters yönü gösterir. `toplayici->olcum-deposu` yalnız 3 yol kapatır ve 14 meşru iş durdurur — oran 0,21. Bu kenar ağın asıl işidir: okumalar oradan deposuna yazılır. Onu kaldırmak yüzeyi neredeyse hiç daraltmaz ve işin onda birini durdurur. Son satır her yüzey azaltma listesinde aranması gereken kalemdir. `ag-gecidi->rapor-ucu` **hiçbir yol kapatmaz** — 35 yol 35 kalır — ve 4 meşru iş durdurur. Rapor ucu hiçbir hedefe bağlanmaz, bu yüzden hiçbir yolun üstünde değildir. Yüzey sayılmadan yapılan bir sadeleştirmede bu kenar "açık uç" diye kaldırılabilir; ölçüldüğünde görülen şey, bedeli olan ve karşılığı sıfır olan bir karardır. #### Yüzey Ölçüsü Olarak Ne Sayılır Beşinci tablo, yol sayısının neden başka bir ölçünün yerine geçmediğini gösterir. Dört giriş ucundan her biri uç sayısının **%25'idir**; kapattıkları yol payı ise sırasıyla %28,6, %28,6, %5,7 ve %37,1'dir. Aynı büyüklükteki dört kapı, yüzeyin altı buçuk kat farklı paylarını taşır. Uçları sayarak yapılan bir yüzey değerlendirmesi bu dört kalemi eşit yazar ve "dört açık ucumuz var" cümlesini üretir. Kenarları sayan bir değerlendirme de aynı hataya düşer: `ortak-arayuzu` üzerinden gelen yollar iki kenar kullanır, `yonetim-ucu` üzerinden gelenler de öyle başlar, ama biri iki yol açar öteki on üç. Sayılabilir tek şey **birleşim**dir ve birleşimin sayısı yoldur. Son sütun aynı tabloyu ters yönden okur. `yonetim-ucu` toplam meşru işin yalnız **%1,4'ünü** taşır ve yolların %37,1'ini açar; `sube-ucu` işin %8,1'ini taşır ve yolların %28,6'sını. İki oranın birlikte okunması, yüzey azaltmanın sırasını doğrudan verir: en az iş taşıyıp en çok yol açan uç ilk sıradadır. Bu ders boyunca elde edilen üç sütun — kapanan yol, kalan yol, meşru işe bedel — bu tabloda ilk kez bir **sıralama kuralına** dönüşür. #### Sıfıra İndirmenin Bedeli Üçüncü tablo yolu sıfıra indirmeyi dener: her turda oranı en yüksek kenar kaldırılır ve yol yeniden sayılır. Altı kenar sonunda kalan yol sıfırdır ve duran meşru iş 31'dir; ağın işinin **%79,1'i** ayakta kalır. Sıra kendi içinde öğreticidir. İlk kaldırma 35 yolu 22'ye indirir, ikincisi 16'ya, üçüncüsü 11'e. İlk üç kenar toplam 7 meşru iş bedeliyle yolların **%68,6'sını** kapatır. Kalan on bir yol için ödenen bedel ise 24 meşru iştir. **Yüzey azaltmanın getirisi ilk adımlarda toplanır; son yolları kapatmak katlanarak pahalılaşır.** Son satır bunun en açık biçimidir: `ag-gecidi->toplayici` tek başına 15 meşru iş durdurur ve geriye kalan dört yolu kapatır. Dördüncü tablo açgözlü seçimi iki alternatifle karşılaştırır. Kapattığı yol sıfır olan kenarları kaldırmak 4 meşru iş harcar ve **35 yolun hiçbirini kapatmaz**. Bütün giriş uçlarını dış ağdan kesmek yolu sıfırlar ve 27 meşru iş durdurur. Oran sıralamasına göre açgözlü seçim de yolu sıfırlar ama **31 meşru iş** durdurur. Bu son karşılaştırma bu dersin en dikkat çekici sonucudur: her adımda en verimli görünen kenarı seçmek, **toplamda daha pahalı** bir sonuç verir. Açgözlü seçim ilk turlarda ucuz kenarları harcar, sonunda pahalı bir kenarı kaldırmak zorunda kalır. En ucuz tam kesim bir kenar sıralaması değil, bir **kesit** seçimidir — hangi kenar kümesinin birlikte kaynağı hedeflerden ayırdığı. Bir savunma listesi kalem kalem verimlilikle sıralandığında, seçilen kalemlerin **birlikte** ne yaptığı sayılmadıkça toplam bedel dört birim fazla çıkar. #### Özet - Saldırı yüzeyinin sayılabilir karşılığı yol sayısıdır: 13 düğüm ve 21 kenarlık grafta dört giriş ucundan iki hedefe **35 yol** gider, uzunlukları 3 ile 6 adım arasındadır. - Dört giriş ucunun her biri uç sayısının %25'idir ama yolların %28,6, %28,6, %5,7 ve %37,1'ini açar; en az meşru iş taşıyan uç (%1,4) en çok yolu taşır. Uç ya da kenar saymak yüzeyi ölçmez. - Her kenar iki sayıyla anılır: en çok yol kapatan kenar 14 yol / 7 iş (oran 2,00), en verimli kenar 13 yol / 2 iş (oran 6,50), yol kapatanlar arasında en verimsizi 3 yol / 14 iş (oran 0,21). - Bir kenar 4 meşru iş durdurur ve hiçbir yol kapatmaz; hiçbir hedefe bağlanmadığı için hiçbir yolun üstünde değildir. - İlk üç kaldırma 7 meşru iş bedeliyle yolların %68,6'sını kapatır; kalan on bir yol için ödenen bedel 24 meşru iştir. - Yolu sıfırlamak açgözlü seçimle 31, bütün giriş uçlarını kesmekle 27 meşru işe mal olur; kalem kalem en verimli seçim toplamda en ucuz seçim değildir. #### Sonraki Adım Bu konu güvenliğin ölçü birimlerini kurdu. Üç eksen aynı varlığın üstünde çakıştırıldı, varlık, tehdit ve açık ayrı listelere bölündü, risk olasılık ile etkinin bileşimi olarak sıralandı, açıktan etkiye giden zincir adımlandı ve bu ders yüzeyi tek bir sayıya indirdi: **35 yol**. Artık her sorunun bir birimi var. Yine de bütün bu ölçümlerde bir şey hiç yapılmadı. Yollar sayıldı, kenarların kaldırılması denendi ve bedeli yazıldı — ama kaldırmak bir savunma değildir; işi durdurmaktır. Gerçek bir savunma kenarı yerinde bırakır ve üstüne bir denetim koyar: katman ekler, yetkiyi daraltır, bölmelere ayırır, konum temelli güveni kaldırır, kimlik doğrulamayı yetkilendirmeden ayırır, varsayılanı kapatır. Bu ilkelerin her biri **aynı 35 yol** üzerinde koşturulabilir ve her biri için aynı üç sayı yazılabilir: kaç yol kapandı, kaç yol kaldı, kaç meşru iş durdu. Sonraki konu — **Savunma İlkeleri** — altı ilkeyi tek tek bu üç sütunla ölçer. ## Savunma İlkeleri Altı savunma ilkesi aynı yol kümesi üzerinde ölçülür: derinlemesine savunmanın katman katman kapattığı yol, en az yetkinin daraltmayla kapattığı yol ve durdurduğu meşru iş, bölmelere ayırmanın bir bölme düştüğünde eriştirdiği kalem, konum temelli güven kaldırıldığında değişen yol sayısı ve istek başına ek adım, kimlik doğrulama ile yetkilendirmenin yanlış katmanda toplanmasının açtığı yol, güvenli varsayılanın bir kalem unutulduğunda açtığı yol. ### Derinlemesine Savunma Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/derinlemesine-savunma Aynı erişim grafiği üzerinde beş savunma katmanı sırayla eklenir: her katmanın kapattığı yeni yol, kalan yol, istisna gerektiren meşru akış ve yönetilen kalem sayılır. Hiçbir yeni yol kapatmayan katman bulunur ve sıranın kapanma dağılımını nasıl değiştirdiği gösterilir. Önceki konu saldırı yüzeyini sayılabilir bir birime çevirdi: bir varlığa ulaşmanın kaç ayrı yolu olduğu yazıldı. Sayılan şey açık kalan yoldu ve hiçbir savunma o sayının üzerinde koşturulmadı. Bu konu aynı ölçü birimini alır ve altı savunma ilkesini tek tek üzerinde çalıştırır. Her ders üç sütun verir: kaç yol var, ilke kaçını kapatıyor, karşılığında kaç meşru iş duruyor. Ağ modeli bir noktada genişletiliyor. Yüzey sayımı iki hedefe giden yolları saymıştı; savunma ilkelerinin ölçülebilmesi için ağın dört korunan varlığı ve satıcı bakım bağlantısı da modele giriyor, çünkü bir ilkenin hangi varlığı koruduğu ancak varlıklar ayrı ayrı sayıldığında görünür. Genişletilmiş model aynı kurgusal ağdır ve aşağıda yeniden kuruluyor; bundan sonraki altı dersin tamamı bu tek yol kümesi üzerinde koşuyor. İlk ilke **derinlemesine savunmadır** (defense in depth): tek bir denetime güvenmek yerine birbirinden bağımsız katmanlar üst üste konur, biri aşıldığında bir sonraki devrededir. Bu ifade bir karar taşımaz — kaç katman, hangi sırayla ve ne pahasına sorusunun yanıtı yoktur. Bu ders katmanları aynı grafiğe sırayla ekler ve her birinin **kapattığı yeni yolu** sayar. Yol sayımı burada savunmanın kapsamını ölçmek için yapılır; gerçek bir ağ üzerinde böyle bir sayım **yazılı yetki ve tanımlı kapsam** olmadan yürütülemez, yürütülmesi hem yasadışı hem de meslek dışıdır. - **SI1.** Ağ kurgusaldır: bölgesel ölçüm ağının dört giriş noktası, altı ara düğümü ve dört varlığı `node` ile modellenir. Ölçülen şey bu modeldir; yüzey sayımındaki daraltılmış grafiğin yerine bu genişletilmiş grafik geçer ve konu boyunca değişmez. - **SI2.** Yol, bir giriş noktasından bir varlığa giden, düğüm tekrarı olmayan adım dizisidir. - **SI3.** Katmanların hangi adımı durdurduğu ölçülmedi, seçildi. Gerçek bir ağda bu eşleme denenerek çıkarılır; dersin noktası eşlemenin kendisi değil, üzerinde yapılan sayımdır. - **SI4.** Bir katman bir adımı ya durdurur ya durdurmaz. Kısmi engelleme ve atlatma olasılığı modellenmiyor; bunlar kapanan yol sayısını düşürür, yönünü değiştirmez. - **SI5.** Meşru akış aynı grafiğin kenarlarından geçer. Bir katman meşru akışın adımını durduruyorsa o akış elle yazılan bir istisna gerektirir; istisna sayısı ve etkilediği günlük istek bedelin ölçüsüdür. - **SI6.** Yönetilen kalem sayısı her katman için verilmiş bir model değeridir: o katmanın bakımını gerektiren kural, eşleme ve dışlama satırlarının toplamı. #### Korunan Ağ ve Yol Kümesi Model üç düğüm türünü ayırır: dışarıdan erişilen giriş noktaları, aradaki servisler ve korunan varlıklar. Kenarlar bir düğümden diğerine geçilebilen adımlardır. ```js // ag.mjs — kurgusal bolgesel olcum aginin erisim grafigi ve mesru akislari (model) export const GIRIS = ['saha-uc', 'sube-agi', 'genel-uc', 'bakim-uc']; export const VARLIK = ['olcum-deposu', 'fatura-vt', 'abone-kayit', 'yapilandirma']; export const KENAR = [ ['saha-uc', 'toplayici'], ['saha-uc', 'is-emri'], ['sube-agi', 'toplayici'], ['sube-agi', 'is-emri'], ['sube-agi', 'yonetim'], ['genel-uc', 'toplayici'], ['bakim-uc', 'yonetim'], ['bakim-uc', 'kuyruk'], ['toplayici', 'kuyruk'], ['toplayici', 'olcum-deposu'], ['kuyruk', 'dogrulayici'], ['kuyruk', 'faturalama'], ['dogrulayici', 'olcum-deposu'], ['dogrulayici', 'fatura-vt'], ['faturalama', 'fatura-vt'], ['faturalama', 'abone-kayit'], ['is-emri', 'kuyruk'], ['is-emri', 'abone-kayit'], ['yonetim', 'toplayici'], ['yonetim', 'dogrulayici'], ['yonetim', 'is-emri'], ['yonetim', 'yapilandirma'], ]; // Mesru akis: gunluk kosan is; adim dizisi ayni grafigin kenarlarindan gecer. export const AKIS = [ ['saha-okuma', ['saha-uc', 'toplayici', 'kuyruk'], 1440], ['dogrulama', ['kuyruk', 'dogrulayici', 'olcum-deposu'], 1440], ['genel-okuma', ['genel-uc', 'toplayici', 'olcum-deposu'], 300], ['sube-sorgu', ['sube-agi', 'toplayici', 'olcum-deposu'], 210], ['fatura-yazimi', ['kuyruk', 'faturalama', 'fatura-vt'], 48], ['is-emri-acma', ['sube-agi', 'is-emri', 'abone-kayit'], 32], ['is-emri-kuyruk', ['sube-agi', 'is-emri', 'kuyruk'], 32], ['abone-guncelleme', ['faturalama', 'abone-kayit'], 6], ['yapilandirma-degisikligi', ['sube-agi', 'yonetim', 'yapilandirma'], 2], ['bakim-oturumu', ['bakim-uc', 'yonetim', 'toplayici'], 1], ['kuyruk-bakimi', ['bakim-uc', 'kuyruk'], 1], ['mutabakat', ['yonetim', 'dogrulayici', 'fatura-vt'], 1], ]; export const ad = (a, b) => `${a}>${b}`; export const adimlar = (d) => d.slice(0, -1).map((x, i) => ad(x, d[i + 1])); export function yollar(kapali = new Set()) { const komsu = new Map(); for (const [a, b] of KENAR) if (!kapali.has(ad(a, b))) komsu.set(a, [...(komsu.get(a) || []), b]); const s = []; const yuru = (d, y) => { if (VARLIK.includes(d)) return void s.push(y); for (const k of komsu.get(d) || []) if (!y.includes(k)) yuru(k, [...y, k]); }; for (const g of GIRIS) yuru(g, [g]); return s; } export const kesilen = (kapali) => AKIS.filter(([, d]) => adimlar(d).some((k) => kapali.has(k))); ``` ```js // kosum1.mjs — yol kumesi kurulur: giris noktasindan varliga kac ayri yol var import { GIRIS, VARLIK, KENAR, AKIS, yollar } from './ag.mjs'; const y = yollar(); const ara = [...new Set(KENAR.flat())].filter((d) => !GIRIS.includes(d) && !VARLIK.includes(d)); console.log(`giris ${GIRIS.length}, ara dugum ${ara.length}, varlik ${VARLIK.length}, kenar ${KENAR.length}, yol ${y.length}`); const say = (f) => y.reduce((m, p) => m.set(f(p), (m.get(f(p)) || 0) + 1), new Map()); const yaz = (b, m) => { console.log(`\n${b}`); for (const [k, v] of m) console.log(` ${String(k).padEnd(16)}${v}`); }; yaz('giris noktasi basina yol', say((p) => p[0])); yaz('varlik basina yol', say((p) => p.at(-1))); yaz('adim sayisina gore yol', new Map([...say((p) => p.length - 1)].sort())); yaz('ara dugumden gecen yol', new Map(ara.map((d) => [d, y.filter((p) => p.includes(d)).length]) .sort((a, b) => b[1] - a[1]))); console.log(`\nmesru akis ${AKIS.length}, gunluk mesru istek ${AKIS.reduce((s, [, , n]) => s + n, 0)}`); ``` ``` giris 4, ara dugum 6, varlik 4, kenar 22, yol 55 giris noktasi basina yol saha-uc 10 sube-agi 23 genel-uc 5 bakim-uc 17 varlik basina yol olcum-deposu 17 fatura-vt 22 abone-kayit 14 yapilandirma 2 adim sayisina gore yol 2 7 3 12 4 20 5 16 ara dugumden gecen yol kuyruk 40 yonetim 26 toplayici 25 dogrulayici 24 is-emri 20 faturalama 20 mesru akis 12, gunluk mesru istek 3513 ``` On dört düğüm ve yirmi iki kenar elli beş yol üretiyor. Yol sayısı kenar sayısının iki buçuk katıdır; grafiğe eklenen her kenar kendi başına bir yol değil, geçtiği her yolun katlanmasıdır. Şube ağı tek başına yirmi üç yolun başlangıcıdır, çünkü üç ayrı ara düğüme bağlanır. Bakım ucu yalnız iki kenara sahip olduğu hâlde on yedi yol açar: bağlandığı yönetim istasyonu dört ayrı düğüme daha bağlıdır. Bir giriş noktasının tehlikesi kaç bağlantısı olduğuyla değil, bağlandığı düğümün kaç bağlantısı olduğuyla ölçülür. Varlık dağılımı ikinci bir şeyi gösteriyor. Fatura veritabanına yirmi iki yol gidiyor, yapılandırma deposuna iki. İkisi de aynı ağda duruyor ama biri on bir kat daha çok yoldan erişilebilir durumda. Adım dağılımı ise savunmanın nereye konacağını belirler: yolların yalnız yedisi iki adımlık, otuz altısı dört adım ve üzeridir. Uzun yollar ara düğümlerin çoğundan geçer, yani ortada duran tek bir denetim onların hepsini birden keser. Son tablo o denetimin nereye konacağını doğrudan söylüyor. Kuyruk elli beş yolun kırkından geçiyor; kuyruğa giren her adımı durduran bir denetim, tek başına yolların yüzde yetmiş üçüne dokunur. Yönetim istasyonu yirmi altı, ölçüm toplayıcı yirmi beş yol taşıyor. Sıralamanın alt ucundaki iş emri ve faturalama servisleri yirmişer yolla en az yükü taşıyor. Bu sayılar savunmanın yerleştirileceği noktaları önem sırasına koyar, ancak bir uyarıyla: darboğaz aynı zamanda meşru işin de darboğazıdır. Kuyruğa konan bir denetim günde bin dört yüz kırk okuma yüklemesi ve bin dört yüz kırk doğrulama isteğinin üzerinden geçecektir. #### Katman Katman Kapanan Yol Beş katman aynı grafiğe sırayla ekleniyor. Her katman belirli adımları durduruyor; bir yol, adımlarından en az biri durdurulmuşsa kapanmış sayılıyor. ```js // katman.mjs — bes savunma katmani ve her birinin durdurdugu adim (model karari) export const KATMAN = [ ['ag-suzgeci', 22, ['saha-uc>is-emri', 'sube-agi>yonetim', 'bakim-uc>yonetim', 'bakim-uc>kuyruk']], ['kimlik-dogrulama', 14, ['genel-uc>toplayici', 'sube-agi>yonetim', 'bakim-uc>yonetim', 'yonetim>yapilandirma']], ['uc-nokta-denetimi', 9, ['saha-uc>is-emri', 'sube-agi>yonetim', 'bakim-uc>kuyruk']], ['girdi-dogrulama', 11, ['kuyruk>faturalama', 'dogrulayici>fatura-vt']], ['veri-denetimi', 7, ['dogrulayici>olcum-deposu', 'yonetim>dogrulayici']], ]; ``` ```js // kosum2.mjs — katmanlar sirayla eklenir; her katmanin kapattigi yeni yol sayilir import { yollar, kesilen } from './ag.mjs'; import { KATMAN } from './katman.mjs'; const tum = yollar().length, kapali = new Set(); let onceki = tum; console.log('katman kalem tek basina yeni kapanan kalan istisna gunluk ek adim'); for (const [k, kalem, kenarlar] of KATMAN) { const tek = tum - yollar(new Set(kenarlar)).length; kenarlar.forEach((e) => kapali.add(e)); const kalan = yollar(kapali).length, kes = kesilen(kapali); console.log(`${k.padEnd(19)}${String(kalem).padEnd(7)}${String(tek).padEnd(12)}${String(onceki - kalan).padEnd(14)}` + `${String(kalan).padEnd(7)}${String(kes.length).padEnd(9)}${kes.reduce((s, [, , n]) => s + n, 0)}`); onceki = kalan; } console.log('\nbes katmandan sonra kalan yol:'); for (const p of yollar(kapali)) console.log(` ${p.join(' > ')}`); ``` ``` katman kalem tek basina yeni kapanan kalan istisna gunluk ek adim ag-suzgeci 22 35 35 20 3 4 kimlik-dogrulama 14 31 5 15 4 304 uc-nokta-denetimi 9 22 0 15 4 304 girdi-dogrulama 11 32 9 6 6 353 veri-denetimi 7 14 3 3 7 1793 bes katmandan sonra kalan yol: saha-uc > toplayici > olcum-deposu sube-agi > toplayici > olcum-deposu sube-agi > is-emri > abone-kayit ``` İlk katman elli beş yolun otuz beşini kapatıyor ve bedeli neredeyse yok: üç meşru akış istisna gerektiriyor, bunlar günde toplam dört istek. Ağ süzgeci ucuz görünmesinin nedeni budur — sık koşan işler zaten süzgecin içinden geçen kenarlarda durur. Sonraki katmanlarda oran tersine dönüyor. Kimlik doğrulama beş yeni yol kapatıyor ama istisna gerektiren günlük istek dörtten üç yüz dörde çıkıyor, çünkü genel okuma ucu bu katmanın altına giriyor. Veri denetimi yalnız üç yol kapatıyor; karşılığında bin yedi yüz doksan üç günlük istek ek bir adım kazanıyor — doğrulama akışının tamamı bu katmandan geçiyor. Kapanan yol başına ödenen bedel ilk katmanda dokuzda bir istek, son katmanda beş yüz doksan yedi istektir. İstisna sütunu ayrı bir yük biriktiriyor. Beş katman sonunda on iki meşru akıştan yedisi elle yazılmış bir istisnaya bağlı; yani akışların yüzde elli sekizi bir denetimin dışına çıkarılmış durumda. Bir istisna kaldırıldığında ya da yanlış yazıldığında kapanan sayılan bir yol geri açılır, ancak tablo bunu göstermez — tablo istisnaların doğru olduğunu varsayar. Son üç satır bu dersin sert bulgusudur. Beş katmandan sonra elli beş yolun elli ikisi kapandı, üçü hâlâ açık. Kalan üç yol saha ucundan ölçüm deposuna, şube ağından ölçüm deposuna ve şube ağından abone kayıtlarına gidiyor — yani meşru kanalın kendisi. Katman eklemek bu üçünü kapatmaz; onları kapatmak işi durdurmaktır. Derinlemesine savunma yol sayısını sıfırlamaz, meşru kanalın genişliğine indirir. #### Bedava Sanılan Katman Tablodaki üçüncü satır sıfır yazıyor: uç nokta denetimi hiçbir yeni yol kapatmıyor. Aynı satırın sol tarafı tek başına yirmi iki yol kapattığını söylüyor. İki sayı çelişmiyor; katmanın değerinin sıraya bağlı olduğunu söylüyor. ```js // kosum3.mjs — sira degisince kapanan yol nasil dagiliyor, katman cikarilinca ne oluyor import { yollar } from './ag.mjs'; import { KATMAN } from './katman.mjs'; const tum = yollar().length, kisa = (a) => a.split('-')[0]; function kos(liste) { const kapali = new Set(), m = new Map(); let onceki = tum; for (const [a, , kenarlar] of liste) { kenarlar.forEach((e) => kapali.add(e)); const kalan = yollar(kapali).length; m.set(a, onceki - kalan); onceki = kalan; } return [m, onceki, liste.reduce((s, [, n]) => s + n, 0)]; } const uc = KATMAN.find(([a]) => a.startsWith('uc-')); console.log(`sira ${KATMAN.map(([a]) => kisa(a).padEnd(9)).join('')}kalan kalem`); for (const [etiket, liste] of [['yazildigi sira', KATMAN], ['uc nokta basta', [uc, ...KATMAN.filter((k) => k !== uc)]], ['uc nokta cikarilmis', KATMAN.filter((k) => k !== uc)]]) { const [m, kalan, kalem] = kos(liste); console.log(`${etiket.padEnd(21)}${KATMAN.map(([a]) => String(m.get(a) ?? '-').padEnd(9)).join('')}` + `${String(kalan).padEnd(7)}${kalem}`); } const tek = KATMAN.reduce((s, [, , k]) => s + tum - yollar(new Set(k)).length, 0); console.log(`\ntek basina toplami ${tek}, gercekte kapanan ${tum - kos(KATMAN)[1]}, ` + `kalem basina ${((tum - kos(KATMAN)[1]) / kos(KATMAN)[2]).toFixed(2)} yol`); ``` ``` sira ag kimlik uc girdi veri kalan kalem yazildigi sira 35 5 0 9 3 3 63 uc nokta basta 13 5 22 9 3 3 63 uc nokta cikarilmis 35 5 - 9 3 3 54 tek basina toplami 134, gercekte kapanan 52, kalem basina 0.83 yol ``` Üç satır aynı sonuca varıyor: kalan yol her durumda üç. Sıra değiştiğinde yalnız kapanmanın dağılımı değişiyor. Uç nokta denetimi başa alındığında yirmi iki yol ona, on üç yol ağ süzgecine yazılıyor; sonda kaldığında ona sıfır düşüyor. Bir katmanın "kaç yol kapattığı" tek başına bir sayı değildir, ondan önce ne olduğuna bağlıdır. Üçüncü satır asıl kararı veriyor. Uç nokta denetimi tamamen çıkarıldığında kalan yol yine üç, ancak yönetilen kalem altmış üçten elli dörde iniyor. Bu yol kümesi üzerinde katman dokuz kalemlik bakım yükü karşılığında hiçbir şey kazandırmıyor. "Bir katman daha eklemek zarar vermez" cümlesi burada sayıyla yanlışlanıyor: eklemenin bedeli sıfır değil, dokuz kalemdir. Karar bu kadar kısa değildir. Ölçüm, ağ süzgecinin ayakta kaldığı varsayımı altında yapıldı. Süzgeç aşılırsa uç nokta denetimi tek başına yirmi iki yolu kapatan katmandır ve o durumda kalan yol üç değil, çok daha fazla olur. Doğru okuma şudur: bu katman kapsam kazandırmıyor, **yedeklilik** kazandırıyor — ve yedekliliğin bedeli dokuz kalemdir. Üst satırdaki toplam da aynı yanılgının sayısal karşılığıdır: tek başına ölçümlerin toplamı yüz otuz dört, gerçekte kapanan elli iki. Aynı yolu iki kez sayan bir savunma raporu, kapsamını iki buçuk kat büyük gösterir. Modelin sessiz varsayımı da burada ortaya çıkıyor. Her katman bağımsız kabul edildi: birinin düşmesi diğerini etkilemiyor. Gerçekte katmanların birçoğu aynı yönetim düzlemi üzerinden yapılandırılır ve aynı kimlik kümesiyle yönetilir. Ağ süzgecinin kural tablosunu değiştirebilen bir özne, uç nokta denetiminin dışlama listesini de değiştirebiliyorsa iki katman tek katman sayılır ve tablodaki elli iki sayısı üst sınırdır. Yönetilen kalem sayısının ikinci anlamı budur: altmış üç kalem yalnız bakım yükü değil, aynı zamanda **yanlış yapılandırılabilecek altmış üç yerdir**. Derinlemesine savunmanın ölçüsü katman sayısı değil, katmanların gerçekten kaç ayrı denetim yüzeyine dağıldığıdır. #### Özet - Kurgusal ağ dört giriş, altı ara düğüm ve dört varlıkla yirmi iki kenar taşıyor; giriş noktasından varlığa 55 ayrı yol çıkıyor. Fatura veritabanına 22 yol gidiyor, yapılandırma deposuna 2 — aynı ağda erişilebilirlik on bir kat farklıdır. - Beş katman sırayla eklendiğinde 55 yolun 52'si kapanıyor, 3'ü açık kalıyor. Kalan üç yol meşru kanalın kendisidir; katman eklemek onları kapatmaz. - Kapanan yol başına bedel katman ilerledikçe büyüyor: ağ süzgeci 35 yolu günde 4 istisna isteğiyle kapatıyor, veri denetimi 3 yolu günde 1.793 ek adımla. - Uç nokta denetimi sırasında 0 yeni yol kapatıyor ama tek başına 22 yol kapatıyor; katmanın sayısı kendisine değil, kendisinden öncekilere bağlıdır. - Katman çıkarıldığında kalan yol yine 3, yönetilen kalem 63'ten 54'e iniyor. Katman kapsam değil yedeklilik kazandırıyor ve yedekliliğin bedeli 9 kalemdir. - Katmanların tek başına kapattığı yolların toplamı 134, gerçekte kapanan 52. Üst üste sayım savunmanın kapsamını 2,5 kat şişirir. #### Sonraki Adım Bu ders katmanları ağ üzerinde konumlandırdı ve her birinin kaç yol kapattığını saydı. Kapanan yolların hepsi bir adımın **geçilememesiyle** kapandı: süzgeç geçirmedi, kimlik tanınmadı, girdi kabul edilmedi. Ama grafikte bir adımı geçmenin ikinci bir koşulu daha var — o adımı atan öznenin hedef kaleme dokunma **izni**. Beş katmanın hiçbiri o izne bakmadı; hepsi adımın kendisini denetledi. Sonraki dersin sorusu izin kümesidir: her özneye verilen izin kalemleri yol kümesine çevrildiğinde kaç yol açılıyor, izinler gerçekten kullanılana kadar daraltıldığında kaç yol kapanıyor ve daraltmanın karşılığında hangi meşru akış, günde kaç istekle duruyor. ### En Az Yetki Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/en-az-yetki Aynı erişim grafiğinin her adımı bir izin kalemine bağlanır ve her kalemin açtığı yol ile taşıdığı günlük meşru istek yan yana sayılır. Meşru trafik taşımayan kalemlerin bedelsiz kaldırılması ölçülür, ardından yol başına durdurulan istek eşiği taranarak daraltmanın durduğu yer bulunur. Önceki ders beş savunma katmanını aynı grafiğe ekledi ve elli beş yolun elli ikisini kapattı. Kapanan yolların hepsi bir adımın geçilememesiyle kapandı: süzgeç geçirmedi, kimlik tanınmadı, girdi kabul edilmedi. Katmanların hiçbiri ikinci bir soruyu sormadı — adımı atan özne hedef kaleme dokunma **iznine** sahip mi? Bu ders o soruyu sorar ve grafiği izin kümesi olarak yeniden okur. **En az yetki** (least privilege), her özneye işini yapmaya yeten en dar izin kümesinin verilmesidir. Bulut Yönetişimi, Güvenlik ve Maliyet kursunda aynı ilke verilen izin ile kullanılan izin oranı üzerinden ölçülmüştü; burada ölçü birimi yol sayısıdır. Bir izin kalemi kaldırıldığında grafikten bir adım düşer ve o adımdan geçen bütün yollar kapanır. Aynı adımdan meşru işler de geçtiği için her kaldırma iki sayı üretir: kapanan yol ve duran günlük istek. İlke ancak ikisi birlikte yazıldığında ölçülmüş sayılır. - **SI7.** İzin kalemi `(özne, kalem, eylem)` üçlüsüdür ve grafikteki bir adıma birebir karşılık gelir. Yirmi iki kenar, yirmi iki izin kalemi demektir. - **SI8.** Eylem eşlemesi bir model kararıdır: her adıma `oku`, `yaz` ya da `yonet` atandı. Gerçekte bir adım birden çok eylem gerektirebilir; bu kalem sayısını büyütür, ölçünün yönünü değiştirmez. - **SI9.** Bir izin kalemi ya verilmiştir ya verilmemiştir. Koşul ifadesi, kayıt düzeyinde daraltma ve süreli izin modellenmiyor. - **SI10.** Günlük meşru istek sayıları önceki dersteki akış modelinden gelir; ölçülmedi, seçildi. - **SI11.** Bir meşru akış, adımlarından biri kapandığında tamamen durur. Yedek yol üzerinden devam etme modellenmiyor; bu, durma sayısını yüksek gösterir. #### Adımın İkinci Koşulu Grafik değişmedi; üzerine ikinci bir okuma bindi. Her kenar artık bir izin kaleminin adıdır ve o kalem kaldırıldığında kenar da düşer. ```js // ag.mjs — kurgusal bolgesel olcum aginin erisim grafigi ve mesru akislari (model) export const GIRIS = ['saha-uc', 'sube-agi', 'genel-uc', 'bakim-uc']; export const VARLIK = ['olcum-deposu', 'fatura-vt', 'abone-kayit', 'yapilandirma']; export const KENAR = [ ['saha-uc', 'toplayici'], ['saha-uc', 'is-emri'], ['sube-agi', 'toplayici'], ['sube-agi', 'is-emri'], ['sube-agi', 'yonetim'], ['genel-uc', 'toplayici'], ['bakim-uc', 'yonetim'], ['bakim-uc', 'kuyruk'], ['toplayici', 'kuyruk'], ['toplayici', 'olcum-deposu'], ['kuyruk', 'dogrulayici'], ['kuyruk', 'faturalama'], ['dogrulayici', 'olcum-deposu'], ['dogrulayici', 'fatura-vt'], ['faturalama', 'fatura-vt'], ['faturalama', 'abone-kayit'], ['is-emri', 'kuyruk'], ['is-emri', 'abone-kayit'], ['yonetim', 'toplayici'], ['yonetim', 'dogrulayici'], ['yonetim', 'is-emri'], ['yonetim', 'yapilandirma'], ]; // Mesru akis: gunluk kosan is; adim dizisi ayni grafigin kenarlarindan gecer. export const AKIS = [ ['saha-okuma', ['saha-uc', 'toplayici', 'kuyruk'], 1440], ['dogrulama', ['kuyruk', 'dogrulayici', 'olcum-deposu'], 1440], ['genel-okuma', ['genel-uc', 'toplayici', 'olcum-deposu'], 300], ['sube-sorgu', ['sube-agi', 'toplayici', 'olcum-deposu'], 210], ['fatura-yazimi', ['kuyruk', 'faturalama', 'fatura-vt'], 48], ['is-emri-acma', ['sube-agi', 'is-emri', 'abone-kayit'], 32], ['is-emri-kuyruk', ['sube-agi', 'is-emri', 'kuyruk'], 32], ['abone-guncelleme', ['faturalama', 'abone-kayit'], 6], ['yapilandirma-degisikligi', ['sube-agi', 'yonetim', 'yapilandirma'], 2], ['bakim-oturumu', ['bakim-uc', 'yonetim', 'toplayici'], 1], ['kuyruk-bakimi', ['bakim-uc', 'kuyruk'], 1], ['mutabakat', ['yonetim', 'dogrulayici', 'fatura-vt'], 1], ]; export const ad = (a, b) => `${a}>${b}`; export const adimlar = (d) => d.slice(0, -1).map((x, i) => ad(x, d[i + 1])); export function yollar(kapali = new Set()) { const komsu = new Map(); for (const [a, b] of KENAR) if (!kapali.has(ad(a, b))) komsu.set(a, [...(komsu.get(a) || []), b]); const s = []; const yuru = (d, y) => { if (VARLIK.includes(d)) return void s.push(y); for (const k of komsu.get(d) || []) if (!y.includes(k)) yuru(k, [...y, k]); }; for (const g of GIRIS) yuru(g, [g]); return s; } export const kesilen = (kapali) => AKIS.filter(([, d]) => adimlar(d).some((k) => kapali.has(k))); ``` ```js // yetki.mjs — her adimin gerektirdigi izin kalemi: (ozne, kalem, eylem) export const EYLEM = { 'saha-uc>toplayici': 'yaz', 'saha-uc>is-emri': 'yaz', 'sube-agi>toplayici': 'oku', 'sube-agi>is-emri': 'yaz', 'sube-agi>yonetim': 'yonet', 'genel-uc>toplayici': 'oku', 'bakim-uc>yonetim': 'yonet', 'bakim-uc>kuyruk': 'yonet', 'toplayici>kuyruk': 'yaz', 'toplayici>olcum-deposu': 'yaz', 'kuyruk>dogrulayici': 'oku', 'kuyruk>faturalama': 'oku', 'dogrulayici>olcum-deposu': 'yaz', 'dogrulayici>fatura-vt': 'yaz', 'faturalama>fatura-vt': 'yaz', 'faturalama>abone-kayit': 'yaz', 'is-emri>kuyruk': 'yaz', 'is-emri>abone-kayit': 'yaz', 'yonetim>toplayici': 'yonet', 'yonetim>dogrulayici': 'yonet', 'yonetim>is-emri': 'yonet', 'yonetim>yapilandirma': 'yaz', }; export const kalemAdi = (k) => `${k.split('>')[0]}.${k.split('>')[1]}.${EYLEM[k]}`; ``` ```js // kosum1.mjs — izin matrisi: her kalem kac yol aciyor, kac gunluk mesru istek tasiyor import { AKIS, KENAR, ad, adimlar, yollar } from './ag.mjs'; import { kalemAdi } from './yetki.mjs'; const y = yollar(), kalem = KENAR.map(([a, b]) => ad(a, b)); const yolu = (k) => y.filter((p) => adimlar(p).includes(k)).length; const istek = (k) => AKIS.filter(([, d]) => adimlar(d).includes(k)).reduce((s, [, , n]) => s + n, 0); console.log(`izin kalemi ${kalem.length}, yol ${y.length}, gunluk mesru istek ${AKIS.reduce((s, [, , n]) => s + n, 0)}`); console.log('\nizin kalemi actigi yol gunluk mesru istek'); for (const [k, a, i] of kalem.map((k) => [k, yolu(k), istek(k)]).sort((p, q) => q[1] - p[1])) console.log(`${kalemAdi(k).padEnd(30)}${String(a).padEnd(12)}${i}`); const bos = kalem.filter((k) => istek(k) === 0); console.log(`\nmesru trafik tasimayan kalem ${bos.length}: ${bos.map(kalemAdi).join(', ')}`); ``` ``` izin kalemi 22, yol 55, gunluk mesru istek 3513 izin kalemi actigi yol gunluk mesru istek toplayici.kuyruk.yaz 20 1440 kuyruk.dogrulayici.oku 20 1440 kuyruk.faturalama.oku 20 48 is-emri.kuyruk.yaz 16 32 sube-agi.yonetim.yonet 13 2 bakim-uc.yonetim.yonet 13 1 dogrulayici.olcum-deposu.yaz 12 1440 dogrulayici.fatura-vt.yaz 12 1 faturalama.fatura-vt.yaz 10 48 faturalama.abone-kayit.yaz 10 6 yonetim.toplayici.yonet 10 1 yonetim.is-emri.yonet 10 0 saha-uc.toplayici.yaz 5 1440 saha-uc.is-emri.yaz 5 0 sube-agi.toplayici.oku 5 210 sube-agi.is-emri.yaz 5 64 genel-uc.toplayici.oku 5 300 toplayici.olcum-deposu.yaz 5 510 bakim-uc.kuyruk.yonet 4 1 is-emri.abone-kayit.yaz 4 32 yonetim.dogrulayici.yonet 4 1 yonetim.yapilandirma.yaz 2 2 mesru trafik tasimayan kalem 2: saha-uc.is-emri.yaz, yonetim.is-emri.yonet ``` Tablo iki sütunu yan yana koyduğu için okunması gerekenden farklı okunur. Sol sütun yüksek olan kalem tehlikeli, sağ sütun yüksek olan kalem vazgeçilmez değildir; karar iki sütunun **oranına** bağlıdır. Kuyruğa yazma izni yirmi yol açıyor ama günde bin dört yüz kırk meşru isteği de taşıyor. Doğrulayıcının fatura veritabanına yazma izni de on iki yol açıyor ve günde yalnız bir meşru istek taşıyor. İki kalem yakın sayıda yol açar, ama biri kaldırıldığında ağ durur, diğeri kaldırıldığında günde bir mutabakat işi durur. Aynı satır çiftini karşılaştırmak ilkeyi somutlaştırıyor. Şube ağının yönetim istasyonuna yönetme izni on üç yol açıyor ve günde iki istek taşıyor; bakım ucununki de on üç yol açıyor, bir istek taşıyor. Yirmi iki kalemin dokuzu günde beşten az istek taşıyor ve bunlar toplamda yolların çoğunu açan kalemlerdir. En az yetki ilkesinin işe yaradığı yer tam olarak burasıdır: seyrek kullanılan ama geniş açan kalemler. Eylem sütunu okunmadığı hâlde tabloyu açıklıyor. Altı kalem `yonet` eylemi taşıyor ve bu altısının taşıdığı günlük meşru istek toplamı altıdır; buna karşılık dördü en az on yol açıyor. Yönetme izni doğası gereği geniştir: bir düğümü yönetebilen özne o düğümün bütün çıkış adımlarını da kullanabilir. Tabloda yönetim istasyonunun üç ayrı yönetme izni ayrı satırlar hâlinde duruyor ama üçü de aynı öznenin elinde toplanıyor. İzin kalemlerini tek tek saymak bu yığılmayı gizler; yol sayımı ise gizlemez, çünkü aynı öznenin izinleri aynı yollarda birleşir. Son satır ise ilkenin en ucuz kısmını veriyor. İki kalem hiçbir meşru istek taşımıyor: saha ucunun iş emri servisine yazma izni ve yönetim istasyonunun iş emri servisini yönetme izni. İkisi de verildi, ikisi de kullanılmıyor. #### Daraltma Sınırı Kaldırma sırası önemlidir. Önce bedelsiz kalemler, sonra yol başına durdurduğu istek oranına göre sıralanmış kalemler kaldırılıyor. Eşik, bir kalemin kaldırılmasının kabul edildiği en düşük `açtığı yol / taşıdığı istek` değeridir. ```js // kosum2.mjs — daraltma: once bedelsiz kalemler, sonra yol/istek esigi taranir import { AKIS, KENAR, ad, adimlar, yollar } from './ag.mjs'; const y = yollar(), tum = y.length, kalem = KENAR.map(([a, b]) => ad(a, b)); const yolu = (k) => y.filter((p) => adimlar(p).includes(k)).length; const istek = (k) => AKIS.filter(([, d]) => adimlar(d).includes(k)).reduce((s, [, , n]) => s + n, 0); const bos = kalem.filter((k) => istek(k) === 0); console.log(`bedelsiz daraltma: ${bos.length} kalem kaldirildi, kalan yol ${yollar(new Set(bos)).length}, duran mesru istek 0`); console.log('\nesik kaldirilan kalan duran duran kapanan yol basina'); console.log(' kalem yol akis gunluk duran istek'); for (const t of [Infinity, 10, 4, 1, 0.4, 0.1, 0]) { const kap = new Set([...bos, ...kalem.filter((k) => istek(k) > 0 && yolu(k) / istek(k) >= t)]); const kalan = yollar(kap).length; const kes = AKIS.filter(([, d]) => adimlar(d).some((k) => kap.has(k))); const dur = kes.reduce((s, [, , n]) => s + n, 0); console.log(`${(t === Infinity ? '-' : String(t)).padEnd(6)}${String(kap.size).padEnd(12)}${String(kalan).padEnd(7)}` + `${String(kes.length).padEnd(7)}${String(dur).padEnd(8)}${(dur / (tum - kalan)).toFixed(1)}`); } ``` ``` bedelsiz daraltma: 2 kalem kaldirildi, kalan yol 40, duran mesru istek 0 esik kaldirilan kalan duran duran kapanan yol basina kalem yol akis gunluk duran istek - 2 40 0 0 0.0 10 5 21 2 2 0.1 4 8 16 4 5 0.1 1 10 12 5 11 0.3 0.4 12 7 7 91 1.9 0.1 14 6 8 123 2.5 0 22 0 12 3513 63.9 ``` İlk satır ilkenin bedava kısmıdır. İki kullanılmayan kalem kaldırıldığında elli beş yolun on beşi kapanıyor ve hiçbir meşru iş durmuyor. Yolların yüzde yirmi yedisi sıfır bedelle gitti; bu iki kalem, kimsenin fark etmediği ve hiç kullanılmadığı için de fark edilemeyecek olan kalemlerdi. İkinci ve üçüncü satırlar ilkenin ucuz kısmıdır. Eşik on olduğunda beş kalem kaldırılıyor, kalan yol kırktan yirmi bire iniyor ve karşılığında günde iki istek duruyor. Eşik dörde indiğinde kalan yol on altı, duran istek beş. Otuz dokuz yol, günde beş isteğin bedeliyle kapandı — kapanan yol başına onda bir istek. Duran akış sütunu hangi işlerin sırayla düştüğünü söylüyor ve sıra rastgele değil. Eşik on iken duran iki akış, günde birer istek taşıyan bakım oturumu ile mutabakattır; eşik dörde inince kuyruk bakımı ve yapılandırma değişikliği eklenir. Yüksek eşikte kaldırılan kalemler seyrek kullanılanlar olduğu için, ilk duran işler de seyrek koşan işlerdir: bakım, mutabakat, elle yapılan yapılandırma. Bunlar günlük hacimde görünmez ama gerekli oldukları anda gereklidir ve o an genellikle bir arıza anıdır. Kalan sekiz akış — okuma yükleme, doğrulama, sorgu, faturalama — ancak eşik sıfır virgül dördün altına inince düşmeye başlar. Dördüncü satırdan sonra eğri kırılıyor. Eşik birden sıfır virgül dörde inerken kalan yol on ikiden yediye düşüyor, ama duran günlük istek on birden doksan bire çıkıyor. Beş yol daha kapatmanın bedeli seksen istek, yani yol başına on altı istek — bir önceki adımın on katından fazlası. Eşik sıfıra indirildiğinde bütün yollar kapanıyor ve on iki meşru akışın tamamı, günde üç bin beş yüz on üç istek duruyor. Ağ artık güvenlidir ve artık ağ değildir. #### Kırk Üç Yolun Fiyatı Tablo bir eğri çiziyor ve eğrinin adı en az yetkinin gerçek şeklidir. Elli beş yolun kırk üçü günde on bir isteğin bedeliyle kapatılabiliyor; geri kalan on iki yol için ödenmesi gereken üç bin beş yüz iki istektir. Yolların yüzde yetmiş sekizi bedelin yüzde sıfır virgül üçüyle kapanıyor. Aynı eğri, en az yetkinin neden yarım bırakıldığını da açıklıyor. Kolay kısmı bittiğinde geriye kalan iş, her adımda bir meşru akışı durdurmayı göze almayı gerektirir; bu da bir güvenlik kararı değil, işletme kararıdır ve güvenlik ekibinin tek başına veremeyeceği bir karardır. Eşiğin nerede durduğu bu yüzden ölçümden değil, durdurulmasına razı olunan işten çıkar. Bu oran ilkenin nasıl uygulanacağını da söylüyor. Daraltmayı "hangi izin fazla" sorusuyla başlatmak yanlış sıralamadır; doğru sıralama "hangi izin çok yol açıp az iş taşıyor" sorusudur. İki soru aynı cevabı vermez: kuyruğa yazma izni yirmi yolla listenin en tepesindedir ama günde bin dört yüz kırk istek taşıdığı için son kaldırılacak kalemler arasındadır. Yönetim istasyonunun iş emri servisini yönetme izni ise on yolla listenin ortasındadır ve ilk kaldırılacak kalemdir, çünkü hiçbir iş taşımaz. Kalan on iki yolun neden pahalı olduğu da tablodan okunuyor. O yollar meşru akışların üzerinden geçtiği kenarlardan oluşuyor: saha ucundan toplayıcıya, toplayıcıdan kuyruğa, kuyruktan doğrulayıcıya. Bir saldırı yolu ile bir iş akışı burada aynı kenarı paylaşıyor ve izin kalemi ikisini ayırt edemiyor, çünkü izin kalemi yalnız "kim, neye, ne yapabilir" sorusunu yanıtlar. En az yetkinin sınırı bu ayırt edememedir. Daraltma yolları meşru kanalın genişliğine indirir ve orada durur — önceki derste beş katmanın durduğu yerin aynısı, farklı bir yoldan. Tablonun göstermediği iki şey de kararın parçasıdır. Birincisi, daraltma bir kez yapılıp bitmez: ağa bir servis eklendiğinde kenar sayısı büyür, yeni kenarların açtığı yollar ilk gün geniş verilir ve eşik yeniden taranana kadar açık kalır. Ölçüm bir andaki fotoğraftır, sürekli bir durum değil. İkincisi, kaldırılan her kalem bir yapılandırma değişikliğidir ve o değişikliğin kendisi yanlış yazılabilir. Bedelsiz görünen ilk iki kalem gerçekte de bedelsizdir, ancak eşik birin altına indiğinde kaldırılan kalemlerin çoğu seyrek koşan işlere aittir — bir kalem yanlış kaldırıldığında bunun anlaşılması, o işin bir sonraki koşma zamanını bekler. Yol sayısı anında düşer, durma haftalar sonra görünür. #### Özet - Grafiğin yirmi iki kenarı yirmi iki izin kalemine karşılık geliyor. Her kalem iki sayı taşır: açtığı yol ve taşıdığı günlük meşru istek; karar bu ikisinin oranıyla verilir. - Yakın sayıda yol açan iki kalem çok farklı olabilir: kuyruğa yazma izni 20 yol açıyor ve günde 1.440 istek taşıyor, doğrulayıcının fatura yazma izni 12 yol açıyor ve günde 1 istek taşıyor. - İki izin kalemi hiçbir meşru istek taşımıyor. Kaldırıldıklarında 55 yolun 15'i sıfır bedelle kapanıyor — yolların %27'si, kimsenin fark etmediği iki kalemden geliyordu. - Eşik taraması eğrinin kırıldığı yeri veriyor: 43 yol günde 11 isteğin bedeliyle kapanıyor, kalan 12 yol için 3.502 istek gerekiyor. Yolların %78'i bedelin %0,3'üyle kapanıyor. - Bütün izinler kaldırıldığında kalan yol 0, duran günlük istek 3.513: on iki meşru akışın tamamı. Tam daraltma, ağın işlevini kaldırmakla aynı şeydir. - Daraltma sıralaması "hangi izin fazla" ile değil "hangi izin çok yol açıp az iş taşıyor" ile yapılır; iki soru farklı sıralama üretir. #### Sonraki Adım Bu ders izin kalemlerini tek tek kaldırdı ve her kaldırmanın bedelini saydı. Ama bütün ölçüm bir varsayım üzerinde durdu: bir adım kapandığında yalnız o adım kapanıyor, düğümlerin kendisi yerinde kalıyor. Gerçek bir olayda kapanan şey bir adım değil, bir düğümdür — bir servis ele geçirilir ve o servisin sahip olduğu bütün izinler saldırganın eline geçer. Kırk üç yolu kapatan daraltma, ele geçirilen düğümün kendi izinleriyle açtığı yolları kapatmaz. Sonraki dersin sorusu bu yüzden düğümlerin nasıl gruplandığıdır: ağ bölmelere ayrıldığında bir bölme düştüğünde kaç kaleme erişiliyor, bölme sayısı arttıkça bu sayı nasıl azalıyor ve bölmeler arasında koşan meşru trafiğin bedeli kaç geçit ediyor. ### Yalıtım Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/yalitim Aynı ağ yedi ayrı bölme şemasıyla kurulur ve bir düğüm düştüğünde erişilen kalem sayılır. Geçit sayısı, geçitten geçen günlük meşru istek ve bölme sayısının erişilen varlığı ne kadar daralttığı birlikte ölçülür; sınırın nereye çizildiğinin bölme sayısından daha belirleyici olduğu gösterilir. Önceki ders izin kalemlerini tek tek kaldırdı ve kırk üç yolu günde on bir isteğin bedeliyle kapattı. Ölçümün tamamı bir varsayım üzerinde durdu: kapanan şey bir adımdır, düğümler yerinde kalır. Gerçek bir olayda kapanan şey adım değil düğümdür — bir servis ele geçirilir ve o andan sonra saldırgan o servisin durduğu yerden hareket eder. O yerden nereye gidilebileceği izin kümesiyle değil, **ağın şekliyle** belirlenir. **Yalıtım**, düğümleri bölmelere ayırıp (compartmentalization) bölmeler arasındaki geçişi kısıtlamaktır. Konteynerler kursunda aynı kavram çalışma zamanı sınırları üzerinden ele alınmıştı; burada ölçülen şey mekanizma değil, sonuçtur: bir bölme düştüğünde **kaç kaleme erişiliyor**. Bu dersin üç sütunu erişilen kalem, geçit sayısı ve geçitten geçen günlük meşru istektir. - **SI12.** Bir bölmenin içinde serbest dolaşılır. Düşen düğüm kendi bölmesindeki bütün düğümlere ulaşır; bu, düz bir ağda düğümler arasında ilan edilmemiş bağlantıların da bulunduğu gerçeğini modeller. - **SI13.** Bölmeler arasında yalnız **geçit** üzerinden geçilir. Geçit kümesi meşru akışlardan türetilir: bir akışın adımı bölme sınırını geçiyorsa o adım geçit olarak açılır. - **SI14.** Geçit, açıldığı yönde düşen düğüm için de açıktır. Geçidin kendisi bir denetim taşımıyor; taşısaydı bu, önceki iki dersin ölçtüğü şey olurdu. - **SI15.** Erişilen kalem, düşen düğümün ulaşabildiği düğüm sayısıdır; düğümün kendisi sayılmaz. Varlık sütunu bunların içinden korunan dört kalemi ayrı sayar. - **SI16.** Bölme şemaları seçilmiş model kararlarıdır. Gerçekte bölme sınırı ağ topolojisi, yerleşim ve işletim sınırlarıyla birlikte çizilir; bu ders yalnız sınırın **sonucunu** ölçer. #### Bölme Şemaları ve Geçitler Dört şema aynı düğüm kümesini farklı biçimde gruplar: tek bölme, dış ile iç ayrımı, dört katmanlı ayrım ve her düğümün kendi bölmesi. Şemaların hiçbiri grafiği değiştirmiyor; değişen tek şey hangi geçişin bir sınırı kestiğidir. Sınırı kesen bir adım meşru bir akışa aitse geçit olarak açık kalır, değilse kapanır — yani bölmeleme kararı, meşru akış listesi tarafından belirlenir. Bu bağımlılık dersin sonunda karşımıza çıkacak sonucun da kaynağıdır. ```js // ag.mjs — kurgusal bolgesel olcum aginin erisim grafigi ve mesru akislari (model) export const GIRIS = ['saha-uc', 'sube-agi', 'genel-uc', 'bakim-uc']; export const VARLIK = ['olcum-deposu', 'fatura-vt', 'abone-kayit', 'yapilandirma']; export const KENAR = [ ['saha-uc', 'toplayici'], ['saha-uc', 'is-emri'], ['sube-agi', 'toplayici'], ['sube-agi', 'is-emri'], ['sube-agi', 'yonetim'], ['genel-uc', 'toplayici'], ['bakim-uc', 'yonetim'], ['bakim-uc', 'kuyruk'], ['toplayici', 'kuyruk'], ['toplayici', 'olcum-deposu'], ['kuyruk', 'dogrulayici'], ['kuyruk', 'faturalama'], ['dogrulayici', 'olcum-deposu'], ['dogrulayici', 'fatura-vt'], ['faturalama', 'fatura-vt'], ['faturalama', 'abone-kayit'], ['is-emri', 'kuyruk'], ['is-emri', 'abone-kayit'], ['yonetim', 'toplayici'], ['yonetim', 'dogrulayici'], ['yonetim', 'is-emri'], ['yonetim', 'yapilandirma'], ]; // Mesru akis: gunluk kosan is; adim dizisi ayni grafigin kenarlarindan gecer. export const AKIS = [ ['saha-okuma', ['saha-uc', 'toplayici', 'kuyruk'], 1440], ['dogrulama', ['kuyruk', 'dogrulayici', 'olcum-deposu'], 1440], ['genel-okuma', ['genel-uc', 'toplayici', 'olcum-deposu'], 300], ['sube-sorgu', ['sube-agi', 'toplayici', 'olcum-deposu'], 210], ['fatura-yazimi', ['kuyruk', 'faturalama', 'fatura-vt'], 48], ['is-emri-acma', ['sube-agi', 'is-emri', 'abone-kayit'], 32], ['is-emri-kuyruk', ['sube-agi', 'is-emri', 'kuyruk'], 32], ['abone-guncelleme', ['faturalama', 'abone-kayit'], 6], ['yapilandirma-degisikligi', ['sube-agi', 'yonetim', 'yapilandirma'], 2], ['bakim-oturumu', ['bakim-uc', 'yonetim', 'toplayici'], 1], ['kuyruk-bakimi', ['bakim-uc', 'kuyruk'], 1], ['mutabakat', ['yonetim', 'dogrulayici', 'fatura-vt'], 1], ]; export const ad = (a, b) => `${a}>${b}`; export const adimlar = (d) => d.slice(0, -1).map((x, i) => ad(x, d[i + 1])); export function yollar(kapali = new Set()) { const komsu = new Map(); for (const [a, b] of KENAR) if (!kapali.has(ad(a, b))) komsu.set(a, [...(komsu.get(a) || []), b]); const s = []; const yuru = (d, y) => { if (VARLIK.includes(d)) return void s.push(y); for (const k of komsu.get(d) || []) if (!y.includes(k)) yuru(k, [...y, k]); }; for (const g of GIRIS) yuru(g, [g]); return s; } export const kesilen = (kapali) => AKIS.filter(([, d]) => adimlar(d).some((k) => kapali.has(k))); ``` ```js // bolme.mjs — bolme semalari ve bir dugum dustugunde erisilen kalemin hesabi import { KENAR, AKIS, GIRIS, VARLIK, ad, adimlar } from './ag.mjs'; export const DUGUM = [...new Set(KENAR.flat())]; export const ARA = DUGUM.filter((d) => !GIRIS.includes(d) && !VARLIK.includes(d)); const SERVIS = ['toplayici', 'kuyruk', 'dogrulayici', 'faturalama', 'is-emri']; const kur = (f) => Object.fromEntries(DUGUM.map((d) => [d, f(d)])); export const SEMA = [ ['tek-bolme', kur(() => 'ag')], ['iki-bolme', kur((d) => (GIRIS.includes(d) ? 'dis' : 'ic'))], ['dort-bolme', kur((d) => (GIRIS.includes(d) ? 'dis' : SERVIS.includes(d) ? 'servis' : d === 'yonetim' ? 'yonetim' : 'veri'))], ['dugum-basina', kur((d) => d)], ]; const MESRU = new Set(AKIS.flatMap(([, d]) => adimlar(d))); // Bir bolmenin icinde serbest dolasilir; bolmeler arasi yalniz acik gecitten gecilir. export function cozumle(harita) { const capraz = KENAR.map(([a, b]) => ad(a, b)).filter((k) => harita[k.split('>')[0]] !== harita[k.split('>')[1]]); const gecit = capraz.filter((k) => MESRU.has(k)), uye = {}, komsu = new Map(); for (const d of DUGUM) (uye[harita[d]] ||= []).push(d); for (const g of gecit) { const [a, b] = g.split('>'); komsu.set(harita[a], [...(komsu.get(harita[a]) || []), harita[b]]); } const erisilen = (d) => { const gor = new Set([harita[d]]), yig = [harita[d]]; while (yig.length) for (const x of komsu.get(yig.pop()) || []) if (!gor.has(x)) { gor.add(x); yig.push(x); } return [...gor].flatMap((b) => uye[b]).filter((x) => x !== d); }; return { gecit, kapali: capraz.filter((k) => !MESRU.has(k)), erisilen }; } ``` ```js // kosum1.mjs — sema sema: gecit sayisi, erisilen kalem ve gecitten gecen mesru istek import { AKIS, VARLIK, adimlar } from './ag.mjs'; import { SEMA, ARA, cozumle } from './bolme.mjs'; const ort = (a) => (a.reduce((s, x) => s + x, 0) / a.length).toFixed(1); console.log('sema bolme gecit kapali ort kalem en kotu ort varlik gecit istek'); for (const [nm, harita] of SEMA) { const { gecit, kapali, erisilen } = cozumle(harita); const er = ARA.map(erisilen); const gi = AKIS.filter(([, d]) => adimlar(d).some((k) => gecit.includes(k))).reduce((s, [, , n]) => s + n, 0); console.log(`${nm.padEnd(14)}${String(new Set(Object.values(harita)).size).padEnd(7)}${String(gecit.length).padEnd(7)}` + `${String(kapali.length).padEnd(8)}${ort(er.map((s) => s.length)).padEnd(11)}` + `${String(Math.max(...er.map((s) => s.length))).padEnd(9)}` + `${ort(er.map((s) => s.filter((x) => VARLIK.includes(x)).length)).padEnd(12)}${gi}`); } ``` ``` sema bolme gecit kapali ort kalem en kotu ort varlik gecit istek tek-bolme 1 0 0 13.0 13 4.0 0 iki-bolme 2 7 1 9.0 9 4.0 2018 dort-bolme 4 16 2 8.2 9 4.0 3513 dugum-basina 14 20 2 4.8 8 2.8 3513 ``` Birinci satır bölmesiz ağın ölçüsüdür. Hangi servis düşerse düşsün diğer on üç düğümün tamamına ve dört varlığın dördüne erişiliyor. Düz ağda "hangi servis ele geçirildi" sorusunun cevabı sonucu değiştirmez; ele geçirilen her düğüm aynı yarıçapı açar. İkinci satır ilk bölme sınırını çiziyor ve ortalama erişilen kalem on üçten dokuza iniyor — yüzde otuz bir daralma. Ancak varlık sütunu kıpırdamıyor: hâlâ dört. Sınır giriş noktalarını içeriden ayırdı, ama bütün varlıklar içeride kaldı. Yedi geçit açıldı ve günde iki bin on sekiz istek bu geçitlerden geçer oldu. Yalıtımın bedeli ödendi, korunan kalem sayısı değişmedi. Üçüncü satır bu dersin en pahalı satırıdır. Dört bölme on altı geçit gerektiriyor ve günlük meşru isteğin tamamı, üç bin beş yüz on üçü, en az bir geçitten geçiyor. Karşılığında ortalama erişilen kalem dokuzdan sekiz virgül ikiye iniyor ve varlık sayısı yine dört. Dokuz ek geçit sıfır virgül sekiz kalem satın aldı. Bölme sayısını artırmak tek başına yalıtım üretmiyor. Son satır neyin işe yaradığını gösteriyor. Her düğüm kendi bölmesindeyken ortalama erişilen kalem dört virgül sekize, erişilen varlık iki virgül sekize iniyor. Varlık sütunu ancak burada kıpırdıyor. Fark bölme sayısından değil, geçitlerin **taneciğinden** geliyor: dört bölmede servis bölmesinden veri bölmesine açılan bir geçit, o bölmedeki bütün varlıkları açıyordu; düğüm başına şemada aynı geçit yalnız bir varlığa açılıyor. #### Düşen Düğüm Başına Yarıçap Ortalama tek başına yanıltıcıdır. Aynı ölçüm düğüm düğüm yapıldığında hangi düğümün daraldığı ve hangisinin daralmadığı görünür. ```js // kosum2.mjs — dusen dugum basina erisilen kalem; sema degistikce nasil daraliyor import { VARLIK } from './ag.mjs'; import { SEMA, ARA, cozumle } from './bolme.mjs'; const c = SEMA.map(([nm, h]) => [nm, cozumle(h)]); console.log(`dusen dugum ${c.map(([nm]) => nm.split('-')[0].padEnd(9)).join('')}`); for (const d of ARA) console.log(`${d.padEnd(14)}${c.map(([, x]) => String(x.erisilen(d).length).padEnd(9)).join('')}`); console.log('\nayni satirlar yalniz varlik sayilarak:'); for (const d of ARA) console.log(`${d.padEnd(14)}${c.map(([, x]) => String(x.erisilen(d).filter((y) => VARLIK.includes(y)).length).padEnd(9)).join('')}`); const son = c[3][1]; console.log(`\ndugum basina semada en genis yaricap: ${ARA.map((d) => [d, son.erisilen(d).length]).sort((a, b) => b[1] - a[1])[0].join(' -> ')} kalem`); ``` ``` dusen dugum tek iki dort dugum toplayici 13 9 8 6 is-emri 13 9 8 6 yonetim 13 9 9 8 kuyruk 13 9 8 5 dogrulayici 13 9 8 2 faturalama 13 9 8 2 ayni satirlar yalniz varlik sayilarak: toplayici 4 4 4 3 is-emri 4 4 4 3 yonetim 4 4 4 4 kuyruk 4 4 4 3 dogrulayici 4 4 4 2 faturalama 4 4 4 2 dugum basina semada en genis yaricap: yonetim -> 8 kalem ``` İlk iki sütun tamamen düzdür: bölmesiz ve iki bölmeli şemada hangi düğümün düştüğü fark etmiyor. Ayrım ancak son sütunda açılıyor. Doğrulayıcı ve faturalama düştüğünde erişilen kalem on üçten ikiye iniyor; bu iki servis grafiğin sonuna yakın durur ve arkalarında yalnız yazdıkları varlıklar vardır. Ölçüm toplayıcısı ve iş emri servisi altıya, kuyruk beşe iniyor. Yönetim istasyonu inmiyor. Dört bölmeli şemada dokuz, düğüm başına şemada sekiz kalem — ve varlık sütununda dört, yani şema ne olursa olsun bütün varlıklara erişiliyor. Nedeni geçit kümesinin nereden türediğidir: yönetim istasyonunun meşru işi zaten toplayıcıya, doğrulayıcıya, iş emri servisine ve yapılandırma deposuna dokunmaktır. Geçitler meşru akışlardan türediği için, meşru işi geniş olan düğümün geçitleri de geniştir. Bu, yalıtımın yapısal sınırıdır: **bölmelere ayırma, meşru işi dar olan düğümleri daraltır, geniş olanları daraltmaz.** Ele geçirilmesi en pahalıya mal olacak düğüm, yalıtımdan en az yararlanan düğümdür. Aynı gözlem bir karara da çevrilebilir — yönetim düğümünün yarıçapını daraltmanın yolu bölme eklemek değil, o düğümün meşru işini bölmektir: bakım işini yapan özne ile yapılandırma değiştiren öznenin ayrı düğümlere konması, sekiz kalemi iki ayrı ve daha küçük kümeye böler. Şemaların bedeli de bu tabloyla birlikte okunmalıdır. Düğüm başına şema yirmi geçit gerektiriyor ve bu geçitlerin her biri elle yazılan, meşru akış değiştikçe güncellenmesi gereken bir kalemdir. Günlük üç bin beş yüz on üç isteğin tamamı en az bir geçitten geçiyor; her geçit hem bir işletim kalemi hem de bir arıza noktasıdır. Ortalama erişilen kalemi on üçten dört virgül sekize indirmenin fiyatı budur ve bu fiyat, bir olay yaşanmadığı sürece hiçbir yerde görünmez. #### Sınırın Yeri Bölme sayısı tek başına belirleyici değilse sınırın nereye çizildiği belirleyicidir. Üç şema aynı soruyu farklı yanıtlıyor: sınır varlıkların etrafına mı, varlıkların arasına mı, yoksa servislerin arasına mı çizilmeli? ```js // kosum3.mjs — sinirin yeri: ayni sayida bolme farkli yerlere konursa ne degisiyor import { AKIS, GIRIS, VARLIK, adimlar } from './ag.mjs'; import { DUGUM, ARA, cozumle } from './bolme.mjs'; const kur = (f) => Object.fromEntries(DUGUM.map((d) => [d, f(d)])); const ort = (a) => (a.reduce((s, x) => s + x, 0) / a.length).toFixed(1); const YER = [ ['varlik-etrafinda', kur((d) => (VARLIK.includes(d) ? 'veri' : 'geri'))], ['varlik-basina', kur((d) => (VARLIK.includes(d) ? d : 'geri'))], ['servis-basina', kur((d) => (VARLIK.includes(d) ? 'veri' : GIRIS.includes(d) ? 'dis' : d))], ]; console.log('sema bolme gecit ort kalem ort varlik gecit istek'); for (const [nm, harita] of YER) { const { gecit, erisilen } = cozumle(harita), er = ARA.map(erisilen); const gi = AKIS.filter(([, d]) => adimlar(d).some((k) => gecit.includes(k))).reduce((s, [, , n]) => s + n, 0); console.log(`${nm.padEnd(18)}${String(new Set(Object.values(harita)).size).padEnd(7)}${String(gecit.length).padEnd(7)}` + `${ort(er.map((s) => s.length)).padEnd(11)}${ort(er.map((s) => s.filter((x) => VARLIK.includes(x)).length)).padEnd(12)}${gi}`); } ``` ``` sema bolme gecit ort kalem ort varlik gecit istek varlik-etrafinda 2 7 13.0 4.0 2039 varlik-basina 5 7 13.0 4.0 2039 servis-basina 8 20 6.0 4.0 3513 ``` İlk iki satır sıfır kazanç veriyor. Bütün varlıkları tek bir bölmeye koymak da her varlığa ayrı bölme vermek de ortalama erişilen kalemi on üçte, erişilen varlığı dörtte bırakıyor. Neden geçit kuralından çıkıyor: servislerin hepsi aynı bölmede kaldığı için biri düştüğünde hepsine erişiliyor ve her varlığa giden geçit o ortak bölmeden açık olduğu için varlıkların hepsine de erişiliyor. Beş bölmeli şema iki bölmeli şemadan farksızdır — üç ek sınır çizildi, hiçbir yol daralmadı. Yalıtımı bölme sayısıyla raporlamak burada tamamen yanıltıcıdır. Üçüncü satır bir kazanç gösteriyor ama beklenen kazancı değil. Servisleri ayırmak ortalama erişilen kalemi on üçten altıya indiriyor; yan hareket gerçekten daraldı. Erişilen varlık yine dört, çünkü her servis kendi meşru işi için ortak veri bölmesine geçit alıyor ve o bölmenin içinde serbest dolaşılıyor. Yirmi geçit ve günlük isteğin tamamı ödendi, korunan varlık sayısı değişmedi. Üç satır birlikte okunduğunda kural görünür oluyor: **yan hareketi servis sınırı daraltır, varlık erişimini varlık sınırı daraltır ve ikisi birbirinin yerine geçmez.** Düğüm başına şemanın erişilen varlığı iki virgül sekize indirmesinin nedeni ikisini birden yapmasıdır. Bir yalıtım kararının ölçüsü kaç bölme kurulduğu değil, hangi iki kalem çiftinin arasına sınır konduğudur. #### Özet - Düz ağda hangi servis düşerse düşsün diğer 13 düğüme ve 4 varlığın tamamına erişiliyor. Bölmesiz bir ağda "hangi düğüm ele geçirildi" sorusu sonucu değiştirmez. - İki bölme ortalama erişilen kalemi 13'ten 9'a indiriyor (%31) ama erişilen varlık 4'te kalıyor; 7 geçit ve günde 2.018 istek karşılığında korunan varlık sayısı değişmedi. - Dört bölme 16 geçit ve günlük isteğin tamamı karşılığında ortalamayı yalnız 9'dan 8,2'ye indiriyor. Bölme sayısını artırmak tek başına yalıtım üretmiyor. - Erişilen varlık ancak düğüm başına bölmede kıpırdıyor: ortalama 4'ten 2,8'e. Belirleyici olan bölme sayısı değil, geçidin taneciğidir. - Yönetim istasyonu en az daralan düğümdür: 13 kalemden yalnız 8'e iniyor, 4 varlığın hepsine her şemada erişiliyor. Geçitler meşru akıştan türediği için meşru işi geniş olan düğüm yalıtımdan yararlanamaz. - Düğüm başına şemanın bedeli 20 elle yönetilen geçit ve günde 3.513 isteğin geçitten geçmesidir; bu bedel bir olay yaşanmadığı sürece görünmez. #### Sonraki Adım Bu ders ağı bölmelere ayırdı ve bir bölmenin düşmesinin kaç kaleme eriştiğini saydı. Bölmelerin tamamı aynı sessiz kuralla çalıştı: **bir bölmenin içinde serbest dolaşılır.** Erişilen kalem sayısının on üçten başlamasının nedeni de buydu — düz ağda içeride olmak, geçmek için yeterli sayılıyordu. Bölme eklemek bu kuralı kaldırmadı, yalnız kuralın geçerli olduğu alanı küçülttü; her şemada içeride olmak hâlâ bir ayrıcalıktı ve geçitler o ayrıcalığı bölmeden bölmeye taşıdı. Sonraki dersin sorusu bu kuralın kendisidir: konuma bakarak verilen güven tamamen kaldırılır ve her adım, nereden geldiğine bakılmaksızın ayrı ayrı doğrulanırsa yol sayısı ne oluyor, erişilen kalem nereye iniyor ve her isteğin ayrı doğrulanması günlük istek başına kaç ek adım ediyor. ### Sıfır Güven Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/sifir-guven Konum temelli güven kaldırılırken doğrulama kapsamı beş adımda genişletilir ve her adımda yol sayısı, günlük doğrulama işlemi ve istek başına ek adım birlikte sayılır. Sıfır güvende açık kalan yolların nedeni bulunur ve kimliğin uçtan uca taşınmasının kaç iç akışı değiştirdiği ölçülür. Önceki ders ağı bölmelere ayırdı ve bir düğüm düştüğünde erişilen kalemi saydı. Bütün şemalar aynı sessiz kuralla çalıştı: bir bölmenin içinde serbest dolaşılır. Erişilen kalem sayısının on üçten başlamasının nedeni buydu; bölme eklemek kuralı kaldırmadı, yalnız geçerli olduğu alanı küçülttü. Bu ders kuralın kendisini kaldırır. **Sıfır güven** (zero trust), bir isteğin nereden geldiğine bakarak verilen güveni tamamen bırakmak ve her adımı ayrı ayrı doğrulamaktır. İlkeyi ölçmek için "içeride olmak" yerine geçen bir şey gerekir: her adımın **kime ait** olduğu. Bir adım, ona sahip olan kimlik tarafından atılıyorsa geçer; başka bir kimlik aynı adımı atmaya çalıştığında, adım ağın neresinde olursa olsun durur. Ölçülen üç şey yol sayısı, günlük doğrulama işlemi ve **istek başına ek adımdır**. - **SI17.** Adım sahipliği meşru akış listesinden türetilir: bir akış bir giriş noktasından başlıyorsa o akışın adımları o kimliğe aittir. - **SI18.** Dört meşru akış bir giriş noktasından başlamaz; kuyruktan ya da yönetim istasyonundan tetiklenir. Bu akışların adımları **ortak** kabul edilir, yani hangi kimliğin tetiklediği bilinmez. Modelin en belirleyici kararı budur. - **SI19.** Doğrulama kapsamı, kimlik denetimi yapılan adımların kümesidir. Kapsam dışındaki adım konuma güvenip geçirir; kapsam içindeki adım sahiplik kümesine bakar. - **SI20.** Bir doğrulama işlemi bir ek adımdır. Doğrulamanın kendi gecikmesi, süresi ve başarısızlık oranı modellenmiyor; sayılan yalnız kaç kez yapıldığıdır. - **SI21.** Doğrulama her zaman doğru sonuç verir. Sahte kimlik, çalınmış belirteç ve yeniden oynatma modellenmiyor; bunlar kapanan yol sayısını düşürür, ölçünün yönünü değiştirmez. #### Konumun Yerine Kimlik Grafik aynı kalıyor; değişen tek şey bir adımın hangi koşulla geçildiğidir. ```js // ag.mjs — kurgusal bolgesel olcum aginin erisim grafigi ve mesru akislari (model) export const GIRIS = ['saha-uc', 'sube-agi', 'genel-uc', 'bakim-uc']; export const VARLIK = ['olcum-deposu', 'fatura-vt', 'abone-kayit', 'yapilandirma']; export const KENAR = [ ['saha-uc', 'toplayici'], ['saha-uc', 'is-emri'], ['sube-agi', 'toplayici'], ['sube-agi', 'is-emri'], ['sube-agi', 'yonetim'], ['genel-uc', 'toplayici'], ['bakim-uc', 'yonetim'], ['bakim-uc', 'kuyruk'], ['toplayici', 'kuyruk'], ['toplayici', 'olcum-deposu'], ['kuyruk', 'dogrulayici'], ['kuyruk', 'faturalama'], ['dogrulayici', 'olcum-deposu'], ['dogrulayici', 'fatura-vt'], ['faturalama', 'fatura-vt'], ['faturalama', 'abone-kayit'], ['is-emri', 'kuyruk'], ['is-emri', 'abone-kayit'], ['yonetim', 'toplayici'], ['yonetim', 'dogrulayici'], ['yonetim', 'is-emri'], ['yonetim', 'yapilandirma'], ]; // Mesru akis: gunluk kosan is; adim dizisi ayni grafigin kenarlarindan gecer. export const AKIS = [ ['saha-okuma', ['saha-uc', 'toplayici', 'kuyruk'], 1440], ['dogrulama', ['kuyruk', 'dogrulayici', 'olcum-deposu'], 1440], ['genel-okuma', ['genel-uc', 'toplayici', 'olcum-deposu'], 300], ['sube-sorgu', ['sube-agi', 'toplayici', 'olcum-deposu'], 210], ['fatura-yazimi', ['kuyruk', 'faturalama', 'fatura-vt'], 48], ['is-emri-acma', ['sube-agi', 'is-emri', 'abone-kayit'], 32], ['is-emri-kuyruk', ['sube-agi', 'is-emri', 'kuyruk'], 32], ['abone-guncelleme', ['faturalama', 'abone-kayit'], 6], ['yapilandirma-degisikligi', ['sube-agi', 'yonetim', 'yapilandirma'], 2], ['bakim-oturumu', ['bakim-uc', 'yonetim', 'toplayici'], 1], ['kuyruk-bakimi', ['bakim-uc', 'kuyruk'], 1], ['mutabakat', ['yonetim', 'dogrulayici', 'fatura-vt'], 1], ]; export const ad = (a, b) => `${a}>${b}`; export const adimlar = (d) => d.slice(0, -1).map((x, i) => ad(x, d[i + 1])); export function yollar(kapali = new Set()) { const komsu = new Map(); for (const [a, b] of KENAR) if (!kapali.has(ad(a, b))) komsu.set(a, [...(komsu.get(a) || []), b]); const s = []; const yuru = (d, y) => { if (VARLIK.includes(d)) return void s.push(y); for (const k of komsu.get(d) || []) if (!y.includes(k)) yuru(k, [...y, k]); }; for (const g of GIRIS) yuru(g, [g]); return s; } export const kesilen = (kapali) => AKIS.filter(([, d]) => adimlar(d).some((k) => kapali.has(k))); ``` ```js // kimlik.mjs — adim sahipligi ve dogrulama kapsamlari (model) import { KENAR, AKIS, GIRIS, VARLIK, ad, adimlar } from './ag.mjs'; export const KENAR_AD = KENAR.map(([a, b]) => ad(a, b)); // Ic akislar bir giris noktasindan baslamaz; adimlari butun kimliklerce ortak kullanilir. const ORTAK = new Set(AKIS.filter(([, d]) => !GIRIS.includes(d[0])).flatMap(([, d]) => adimlar(d))); const kendi = (g) => AKIS.filter(([, d]) => d[0] === g).flatMap(([, d]) => adimlar(d)); export const SAHIP = Object.fromEntries(GIRIS.map((g) => [g, new Set([...ORTAK, ...kendi(g)])])); export const UCTAN_UCA = Object.fromEntries(GIRIS.map((g) => [g, new Set(kendi(g))])); const SERVIS = ['toplayici', 'kuyruk', 'dogrulayici', 'faturalama', 'is-emri']; const bolme = (d) => (GIRIS.includes(d) ? 'dis' : SERVIS.includes(d) ? 'servis' : d === 'yonetim' ? 'yonetim' : 'veri'); export const CEVRE = KENAR_AD.filter((k) => GIRIS.includes(k.split('>')[0])); export const VARLIGA = KENAR_AD.filter((k) => VARLIK.includes(k.split('>')[1])); export const GECIT = KENAR_AD.filter((k) => bolme(k.split('>')[0]) !== bolme(k.split('>')[1])); const komsu = new Map(); for (const [a, b] of KENAR) komsu.set(a, [...(komsu.get(a) || []), b]); // Kapsamdaki adim kimligi denetler; kapsam disindaki adim konuma guvenip gecirir. export function yol(g, kapsam, sahip = SAHIP) { const s = new Set(kapsam), out = []; const yuru = (d, y) => { if (VARLIK.includes(d)) return void out.push(y); for (const k of komsu.get(d) || []) { const e = ad(d, k); if (s.has(e) && !sahip[g].has(e)) continue; if (!y.includes(k)) yuru(k, [...y, k]); } }; yuru(g, [g]); return out; } ``` ```js // kosum1.mjs — dogrulama kapsami genisledikce yol sayisi ve istek basina ek adim import { AKIS, GIRIS, adimlar } from './ag.mjs'; import { KENAR_AD, CEVRE, VARLIGA, GECIT, yol } from './kimlik.mjs'; const tek = (a) => [...new Set(a)]; const KAPSAM = [['hicbiri', []], ['cevre', CEVRE], ['cevre+varlik', tek([...CEVRE, ...VARLIGA])], ['cevre+gecit', tek([...CEVRE, ...GECIT])], ['her-adim', KENAR_AD]]; const gunluk = AKIS.reduce((s, [, , n]) => s + n, 0); console.log('kapsam denetlenen yol kapanan gunluk dogrulama istek basina ek adim'); for (const [nm, kapsam] of KAPSAM) { const y = GIRIS.reduce((s, g) => s + yol(g, kapsam).length, 0), s = new Set(kapsam); const dog = AKIS.reduce((t, [, d, c]) => t + c * adimlar(d).filter((k) => s.has(k)).length, 0); console.log(`${nm.padEnd(14)}${String(kapsam.length).padEnd(12)}${String(y).padEnd(5)}` + `${String(55 - y).padEnd(9)}${String(dog).padEnd(18)}${(dog / gunluk).toFixed(2)}`); } ``` ``` kapsam denetlenen yol kapanan gunluk dogrulama istek basina ek adim hicbiri 0 55 0 0 0.00 cevre 8 50 5 2018 0.57 cevre+varlik 15 46 9 4057 1.15 cevre+gecit 18 32 23 4059 1.16 her-adim 22 20 35 7019 2.00 ``` İkinci satır konum temelli güvenin ölçüsüdür. Sekiz giriş adımında kimlik denetleniyor, içeride hiçbir yerde denetlenmiyor. Elli beş yolun yalnız beşi kapanıyor. Bedeli düşük — günde iki bin on sekiz doğrulama, istek başına sıfır virgül elli yedi ek adım — ama karşılığında alınan da düşük: yolların yüzde doksanı açık kalıyor. Çevrede duran bir denetim, çevreyi geçmiş bir isteği bir daha hiç görmüyor. Bu, çevre denetiminin değersiz olduğu anlamına gelmez; ilk beş yolu en ucuz biçimde kapatan denetim odur. Anlamı, ölçümün orada bitirilemeyeceğidir — çevrede duran bir denetimin kapattığı yol sayısı, arkasındaki ağın şeklinden bağımsız olarak küçüktür. Üçüncü ve dördüncü satırlar birlikte okunmalıdır, çünkü ikisinin maliyeti neredeyse aynı: günde dört bin elli yedi ve dört bin elli dokuz doğrulama, istek başına bir virgül on beş ve bir virgül on altı ek adım. Kapattıkları yol sayısı ise dokuz ve yirmi üç. Aynı bedelle iki buçuk kat fark. Doğrulamayı varlığın önüne koymak, yolun son adımını denetlemektir ve o adıma gelen istek zaten bütün ara düğümlerden geçmiştir; bölme geçitlerine koymak ise yolu ortasından keser. **Doğrulamanın maliyeti kaç kez yapıldığıyla, değeri nerede yapıldığıyla belirlenir.** Son satır sıfır güvenin tam hâlidir. Yirmi iki adımın hepsinde kimlik denetleniyor, elli beş yolun otuz beşi kapanıyor ve yirmisi açık kalıyor. Bedel günde yedi bin on dokuz doğrulama, yani istek başına tam iki ek adım: her meşru istek ortalama iki kez kimliğini gösteriyor. Konum temelli güvene göre otuz yol daha kapandı ve doğrulama sayısı üç buçuk katına çıktı. İki sütunu birbirine bölmek beklenmedik bir sonuç veriyor. Çevre denetiminde kapanan yol başına dört yüz dört doğrulama düşüyor; her adımda doğrulamada iki yüz bir. Sıfır güven, kapattığı yol başına konum temelli güvenden **daha ucuzdur**. En verimli satır çevre ile bölme geçitlerinin birleşimi: kapanan yol başına yüz yetmiş altı doğrulama. En verimsizi ise çevre ile varlık girişi birleşimi: dört yüz elli bir. Toplam maliyete bakarak "sıfır güven pahalıdır" demek, tablonun yalnız bir sütununu okumaktır; iki sütun birlikte okunduğunda pahalı olan şey doğrulamanın sayısı değil, yanlış yere konmasıdır. Son sütundaki iki sayısı da açıklanmalıdır. Yirmi iki adımın hepsinde doğrulama yapılıyor ama istek başına ek adım iki çıkıyor, çünkü meşru akışların çoğu iki adımlıdır. Doğrulama kapsamının genişlemesi denetlenen adım sayısını artırır; bir isteğin ödediği bedeli ise o isteğin kaç adımdan geçtiği belirler. Uzun akışlar sıfır güvenin bedelini doğrusal olarak büyütür. #### Giriş Noktası Başına Toplam sayı hangi kimliğin daraldığını göstermez. Aynı ölçüm giriş noktası başına yapıldığında sahiplik kümesinin genişliği belirleyici oluyor. ```js // kosum2.mjs — giris noktasi basina yol; kimlik uctan uca tasinirsa ne kaliyor import { AKIS, GIRIS, VARLIK } from './ag.mjs'; import { KENAR_AD, CEVRE, SAHIP, UCTAN_UCA, yol } from './kimlik.mjs'; console.log('giris sahip adim konum temelli sifir guven uctan uca kimlik'); for (const g of GIRIS) console.log(`${g.padEnd(11)}${String(SAHIP[g].size).padEnd(12)}${String(yol(g, CEVRE).length).padEnd(15)}` + `${String(yol(g, KENAR_AD).length).padEnd(13)}${yol(g, KENAR_AD, UCTAN_UCA).length}`); const acik = GIRIS.flatMap((g) => yol(g, KENAR_AD)); const say = acik.reduce((m, p) => m.set(p.at(-1), (m.get(p.at(-1)) || 0) + 1), new Map()); console.log(`\nsifir guvende acik kalan ${acik.length} yolun ulastigi varlik:`); for (const v of VARLIK) console.log(` ${v.padEnd(16)}${say.get(v) || 0}`); const ic = AKIS.filter(([, d]) => !GIRIS.includes(d[0])); console.log(`\nkimligi uctan uca tasimak icin degismesi gereken ic akis ${ic.length}, ` + `gunluk istek ${ic.reduce((s, [, , n]) => s + n, 0)}`); ``` ``` giris sahip adim konum temelli sifir guven uctan uca kimlik saha-uc 9 5 4 0 sube-agi 14 23 9 3 genel-uc 9 5 1 1 bakim-uc 10 17 6 0 sifir guvende acik kalan 20 yolun ulastigi varlik: olcum-deposu 7 fatura-vt 8 abone-kayit 4 yapilandirma 1 kimligi uctan uca tasimak icin degismesi gereken ic akis 4, gunluk istek 1495 ``` Bakım ucu on yedi yoldan altıya iniyor. Şube ağı yirmi üçten dokuza iniyor ve sıfır güvenden sonra en çok yol bırakan giriş noktası odur, çünkü sahiplik kümesi en geniş olan odur — on dört adım. Meşru işi geniş olan kimlik sıfır güvenden en az yararlanan kimliktir; önceki derste aynı şeyi yönetim düğümü için görmüştük, ölçü farklı, sonuç aynı. Genel uç en sert daralmayı yaşıyor: beş yoldan bire. Sahiplik kümesi dokuz adım olmasına rağmen kendi akışı yalnız iki adımdan ibaret; geri kalan yedi adım ortak kümeden geliyor. Bu satır bir sonraki bulgunun ipucudur. Alt tablo daralmanın varlıklara nasıl dağıldığını veriyor ve dağılım eşit değil. İlk derste fatura veritabanına yirmi iki, ölçüm deposuna on yedi, abone kayıtlarına on dört ve yapılandırma deposuna iki yol gidiyordu. Sıfır güvenden sonra bu sayılar sekiz, yedi, dört ve bir. En çok yol taşıyan varlık mutlak olarak en çok daralan varlık oldu — yirmi ikiden sekize, yüzde altmış dört. Yapılandırma deposu ise ikiden bire indi, yüzde elli. Oransal daralmanın büyük olması yüksek sayıdan başlamanın sonucudur; kalan mutlak sayı hâlâ fatura veritabanında en yüksektir. Bir savunma raporu yüzdeyle yazıldığında en çok korunan varlık gibi görünen kalem, mutlak sayıyla yazıldığında hâlâ en açık kalemdir. Hangi sütunun okunacağı, kararın ne olduğuna göre değişir: yatırım önceliği mutlak sayıdan, ilerleme ölçüsü orandan okunur. #### Kimliğin Kaybolduğu Yer Sıfır güvende yirmi yol neden hâlâ açık? Cevap ortak adımlardadır. Dört meşru akış bir giriş noktasından başlamıyor: doğrulama, fatura yazımı, abone güncelleme ve mutabakat. Bunlar kuyruktan ya da yönetim istasyonundan tetikleniyor ve tetikleyenin kim olduğu adımın kendisinde yazmıyor. Modelde bu yedi adım bütün kimliklere ortak açık kaldı; gerçekte de bir kuyruktan alınan iş, işi kuyruğa koyanın kimliğini taşımaz. Son sütun bunun ölçüsüdür. Kimlik uçtan uca taşınsaydı, yani her iç akış kendisini tetikleyen isteğin kimliğini de taşısaydı, kalan yol yirmiden dörde inecekti. Saha ucundan ve bakım ucundan hiçbir yol kalmıyor; şube ağından üç, genel uçtan bir yol kalıyor. On altı yolun tamamı, kimliğin kuyrukta düşmesinden geliyor. Bu on altı yolun fiyatı da yazılabilir: dört iç akışın yeniden kurulması ve günde bin dört yüz doksan beş isteğin kimlik taşıyacak biçimde değiştirilmesi. Bu bir denetim eklemek değil, bir tasarım değişikliğidir; kuyruğun ilettiği her işin çağıranın kimliğini de iletmesi gerekir. Sıfır güvenin uygulamada yarım kalmasının başlıca nedeni budur: kapatılabilir elli bir yolun otuz beşi denetim ekleyerek kapanır, on altısı ancak akışlar yeniden yazılarak kapanır. Birincisi bir yapılandırma işi, ikincisi bir yazılım işidir ve ikisi aynı bütçeden çıkmaz. Ölçümün tamamının bir sınırı da vardır. Model doğrulamanın her zaman doğru sonuç verdiğini kabul etti; çalınmış bir kimlik, sahibi olduğu bütün adımlarda geçerlidir. Sıfır güven bir kimliğin çalınmasını engellemez, çalınan kimliğin **kaç adımda geçerli olduğunu** küçültür. Sahiplik sütunundaki dokuz ile on dört arasındaki fark, bir kimliğin çalınması hâlinde açılan alanın farkıdır. Aynı nedenle sıfır güven bir bitiş durumu değil, bir ölçü ekseni sayılmalıdır: sahiplik kümeleri daraldıkça çalınan kimliğin değeri düşer, genişledikçe yükselir. Ölçülecek şey "sıfır güvene geçildi mi" değil, **kimlik başına kaç adımın açık olduğudur**. #### Özet - Konum temelli güven, sekiz giriş adımında kimlik denetleyip içeride hiç denetlemiyor: 55 yolun yalnız 5'i kapanıyor, istek başına 0,57 ek adım ödeniyor. - Doğrulamayı varlığın önüne koymakla bölme geçitlerine koymak neredeyse aynı maliyeti taşıyor (günde 4.057 ve 4.059 doğrulama) ama 9 ve 23 yol kapatıyor. Maliyet kaç kez yapıldığıyla, değer nerede yapıldığıyla belirlenir. - Her adımda doğrulama 35 yol kapatıyor ve 20 yol bırakıyor; bedeli günde 7.019 doğrulama, istek başına tam 2 ek adım. - Sahiplik kümesi geniş olan kimlik daha az daralıyor: şube ağı 14 adımla 23 yoldan 9'a inerken bakım ucu 10 adımla 17 yoldan 6'ya iniyor. - Açık kalan 20 yolun kaynağı, bir giriş noktasından başlamayan 4 iç akışın ortak adımlarıdır. Kimlik uçtan uca taşınsaydı kalan yol 4 olurdu. - Son 16 yolun fiyatı denetim değil tasarımdır: 4 iç akışın yeniden kurulması ve günde 1.495 isteğin kimlik taşıyacak biçimde değiştirilmesi. #### Sonraki Adım Bu ders her adımda kimliği denetledi ve kimliğin kaybolduğu yeri buldu. Sorulan soru hep aynıydı: bu isteği kim gönderdi? Ama bir adımın geçilmesi için iki ayrı sorunun yanıtlanması gerekir ve bu ders yalnız birincisini sordu. Kimliği doğrulanmış bir istek, doğrulandığı için yetkili değildir; yetki ayrı bir sorudur ve ayrı bir yerde sorulur. İki soru aynı katmanda birleştirildiğinde ya da biri diğerinin yerine geçtiğinde ne olur? Sonraki dersin ölçtüğü şey budur: doğrulanmış ama yetkisiz bir istek kaç kalemde geçiyor, denetim yanlış katmana konduğunda kaç yol açılıyor ve iki soruyu ayrı ayrı sormanın kaç kaleme ek denetim eklemek demek olduğu. ### Kimlik Doğrulama ve Yetkilendirme Ayrımı Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/kimlik-dogrulama-ve-yetkilendirme-ayrimi Aynı adım kümesi üzerinde iki denetim ayrı kapsamlara konur ve iki ayrı isteğe karşı ölçülür: sahte kimlikli istek ile doğrulanmış ama yetkisiz istek. Kimlik denetimini her adıma koymanın doğrulanmış-yetkisiz isteğe karşı kaç yol kapattığı ve yetkiyi yalnız veri katmanında sormanın açtığı yol sayılır. Önceki ders her adımda kimliği denetledi ve yol sayısını elli beşten yirmiye indirdi. Sorulan soru hep aynıydı: bu isteği kim gönderdi? Bir adımın geçilmesi için ise iki ayrı sorunun yanıtlanması gerekir. **Kimlik doğrulama** (authentication) isteği gönderenin kim olduğunu belirler; **yetkilendirme** (authorization) o kimliğin bu kalemde bu işlemi yapıp yapamayacağını belirler. İki soru farklıdır, farklı verilere bakar ve farklı yerlerde sorulabilir. Kimlik Doğrulama ve Yetkilendirme kursunda bu ayrım akış ve belirteç düzeyinde ele alınmıştı. Burada ölçülen şey mekanizma değil, **denetimin yanlış katmanda durmasının açtığı yoldur**. Ölçüm iki ayrı isteğe karşı yapılıyor: kimliği sahte olan bir istek ve **kimliği gerçek ama o adım için yetkisiz** olan bir istek. İkincisi bu dersin asıl konusudur, çünkü çoğu denetim yalnız birincisini görür. Sahte kimlikli istek bir dış saldırganı, doğrulanmış ama yetkisiz istek ise ele geçirilmiş bir meşru kimliği ya da yanlış yapılandırılmış bir servisi temsil eder; ikinci durum ilkinden hem daha sık hem de daha zor görülür. - **SI22.** Bir adım iki denetimden geçer. Kimlik denetimi kapsamdaysa isteğin kimliğinin geçerli olmasını, yetki denetimi kapsamdaysa o kimliğin adım için yetkili olmasını arar. - **SI23.** Yetki kümesi meşru akış listesinden türetilir; bir kimlik, kendi akışlarının adımlarında ve ortak iç akış adımlarında yetkilidir. - **SI24.** İki istek profili ayrı ayrı koşturulur. Sahte kimlikli istek kimlik denetiminden geçemez; doğrulanmış ama yetkisiz istek kimlik denetiminin tamamından geçer ve yalnız yetki denetimiyle durdurulabilir. - **SI25.** Günlük denetim sayısı iki denetimin toplamıdır: bir adımda ikisi de yapılıyorsa iki işlem sayılır. Denetimlerin süresi ve gecikmesi modellenmiyor. - **SI26.** Yetki denetimi her zaman doğru karar verir. Yetki kümesinin yanlış yazılmış olması, eskimiş kayıt ve devredilen oturum modellenmiyor; bunlar açılan yol sayısını büyütür. #### İki Soru, İki Kapsam Grafik ve meşru akış listesi değişmedi. Değişen tek şey, hangi adımda hangi sorunun sorulduğudur. ```js // ag.mjs — kurgusal bolgesel olcum aginin erisim grafigi ve mesru akislari (model) export const GIRIS = ['saha-uc', 'sube-agi', 'genel-uc', 'bakim-uc']; export const VARLIK = ['olcum-deposu', 'fatura-vt', 'abone-kayit', 'yapilandirma']; export const KENAR = [ ['saha-uc', 'toplayici'], ['saha-uc', 'is-emri'], ['sube-agi', 'toplayici'], ['sube-agi', 'is-emri'], ['sube-agi', 'yonetim'], ['genel-uc', 'toplayici'], ['bakim-uc', 'yonetim'], ['bakim-uc', 'kuyruk'], ['toplayici', 'kuyruk'], ['toplayici', 'olcum-deposu'], ['kuyruk', 'dogrulayici'], ['kuyruk', 'faturalama'], ['dogrulayici', 'olcum-deposu'], ['dogrulayici', 'fatura-vt'], ['faturalama', 'fatura-vt'], ['faturalama', 'abone-kayit'], ['is-emri', 'kuyruk'], ['is-emri', 'abone-kayit'], ['yonetim', 'toplayici'], ['yonetim', 'dogrulayici'], ['yonetim', 'is-emri'], ['yonetim', 'yapilandirma'], ]; // Mesru akis: gunluk kosan is; adim dizisi ayni grafigin kenarlarindan gecer. export const AKIS = [ ['saha-okuma', ['saha-uc', 'toplayici', 'kuyruk'], 1440], ['dogrulama', ['kuyruk', 'dogrulayici', 'olcum-deposu'], 1440], ['genel-okuma', ['genel-uc', 'toplayici', 'olcum-deposu'], 300], ['sube-sorgu', ['sube-agi', 'toplayici', 'olcum-deposu'], 210], ['fatura-yazimi', ['kuyruk', 'faturalama', 'fatura-vt'], 48], ['is-emri-acma', ['sube-agi', 'is-emri', 'abone-kayit'], 32], ['is-emri-kuyruk', ['sube-agi', 'is-emri', 'kuyruk'], 32], ['abone-guncelleme', ['faturalama', 'abone-kayit'], 6], ['yapilandirma-degisikligi', ['sube-agi', 'yonetim', 'yapilandirma'], 2], ['bakim-oturumu', ['bakim-uc', 'yonetim', 'toplayici'], 1], ['kuyruk-bakimi', ['bakim-uc', 'kuyruk'], 1], ['mutabakat', ['yonetim', 'dogrulayici', 'fatura-vt'], 1], ]; export const ad = (a, b) => `${a}>${b}`; export const adimlar = (d) => d.slice(0, -1).map((x, i) => ad(x, d[i + 1])); export function yollar(kapali = new Set()) { const komsu = new Map(); for (const [a, b] of KENAR) if (!kapali.has(ad(a, b))) komsu.set(a, [...(komsu.get(a) || []), b]); const s = []; const yuru = (d, y) => { if (VARLIK.includes(d)) return void s.push(y); for (const k of komsu.get(d) || []) if (!y.includes(k)) yuru(k, [...y, k]); }; for (const g of GIRIS) yuru(g, [g]); return s; } export const kesilen = (kapali) => AKIS.filter(([, d]) => adimlar(d).some((k) => kapali.has(k))); ``` ```js // denetim.mjs — iki ayri soru: kimlik dogrulama ve yetkilendirme, ayri kapsamlarla import { KENAR, AKIS, GIRIS, VARLIK, ad, adimlar } from './ag.mjs'; export const KENAR_AD = KENAR.map(([a, b]) => ad(a, b)); const ORTAK = new Set(AKIS.filter(([, d]) => !GIRIS.includes(d[0])).flatMap(([, d]) => adimlar(d))); const kendi = (g) => AKIS.filter(([, d]) => d[0] === g).flatMap(([, d]) => adimlar(d)); // YETKI[g]: g kimliginin yetkili oldugu adimlar; mesru akis listesinden turetildi. export const YETKI = Object.fromEntries(GIRIS.map((g) => [g, new Set([...ORTAK, ...kendi(g)])])); export const CEVRE = KENAR_AD.filter((k) => GIRIS.includes(k.split('>')[0])); export const VARLIGA = KENAR_AD.filter((k) => VARLIK.includes(k.split('>')[1])); const komsu = new Map(); for (const [a, b] of KENAR) komsu.set(a, [...(komsu.get(a) || []), b]); // Bir adim iki ayri denetimden gecer; her denetimin kendi kapsami vardir. export function yol(g, kd, yd, kimlikGecerli) { const K = new Set(kd), Y = new Set(yd), out = []; const yuru = (d, y) => { if (VARLIK.includes(d)) return void out.push(y); for (const k of komsu.get(d) || []) { const e = ad(d, k); if (K.has(e) && !kimlikGecerli) continue; // kimlik dogrulama: sen kimsin if (Y.has(e) && !YETKI[g].has(e)) continue; // yetkilendirme: bunu yapabilir misin if (!y.includes(k)) yuru(k, [...y, k]); } }; yuru(g, [g]); return out; } ``` ```js // kosum1.mjs — iki denetim farkli katmanlara konunca hangi istek durur, hangisi gecer import { AKIS, GIRIS, adimlar } from './ag.mjs'; import { KENAR_AD, CEVRE, VARLIGA, yol } from './denetim.mjs'; const SEMA = [['denetim-yok', [], []], ['kimlik-cevrede', CEVRE, []], ['kimlik-her-adimda', KENAR_AD, []], ['kimlik-cevre-yetki-veride', CEVRE, VARLIGA], ['kimlik-cevre-yetki-heryerde', CEVRE, KENAR_AD], ['yalniz-yetki-heryerde', [], KENAR_AD], ['ikisi-de-heryerde', KENAR_AD, KENAR_AD]]; const gunluk = AKIS.reduce((s, [, , n]) => s + n, 0); console.log('sema sahte dogrulanmis varlik gunluk denetim istek basi'); for (const [nm, kd, yd] of SEMA) { const sahte = GIRIS.reduce((s, g) => s + yol(g, kd, yd, false).length, 0); const dog = GIRIS.flatMap((g) => yol(g, kd, yd, true)); const K = new Set(kd), Y = new Set(yd); const den = AKIS.reduce((s, [, d, c]) => s + c * adimlar(d) .reduce((t, k) => t + (K.has(k) ? 1 : 0) + (Y.has(k) ? 1 : 0), 0), 0); console.log(`${nm.padEnd(29)}${String(sahte).padEnd(7)}${String(dog.length).padEnd(13)}` + `${String(new Set(dog.map((p) => p.at(-1))).size).padEnd(8)}${String(den).padEnd(16)}${(den / gunluk).toFixed(2)}`); } ``` ``` sema sahte dogrulanmis varlik gunluk denetim istek basi denetim-yok 55 55 4 0 0.00 kimlik-cevrede 0 55 4 2018 0.57 kimlik-her-adimda 0 55 4 7019 2.00 kimlik-cevre-yetki-veride 0 50 4 4057 1.15 kimlik-cevre-yetki-heryerde 0 20 4 9037 2.57 yalniz-yetki-heryerde 20 20 4 7019 2.00 ikisi-de-heryerde 0 20 4 14038 4.00 ``` İkinci ve üçüncü satır bu dersin ana bulgusudur. Kimlik denetimi çevreden her adıma genişletildiğinde günlük denetim iki bin on sekizden yedi bin on dokuza çıkıyor — istek başına sıfır virgül elli yediden tam iki ek adıma. Sahte kimlikli istek her iki satırda da sıfır yol buluyor; zaten çevrede duruyordu. Doğrulanmış ama yetkisiz istek ise her iki satırda da elli beş yolun tamamını kullanıyor. **Kimlik denetimini üç buçuk katına çıkarmak, doğrulanmış bir isteğe karşı bir tek yol bile kapatmadı.** Yanlış katmanda değil, yanlış sorunun katmanında yapılan bir genişletme budur. Dördüncü satır uygulamada en sık görülen yerleşimdir: kimlik geçitte, yetki veri katmanında. Elli beş yolun beşi kapanıyor, ellisi açık kalıyor ve dört varlığın dördüne de erişiliyor. Yetkiyi yalnız son adımda sormanın nedeni anlaşılırdır — yetki kararı için gereken bilgi orada durur — ama sonucu, ara adımların hiç sorgulanmamasıdır. Doğrulanmış bir kimlik ara düğümlerin arasında serbestçe dolaşır ve yalnız varlığın kapısında bir soruyla karşılaşır. Beşinci ve yedinci satırlar birlikte okunmalıdır. Yetkiyi her adıma koymak yolu yirmiye indiriyor; kimliği de her adıma koymak aynı yirmiyi veriyor. Fark yalnız maliyettedir: istek başına iki virgül elli yediye karşılık dört ek adım. Bir buçuk ek adım karşılığında kapanan yol sayısı sıfır. Kimlik doğrulamayı çevrede bırakıp yetkilendirmeyi yaymak, ikisini birden yaymakla aynı sonucu veriyor ve yaklaşık üçte bir daha ucuza mal oluyor. Altıncı satır ayrımın öbür ucunu gösteriyor. Yetki her adımda sorulup kimlik hiç sorulmadığında sahte kimlikli istek yirmi yol buluyor. Yetki denetimi "bu kimlik bunu yapabilir mi" sorusunu yanıtlar; kimliğin gerçekten o kimlik olup olmadığını sormaz. İddia edilen kimlik doğru kabul edildiği anda, yetkilendirme o iddianın bütün ayrıcalıklarını verir. İki denetim birbirinin yerine geçmez: biri olmadan diğeri, açık kalan yolu farklı bir istek türüne devreder. #### Yetki Son Adımda Sorulduğunda Dördüncü satırın ellisi kimin elinde? Aynı ölçüm kimlik başına yapıldığında yetkilendirmenin neyi gördüğü ve neyi görmediği ayrışıyor. ```js // kosum2.mjs — yetki yalniz veri katmanindayken dogrulanmis-yetkisiz istek nereye ulasiyor import { GIRIS, VARLIK } from './ag.mjs'; import { CEVRE, VARLIGA, YETKI, yol } from './denetim.mjs'; console.log(`kimlik yetkili adim yol ${VARLIK.map((v) => v.slice(0, 8).padEnd(10)).join('')}`); const kapanan = []; for (const g of GIRIS) { const y = yol(g, CEVRE, VARLIGA, true), ulasan = new Set(y.map((p) => p.at(-1))); const acik = new Set(y.map((p) => p.join('>'))); kapanan.push(...yol(g, [], [], true).map((p) => p.join(' > ')).filter((p) => !acik.has(p.replaceAll(' > ', '>')))); console.log(`${g.padEnd(12)}${String(YETKI[g].size).padEnd(14)}${String(y.length).padEnd(5)}` + VARLIK.map((v) => (ulasan.has(v) ? 'evet' : 'hayir').padEnd(10)).join('')); } console.log(`\nveri katmani denetiminin kapattigi ${kapanan.length} yol:`); for (const p of kapanan) console.log(` ${p}`); const dar = GIRIS.flatMap((g) => yol(g, CEVRE, [...VARLIGA, ...CEVRE], true)); console.log(`\nyetki veri katmani + cevre oldugunda acik yol: ${dar.length}`); ``` ``` kimlik yetkili adim yol olcum-de fatura-v abone-ka yapiland saha-uc 9 8 evet evet evet hayir sube-agi 14 23 evet evet evet evet genel-uc 9 5 evet evet evet hayir bakim-uc 10 14 evet evet evet hayir veri katmani denetiminin kapattigi 5 yol: saha-uc > toplayici > olcum-deposu saha-uc > is-emri > abone-kayit bakim-uc > yonetim > toplayici > olcum-deposu bakim-uc > yonetim > is-emri > abone-kayit bakim-uc > yonetim > yapilandirma yetki veri katmani + cevre oldugunda acik yol: 46 ``` Şube ağı satırı yetkilendirmenin veri katmanında ne kadar kör olduğunu gösteriyor. Yirmi üç yolun yirmi üçü açık; bir tek yol kapanmadı. Nedeni yetki kümesinin şeklidir: şube ağı kimliği kendi meşru işi için dört varlığın dördüne de bir adım yetkisi taşıyor — ölçüm deposunu okuyor, iş emri açarken abone kaydına yazıyor, yapılandırma değişikliği yapıyor ve iç akışlar üzerinden fatura veritabanına yazıyor. Veri katmanındaki denetim yalnız son adıma baktığı için, o son adım yetkili olduğunda **oraya nasıl gelindiği hiç sorulmuyor**. Yetkili adım sütunu bu sonucun göstergesidir: en geniş yetki kümesinde — on dört adımda — veri katmanı denetiminin durdurabileceği yol sıfıra iner. En geniş yetkiye sahip kimlik, en son adımda denetlenen bir sistemde hiç denetlenmemiş sayılır. Genel uç en dar kimliklerden biridir ve yine de beş yolun beşinde ilerliyor; saha ucu ondan sekize, bakım ucu on yediden on dörde iniyor. Kapanan beş yol listelenmiş durumda ve hepsinin ortak bir özelliği var: tamamı iki ya da üç adımlık kısa yollar. Uzun yolların hiçbiri kapanmıyor. Nedeni son adımın kime ait olduğudur. Uzun yollar doğrulayıcı ya da faturalama üzerinden varlığa girer; bu iki servisin varlığa yazan adımları iç akışlara aittir ve iç akış adımları bütün kimliklerce ortak kullanılır. Veri katmanındaki denetim son adıma baktığında karşısında hep yetkili bir adım bulur. Kısa yollar ise varlığa doğrudan girer ve son adımları belirli bir kimliğe aittir; ancak orada bir uyuşmazlık görünür. **Yolu uzatmak, veri katmanındaki denetimden kaçmanın yoludur** — ve bu, denetimin bir eksiği değil, konduğu yerin sonucudur. Son satır ara bir seçeneği ölçüyor. Yetkilendirme veri katmanına ek olarak çevreye de konduğunda açık yol elliden kırk altıya iniyor. Dört yol daha kapandı — sekiz adımlık bir denetim eklemenin karşılığı bu. Yetkilendirmeyi genişletmek yolu doğrusal biçimde kapatmıyor; kapanma denetimin **hangi adımda** durduğuna bağlı ve en çok yolu ortadaki adımlar taşıyor. Yetkiyi uçlara koymak, yolun uçlarını kesip ortasını açık bırakmaktır; ilk tablodaki yirmi sayısına ancak ortadaki adımlar da sorguya dahil edildiğinde inilir. İki tablo birlikte bir yerleştirme kuralı veriyor. Kimlik doğrulama tek bir yerde yapılabilir, çünkü yanıtı yol boyunca değişmez: bir istek kimse sonuna kadar odur. Yetkilendirme ise her adımda yeniden sorulmalıdır, çünkü yanıtı adımdan adıma değişir: aynı kimlik bir adımda yetkili, bir sonrakinde değildir. Bu asimetri iki denetimin neden farklı katmanlara ait olduğunu açıklıyor ve tablodaki maliyet farkını da haklı çıkarıyor — kimliği çevrede bırakıp yetkiyi yaymak, istek başına dört yerine iki virgül elli yedi ek adımla aynı yirmi yolu verdi. Ölçümün bir sınırı da burada yazılmalıdır. Model yetki kümesinin doğru olduğunu ve her adımda doğru değerlendirildiğini kabul etti. Gerçekte yetki kararını ara bir adımda vermek, o adımın kararı verecek bilgiye sahip olmasını gerektirir: hangi kimliğin adına çalışıldığı, hangi kalemin istendiği ve hangi eylemin yapıldığı. Bu bilgi yol boyunca taşınmıyorsa ara adımda yetki sorulamaz — sorulsa da yanıtı "bilmiyorum" olur ve bu yanıt geçirmeye dönüşür. Önceki dersteki ortak adım sorunu ile buradaki ara adım sorunu aynı eksikliğin iki yüzüdür: bir isteğin kimin adına ve ne için yapıldığı, adımlar arasında taşınmıyorsa hiçbir ara denetim doğru karar veremez. Dolayısıyla tablodaki yirmi sayısı bir hedef değil, akışlar bu bilgiyi taşıdığında ulaşılabilir bir alt sınırdır. #### Özet - Bir adımın geçilmesi iki ayrı soruya bağlıdır ve iki soru farklı istek türlerini durdurur: kimlik doğrulama sahte kimliği, yetkilendirme doğrulanmış ama yetkisiz isteği. - Kimlik denetimini çevreden her adıma genişletmek günlük denetimi 2.018'den 7.019'a çıkarıyor (istek başına 0,57'den 2,00'ye) ve doğrulanmış-yetkisiz isteğe karşı 0 yol kapatıyor. - Kimlik geçitte, yetki veri katmanında yerleşiminde 55 yolun 50'si açık kalıyor ve 4 varlığın dördüne de erişiliyor. Son adım yetkiliyse oraya nasıl gelindiği hiç sorulmuyor. - Şube ağı kimliği için veri katmanı denetimi 23 yolun hiçbirini kapatmıyor; kendi meşru işi gereği dört varlığın dördünde de bir adım yetkisi taşıyor. - Yetkiyi her adıma koymak yolu 20'ye indiriyor (istek başına 2,57). Kimliği de her adıma koymak aynı 20'yi veriyor ama istek başına 4,00'e çıkıyor: 1,43 ek adım karşılığında 0 yol. - Yetki her adımda sorulup kimlik hiç sorulmadığında sahte kimlikli istek 20 yol buluyor. İki denetim birbirinin yerine geçmez; biri eksikse açık yol başka bir istek türüne devredilir. #### Sonraki Adım Bu ders iki denetimi ayırdı ve her birinin hangi isteği durdurduğunu saydı. Bütün şemalarda ortak olan bir varsayım vardı: kapsam listesi doğru yazılmış, kapsamda olması gereken her adım kapsamda. Gerçekte bu liste elle yazılır, ağ değiştikçe güncellenir ve bir kalem unutulur. Unutulan kalemin ne olacağı denetimin varsayılanına bağlıdır: kapsam dışı kalan adım geçiriyorsa unutmak bir yol açar, durduruyorsa unutmak bir işi durdurur. Sonraki dersin ölçtüğü şey budur: varsayılan açıkken ve kapalıyken yol sayısı ne oluyor, tek bir kalemi unutmanın bedeli kaç yol ve kaç duran iş ediyor ve bu iki hatanın hangisi kendini gösteriyor. ### Güvenli Varsayılanlar Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/guvenli-varsayilanlar Yirmi iki yapılandırma kaleminden biri unutulduğunda ne olduğu iki varsayılan altında ayrı ayrı sayılır: varsayılan açıkta açılan yol, varsayılan kapalıda duran günlük iş. Unutulan kalem sayısı taranır ve iki hata türünün görünürlük oranı karşılaştırılarak yanlış yapılandırmaya dayanıklılık ölçülür. Önceki ders iki denetimi ayırdı ve her birinin hangi isteği durdurduğunu saydı. Bütün şemalarda ortak bir varsayım vardı: kapsam listesi doğru yazılmış, kapsamda olması gereken her adım kapsamda. Gerçekte bu liste elle yazılır, ağ değiştikçe güncellenir ve bir kalem unutulur. Bu dersin sorusu unutulan kalemin ne olacağıdır. **Güvenli varsayılan** (secure by default), yapılandırılmamış bir kalemin kapalı sayılmasıdır. Karşıtı, yapılandırılmamış kalemin geçirmesidir. İki seçenek yalnız hata anında ayrışır: her şey doğru yazıldığında ikisi de aynı ağı verir. Bu ders o hata anını ölçer — bir kalem unutulduğunda varsayılan açıkta **kaç yol açılıyor**, varsayılan kapalıda **kaç meşru iş duruyor** ve iki hatanın hangisi kendini gösteriyor. Yol sayımı yine kurgusal ağın modeli üzerinde yapılıyor; gerçek bir ağda yapılandırma kalemlerinin taranması **yazılı yetki ve tanımlı kapsam** olmadan yürütülemez. - **SI27.** Yirmi iki adımın her biri bir yapılandırma kalemidir. Tam yapılandırmada her kalem yetki denetimi yapar ve ağ önceki dersin en dar şemasındaki yirmi yola iner. - **SI28.** Unutulan kalem denetim yapmaz. Varsayılan açıkta herkesi geçirir; varsayılan kapalıda herkesi durdurur, meşru akış dahil. - **SI29.** Kalemler birbirinden bağımsız unutulur ve unutulma olasılığı her kalem için eşittir. Gerçekte yeni eklenen kalemler daha çok unutulur; bu, açık varsayılanın bedelini büyütür. - **SI30.** Örnekleme kendi yazılan doğrusal eşlemeli üreteçle yapılır. Tohum görünür ve sabittir; çıktı koşumdan koşuma aynı kalır. - **SI31.** "Görünmez" sütunu, hatanın hiçbir ölçülebilir iz bırakmadığı örneklerin oranıdır: açıkta yol sayısı değişmemiş, kapalıda hiçbir meşru iş durmamış demektir. #### Tek Kalemin Bedeli Yirmi iki kalem tek tek unutuluyor ve her unutmanın iki varsayılan altındaki sonucu ayrı yazılıyor. ```js // ag.mjs — kurgusal bolgesel olcum aginin erisim grafigi ve mesru akislari (model) export const GIRIS = ['saha-uc', 'sube-agi', 'genel-uc', 'bakim-uc']; export const VARLIK = ['olcum-deposu', 'fatura-vt', 'abone-kayit', 'yapilandirma']; export const KENAR = [ ['saha-uc', 'toplayici'], ['saha-uc', 'is-emri'], ['sube-agi', 'toplayici'], ['sube-agi', 'is-emri'], ['sube-agi', 'yonetim'], ['genel-uc', 'toplayici'], ['bakim-uc', 'yonetim'], ['bakim-uc', 'kuyruk'], ['toplayici', 'kuyruk'], ['toplayici', 'olcum-deposu'], ['kuyruk', 'dogrulayici'], ['kuyruk', 'faturalama'], ['dogrulayici', 'olcum-deposu'], ['dogrulayici', 'fatura-vt'], ['faturalama', 'fatura-vt'], ['faturalama', 'abone-kayit'], ['is-emri', 'kuyruk'], ['is-emri', 'abone-kayit'], ['yonetim', 'toplayici'], ['yonetim', 'dogrulayici'], ['yonetim', 'is-emri'], ['yonetim', 'yapilandirma'], ]; // Mesru akis: gunluk kosan is; adim dizisi ayni grafigin kenarlarindan gecer. export const AKIS = [ ['saha-okuma', ['saha-uc', 'toplayici', 'kuyruk'], 1440], ['dogrulama', ['kuyruk', 'dogrulayici', 'olcum-deposu'], 1440], ['genel-okuma', ['genel-uc', 'toplayici', 'olcum-deposu'], 300], ['sube-sorgu', ['sube-agi', 'toplayici', 'olcum-deposu'], 210], ['fatura-yazimi', ['kuyruk', 'faturalama', 'fatura-vt'], 48], ['is-emri-acma', ['sube-agi', 'is-emri', 'abone-kayit'], 32], ['is-emri-kuyruk', ['sube-agi', 'is-emri', 'kuyruk'], 32], ['abone-guncelleme', ['faturalama', 'abone-kayit'], 6], ['yapilandirma-degisikligi', ['sube-agi', 'yonetim', 'yapilandirma'], 2], ['bakim-oturumu', ['bakim-uc', 'yonetim', 'toplayici'], 1], ['kuyruk-bakimi', ['bakim-uc', 'kuyruk'], 1], ['mutabakat', ['yonetim', 'dogrulayici', 'fatura-vt'], 1], ]; export const ad = (a, b) => `${a}>${b}`; export const adimlar = (d) => d.slice(0, -1).map((x, i) => ad(x, d[i + 1])); export function yollar(kapali = new Set()) { const komsu = new Map(); for (const [a, b] of KENAR) if (!kapali.has(ad(a, b))) komsu.set(a, [...(komsu.get(a) || []), b]); const s = []; const yuru = (d, y) => { if (VARLIK.includes(d)) return void s.push(y); for (const k of komsu.get(d) || []) if (!y.includes(k)) yuru(k, [...y, k]); }; for (const g of GIRIS) yuru(g, [g]); return s; } export const kesilen = (kapali) => AKIS.filter(([, d]) => adimlar(d).some((k) => kapali.has(k))); ``` ```js // varsayilan.mjs — yapilandirilmamis kalemin varsayilan durumu ve yol sayimi import { KENAR, AKIS, GIRIS, VARLIK, ad, adimlar } from './ag.mjs'; export const KENAR_AD = KENAR.map(([a, b]) => ad(a, b)); const ORTAK = new Set(AKIS.filter(([, d]) => !GIRIS.includes(d[0])).flatMap(([, d]) => adimlar(d))); const kendi = (g) => AKIS.filter(([, d]) => d[0] === g).flatMap(([, d]) => adimlar(d)); export const YETKI = Object.fromEntries(GIRIS.map((g) => [g, new Set([...ORTAK, ...kendi(g)])])); const komsu = new Map(); for (const [a, b] of KENAR) komsu.set(a, [...(komsu.get(a) || []), b]); // Yapilandirilmis kalem yetki denetler; unutulan kalem varsayilanina gore gecirir ya da durdurur. export function yolSay(unutulan, varsayilan) { const U = new Set(unutulan); let n = 0; for (const g of GIRIS) { const yuru = (d, y) => { if (VARLIK.includes(d)) return void n++; for (const k of komsu.get(d) || []) { const e = ad(d, k); if (U.has(e)) { if (varsayilan === 'kapali') continue; } else if (!YETKI[g].has(e)) continue; if (!y.includes(k)) yuru(k, [...y, k]); } }; yuru(g, [g]); } return n; } export function uretec(tohum) { let s = tohum >>> 0; return () => { s = (Math.imul(s, 1664525) + 1013904223) >>> 0; return s / 4294967296; }; } ``` ```js // kosum1.mjs — tek kalem unutulunca: varsayilan acikta acilan yol, kapalida duran is import { AKIS, adimlar } from './ag.mjs'; import { KENAR_AD, yolSay } from './varsayilan.mjs'; const tam = yolSay([], 'acik'); const duran = (k) => AKIS.filter(([, d]) => adimlar(d).includes(k)).reduce((s, [, , n]) => s + n, 0); const sat = KENAR_AD.map((k) => [k, yolSay([k], 'acik') - tam, duran(k)]); console.log(`tam yapilandirmada yol ${tam}, yapilandirma kalemi ${KENAR_AD.length}\n`); console.log('varsayilan acik — unutulunca en cok yol acan kalem'); for (const [k, a] of [...sat].sort((x, y) => y[1] - x[1]).slice(0, 5)) console.log(` ${k.padEnd(26)}+${a} yol`); console.log('\nvarsayilan kapali — unutulunca en cok is durduran kalem'); for (const [k, , c] of [...sat].sort((x, y) => y[2] - x[2]).slice(0, 5)) console.log(` ${k.padEnd(26)}${c} gunluk istek durur`); console.log(''); for (const [etiket, v] of [ ['acikta ortalama acilan yol', (sat.reduce((s, x) => s + x[1], 0) / sat.length).toFixed(2)], ['acikta hicbir yol acmayan kalem', `${sat.filter((x) => x[1] === 0).length} / ${sat.length}`], ['kapalida ortalama duran gunluk istek', Math.round(sat.reduce((s, x) => s + x[2], 0) / sat.length)], ['kapalida hicbir isi durdurmayan kalem', `${sat.filter((x) => x[2] === 0).length} / ${sat.length}`], ]) console.log(`${etiket.padEnd(40)}${v}`); ``` ``` tam yapilandirmada yol 20, yapilandirma kalemi 22 varsayilan acik — unutulunca en cok yol acan kalem toplayici>kuyruk +12 yol yonetim>is-emri +5 yol toplayici>olcum-deposu +2 yol yonetim>toplayici +1 yol yonetim>yapilandirma +1 yol varsayilan kapali — unutulunca en cok is durduran kalem saha-uc>toplayici 1440 gunluk istek durur toplayici>kuyruk 1440 gunluk istek durur kuyruk>dogrulayici 1440 gunluk istek durur dogrulayici>olcum-deposu 1440 gunluk istek durur toplayici>olcum-deposu 510 gunluk istek durur acikta ortalama acilan yol 0.95 acikta hicbir yol acmayan kalem 17 / 22 kapalida ortalama duran gunluk istek 319 kapalida hicbir isi durdurmayan kalem 2 / 22 ``` İki listenin şekli farklıdır. Açık varsayılanda dağılım son derece dengesiz: bir kalem on iki yol açıyor, bir kalem beş, üç kalem birer ikişer ve geri kalan on yedi kalem hiçbir şey açmıyor. Ortalama sıfır virgül doksan beş yol, ama ortalama burada anlamsızdır — bedel bir kalemde toplanmış durumda. Kuyruğa yazma adımının denetimi unutulursa yol sayısı yirmiden otuz ikiye çıkıyor, yani ağı elli beş yoldan yirmiye indiren bütün çalışmanın üçte biri tek bir kalemin unutulmasıyla geri veriliyor. Kapalı varsayılanda dağılım tersine dengelidir. Yirmi iki kalemin yirmisi unutulduğunda en az bir meşru iş duruyor; ortalama günde üç yüz on dokuz istek. Dört ayrı kalem günde bin dört yüz kırk isteği durduruyor, çünkü saha okuma ve doğrulama akışları ağın en yoğun işleridir. Bir bakıma bu, kapalı varsayılanın maliyetidir; başka bir bakıma **hatanın hemen ortaya çıkmasının garantisidir**. İki listenin kesişimi de dikkat ister. Kuyruğa yazma adımı iki listede de en üstte: açık varsayılanda en çok yol açan kalem odur, kapalı varsayılanda en çok işi durduran dört kalemden biridir. En yoğun kullanılan adım aynı zamanda en çok yol taşıyan adımdır ve hangi varsayılan seçilirse seçilsin en pahalı kalemler arasındadır. Yapılandırma denetiminin ilk bakacağı yer, en çok trafik geçen adımdır. Bu kalem her iki varsayılanda da ayrı bir doğrulamayı hak eder; hangi varsayılan seçilmiş olursa olsun, elde edilen daralmanın üçte birini tek başına taşıyan bir kalemin doğru yazıldığı ayrıca sınanmalıdır. #### Kaç Kalem Unutulursa Bir kalem gerçekçi bir hata sayısı değildir. Aynı ölçüm k kalem unutulduğunda tekrarlanıyor ve üçüncü bir sütun ekleniyor: hatanın hiç iz bırakmama oranı. ```js // kosum2.mjs — k kalem unutulunca iki varsayilanin bedeli ve hatanin gorunurlugu import { AKIS, adimlar } from './ag.mjs'; import { KENAR_AD, yolSay, uretec } from './varsayilan.mjs'; const TOHUM = 20260802, ORNEK = 200, tam = yolSay([], 'acik'); const r = uretec(TOHUM); const sec = (k) => { const a = [...KENAR_AD]; for (let i = a.length - 1; i > 0; i--) { const j = Math.floor(r() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; } return a.slice(0, k); }; const durus = (u) => AKIS.filter(([, d]) => adimlar(d).some((x) => u.includes(x))).reduce((s, [, , n]) => s + n, 0); console.log(`tohum ${TOHUM}, ornek ${ORNEK}, tam yapilandirmada yol ${tam}`); console.log('unutulan acik: ort yol en kotu gorunmez kapali: ort duran en kotu gorunmez'); for (const k of [1, 2, 3, 5, 8, 22]) { const say = k === 22 ? 1 : ORNEK, o = { a: 0, am: 0, ag: 0, c: 0, cm: 0, cg: 0 }; for (let i = 0; i < say; i++) { const u = k === 22 ? KENAR_AD : sec(k); const ya = yolSay(u, 'acik'), dur = durus(u); o.a += ya; o.am = Math.max(o.am, ya); if (ya === tam) o.ag++; o.c += dur; o.cm = Math.max(o.cm, dur); if (dur === 0) o.cg++; } console.log(`${String(k).padEnd(10)}${(o.a / say).toFixed(1).padEnd(13)}${String(o.am).padEnd(9)}` + `${`%${Math.round((o.ag / say) * 100)}`.padEnd(10)}${(o.c / say).toFixed(0).padEnd(19)}` + `${String(o.cm).padEnd(9)}%${Math.round((o.cg / say) * 100)}`); } ``` ``` tohum 20260802, ornek 200, tam yapilandirmada yol 20 unutulan acik: ort yol en kotu gorunmez kapali: ort duran en kotu gorunmez 1 21.3 32 %73 347 1440 %9 2 22.3 37 %53 644 2880 %1 3 23.2 41 %44 969 2944 %0 5 24.9 42 %22 1343 3423 %0 8 29.4 50 %8 2050 3510 %0 22 55.0 55 %0 3513 3513 %0 ``` Görünmez sütunları bu dersin cevabıdır. Tek bir kalem unutulduğunda açık varsayılanda hatanın yüzde yetmiş üçü hiçbir iz bırakmıyor: yol sayısı değişmiyor, kimse fark etmiyor, kayıt düşmüyor. Aynı hata kapalı varsayılanda yüzde doksan bir olasılıkla bir işi durduruyor ve durdurduğu anda görülüyor. İki hatanın büyüklüğü değil, **bulunabilirliği** farklıdır. Fark unutulan kalem sayısı arttıkça kapanıyor ama yanlış yönde. Açık varsayılanda üç kalem unutulduğunda hâlâ yüzde kırk dördü sessiz; sekiz kalemde yüzde sekiz. Kapalı varsayılanda iki kalemde sessizlik yüzde bire, üç kalemde sıfıra iniyor. Yani açık varsayılanla çalışan bir sistem, biriken yanlış yapılandırmayı yıllarca taşıyabilir; kapalı varsayılanla çalışan bir sistem ikinci hatada kendini bildirir. En kötü durum sütunları da simetrik değil. Açık varsayılanda tek bir kalemin unutulması yol sayısını otuz ikiye, sekiz kalem elliye çıkarıyor; yirmi ikisinin unutulması elli beşe, yani hiçbir savunma yokmuş gibi bir ağa. Kapalı varsayılanda aynı uçta ağ tamamen duruyor: günde üç bin beş yüz on üç isteğin tamamı. İki hatanın sonucu da felakettir, ancak biri sessiz bir açıklık, diğeri gürültülü bir kesintidir. Güvenli varsayılanın gerekçesi, ikinci tür hatanın **onarılacağının bilinmesidir**; birinci tür hata onarılmaz, çünkü varlığı bilinmez. Modelin bir yanlılığı da yazılmalıdır. Kalemlerin eşit olasılıkla unutulduğu kabul edildi. Gerçekte unutulan kalem rastgele seçilmez: yeni eklenen bir servisin adımları, nadiren değişen eski adımlardan daha çok unutulur. Tabloda hiçbir işi durdurmayan iki kalem, henüz meşru trafik taşımayan adımlardır; yeni eklenen adımlar da ilk günlerinde aynı gruba düşer. Bu iki gözlem birleştiğinde açık varsayılanın gerçek bedeli tablodakinden büyük çıkar: unutmanın en olası olduğu yer, kapalı varsayılanın en sessiz kaldığı ve dolayısıyla hatanın en geç görüldüğü yerdir. Ölçümü gerçeğe yaklaştırmanın yolu, unutulma olasılığını kalemin yaşına bağlamaktır; bu ders o adımı atmıyor, ancak atıldığında sonucun hangi yöne kayacağı bellidir. Ortalama sütunları bir denge noktası da veriyor. Beş kalem unutulduğunda açık varsayılanda ortalama yirmi beş yol açık kalıyor; tam yapılandırmadaki yirmiye göre beş yol fazla. Aynı beş kalem kapalı varsayılanda günde bin üç yüz kırk üç isteği durduruyor, yani günlük işin yüzde otuz sekizini. Kapalı varsayılanın bedeli açıkça daha büyüktür ve bu bedel doğrudan işletmeye yansır. Karar bu iki sayı arasında verilir — ama görünmez sütunu okunmadan verilen bir karar, yalnız birinci sütunu okumaktır. #### Özet - Tam yapılandırmada 22 kalemin hepsi yetki denetler ve ağ 20 yola iner. Unutulan kalemin sonucu yalnız varsayılana bağlıdır; iki varsayılan hatasız durumda aynı ağı verir. - Açık varsayılanda tek kalem unutmanın dağılımı dengesizdir: bir kalem 12 yol açıyor, 17 kalem hiçbir şey açmıyor. Ortalama 0,95 yol, ama bedel tek bir kalemde toplanmıştır. - Kapalı varsayılanda 22 kalemin 20'si unutulduğunda en az bir işi durduruyor; ortalama günde 319 istek, en kötü 1.440. Bu hem maliyettir hem de hatanın hemen görülmesinin güvencesidir. - Görünmezlik oranı asıl farkı veriyor: tek kalem unutulduğunda açık varsayılanda hataların %73'ü hiç iz bırakmıyor, kapalı varsayılanda yalnız %9'u. - Fark hata sayısı arttıkça yanlış yönde kapanıyor: 3 kalemde açık varsayılan hâlâ %44 sessiz, kapalı varsayılan %0. Açık varsayılanla çalışan sistem yanlış yapılandırmayı biriktirir. - En kötü uçta 22 kalemin unutulması açık varsayılanda ağı 55 yola, yani hiç savunma yokmuş hâline döndürüyor; kapalı varsayılanda günlük 3.513 isteğin tamamını durduruyor. #### Sonraki Adım Altı ilke aynı yol kümesi üzerinde ölçüldü ve her birinin bedeli sayıldı. Derinlemesine savunma elli beş yolun elli ikisini kapattı ve altmış üç kalem bakım yükü getirdi; en az yetki kırk üç yolu günde on bir isteğin bedeliyle kapattı; yalıtım erişilen kalemi on üçten dört virgül sekize indirdi ve yirmi geçit istedi; sıfır güven yolu yirmiye indirdi ve istek başına iki ek adım ekledi; kimlik ile yetki ayrımı yanlış katmanda duran denetimin otuz yolu açık bıraktığını gösterdi; güvenli varsayılan bir kalemin unutulmasının açık varsayılanda yüzde yetmiş üç olasılıkla sessiz kaldığını ortaya çıkardı. Bütün bu tablolarda sorulmayan bir soru var. Ölçümleri **kim** yapacak? Bir katmanın hiçbir yeni yol kapatmadığını kim fark edecek, bir geçidin gereksiz olduğunu kim sınayacak, unutulan kalemi kim tarayacak? Sayılar kendiliğinden ortaya çıkmadı; her biri, savunmayı kuran taraftan bağımsız bir sınama gerektirir. Sonraki konu bu soruyu ele alıyor: savunmayı kuran, saldıran gibi düşünen ve ikisini birleştiren rollerin işlevi nedir, bu işler hangi meslek tanımlarına dağılır ve bir sınamanın hangi yazılı sınır içinde yapılabileceğini ne belirler. ## Alan ve Roller Ölçümü kimin yaptığı ve hangi sınırda yapılabildiği: mavi, kırmızı ve mor takımların aynı yol kümesinde gördüğü yolun ayrılması, bilgi boşluğunun sayılması, güvenlik rollerinin sorumluluk kalemi cinsinden bölünmesi, boşlukta kalan ve çakışan kalemin ölçülmesi, yetkilendirme, kapsam ve sorumluluğun sayılabilir kalem olarak kurulması, mesleki yetkinlik yollarının ölçtüğü yetenek kümesinin karşılaştırılması. ### Mavi, Kırmızı ve Mor Takımlar Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/mavi-kirmizi-ve-mor-takimlar Üç takımın aynı yol kümesindeki farkı: 30 yollu erişim grafiğinde savunmanın bildiği 11 yol, saldırı tarafının bulduğu 15 yol, ikisinin kesişmediği 8 kalem, hiçbirinin görmediği 13 yol; mor çalışmanın bilgi boşluğunu 6'dan 0'a indirmesi, kapanan yolun 17'den 22'ye çıkarken duran meşru isteğin 2.764'ten 2.037'ye inmesi ve kapsam dışı 8 yolun kalması. Önceki konu altı savunma ilkesini aynı yol kümesinde ölçtü ve her birinin kapattığı yol ile durdurduğu meşru işi yan yana yazdı. Bütün o ölçümlerde sessiz bir varsayım vardı: **yol kümesinin kendisi biliniyor.** Kapatılan yol sayılabildiyse, sayılan yol önceden bir yerde yazılıydı demektir. Bu ders o varsayımı kaldırır ve tek bir soru sorar: bir kurumun bildiği yol kümesi ile gerçekten var olan yol kümesi arasındaki fark kaç kalemdir, o farkı kim bulur. Üç çalışma biçimi vardır. **Mavi takım** savunmayı işletir: envanteri tutar, denetimi kurar, kaydı okur. **Kırmızı takım** aynı varlığa ulaşan yolları yazılı yetki ve tanımlı kapsam içinde arar; bulduğu her yol savunmanın listesinde olmayan bir kalem olabilir. **Mor takım** ayrı bir kadro değil, iki tarafın aynı yol kümesi üzerinde birlikte çalışma biçimidir. Bu ders üçünü de tek bir sayıda ayırır: **aynı yol kümesinde kimin kaç yolu gördüğü.** #### Üç Takım, Tek Yol Kümesi Örnek, kursun kurgu **bölgesel ölçüm ağı**dır. Aşağıdaki graf bir **modeldir**; gerçek bir ana bilgisayar, gerçek bir adres ya da gerçek bir servis ucu yoktur. - **AR1.** Erişim grafiği 12 düğüm ve 20 adımdır; 3 giriş noktası, 2 korunan varlık. **Yol**, bir giriş düğümünden bir varlığa giden, düğüm tekrarı olmayan yürüyüştür. - **AR2.** Savunma bir yolu ancak yolun **bütün** düğümleri varlık envanterinde yazıyorsa bilir. Envanterde olmayan tek bir düğüm, o düğümden geçen bütün yolları görünmez yapar. - **AR3.** Saldırı tarafı bir yolu ancak bütün düğümleri **yazılı kapsamın** içindeyse ve adım sayısı **adım bütçesini** aşmıyorsa bulur. Ayrı çalışmada bütçe 4 adımdır. - **AR4.** Mor çalışmada envanter paylaşılır: kırmızının dokunduğu her düğüm envantere girer ve keşif için adım harcanmadığından bütçe 6'ya çıkar. - **AR5.** Her adım günde belli sayıda meşru istek taşır; sayılar kurgudur. - **AR6.** Bir yol, üzerindeki bir adım kesilerek kapanır. Savunma **anladığı** bir yolda en az meşru istek taşıyan adımı keser. - **AR7.** Yalnız rapordan öğrenilen, ara düğümleri envanterde olmayan bir yolda savunma adlandırabildiği tek adımı — **giriş adımını** — keser. - **AR8.** Meşru işe bedel, kesilen **ayrık** adım kümesinin taşıdığı meşru istek toplamıdır; aynı adım birden çok yolu kapatıyorsa bir kez sayılır. ```js // takim/ag.mjs — kurgu bolgesel olcum aginin erisim grafi (MODEL). Gercek bir ana bilgisayar, // gercek bir adres ya da gercek bir servis ucu yoktur; butun sayilar kurgudur. // dugum: envanter = savunmanin varlik listesinde yaziyor mu; // kapsam = yazili yetkilendirmenin sinirlari icinde mi (ucuncu taraf ucu disaridadir). export const DUGUM = ` saha-terminali giris evet evet abone-portali giris evet evet tedarikci-ucu giris hayir hayir sube-anahtari ara hayir evet toplayici ara evet evet dogrulayici ara evet evet kimlik-dizini ara evet evet yonetim-agi ara evet evet is-emri ara evet evet yedek-ucu ara hayir evet okuma-deposu varlik evet evet faturalama varlik evet evet` .trim().split("\n").map((r) => { const [ad, tur, env, kap] = r.trim().split(/\s+/); return { ad, tur, envanter: env === "evet", kapsam: kap === "evet" }; }); // kenar: adim ve o adimdan gunde gecen mesru istek sayisi (kurgu). export const KENAR = ` saha-terminali toplayici 420 saha-terminali sube-anahtari 35 abone-portali dogrulayici 900 abone-portali kimlik-dizini 760 tedarikci-ucu yonetim-agi 18 tedarikci-ucu yedek-ucu 6 sube-anahtari yonetim-agi 24 sube-anahtari toplayici 110 toplayici dogrulayici 380 toplayici okuma-deposu 540 dogrulayici okuma-deposu 610 dogrulayici faturalama 290 kimlik-dizini yonetim-agi 44 kimlik-dizini is-emri 150 yonetim-agi toplayici 60 yonetim-agi yedek-ucu 12 yonetim-agi kimlik-dizini 38 yedek-ucu okuma-deposu 9 is-emri dogrulayici 130 is-emri faturalama 95` .trim().split("\n").map((r) => { const [a, b, m] = r.trim().split(/\s+/); return { a, b, mesru: Number(m) }; }); const bul = (ad) => DUGUM.find((d) => d.ad === ad); export const GIRIS = DUGUM.filter((d) => d.tur === "giris").map((d) => d.ad); export const VARLIK = DUGUM.filter((d) => d.tur === "varlik").map((d) => d.ad); // Butun basit yollar: giris dugumunden varliga, dugum tekrari olmadan. export function yollar() { const cikis = {}; for (const k of KENAR) (cikis[k.a] ??= []).push(k.b); const hepsi = []; const yuru = (d, iz) => { if (VARLIK.includes(d)) { hepsi.push([...iz]); return; } for (const s of cikis[d] ?? []) if (!iz.includes(s)) yuru(s, [...iz, s]); }; for (const g of GIRIS) yuru(g, [g]); return hepsi.map((iz) => ({ iz, adim: iz.length - 1, kenar: iz.slice(0, -1).map((_, i) => `${iz[i]}>${iz[i + 1]}`), })); } export const kenarMesru = (e) => { const [a, b] = e.split(">"); return KENAR.find((k) => k.a === a && k.b === b).mesru; }; // Savunma bir yolu ancak butun dugumleri envanterinde yaziyorsa bilir. export const maviBilir = (y) => y.iz.every((d) => bul(d).envanter); // Saldiri tarafi bir yolu ancak butun dugumleri kapsamdaysa ve adim sayisi butcesini // asmiyorsa bulur; kapsam disi dugume dokunmak yetkilendirmenin disina cikmaktir. export const kirmiziBulur = (y, butce) => y.iz.every((d) => bul(d).kapsam) && y.adim <= butce; ``` #### Kim Neyi Biliyor ```js // takim/olc.mjs — ayni yol kumesinde savunmanin bildigi, saldiri tarafinin buldugu ve // ikisinin de gormedigi yol; sonra kapatmanin mesru ise bedeli. import { yollar, DUGUM, KENAR, kenarMesru, maviBilir, kirmiziBulur } from "./ag.mjs"; const Y = yollar(); const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const ENV0 = new Set(DUGUM.filter((d) => d.envanter).map((d) => d.ad)); const bilir = (y, env) => y.iz.every((d) => env.has(d)); const BUTCE = 4, MOR_BUTCE = 6; // kurgu: mor calismada kesif adimi harcanmaz // Mor calisma: kirmizinin dokundugu her dugum envantere girer, kirmizi envanteri okur. const DOKUNULAN = new Set(); for (const y of Y) if (kirmiziBulur(y, BUTCE)) y.iz.forEach((d) => DOKUNULAN.add(d)); const ENV1 = new Set([...ENV0, ...DOKUNULAN]); const durum = (env, b) => { const m = Y.filter((y) => bilir(y, env)), k = Y.filter((y) => kirmiziBulur(y, b)); const kes = m.filter((y) => k.includes(y)); return { m: m.length, k: k.length, ortak: kes.length, ym: m.length - kes.length, yk: k.length - kes.length, hic: Y.length - (m.length + k.length - kes.length) }; }; const A = durum(ENV0, BUTCE), M = durum(ENV1, MOR_BUTCE); console.log(`erisim grafi MODELI: ${DUGUM.length} dugum, ${KENAR.length} adim, ` + `${Y.length} basit yol; adim butcesi ayri calismada ${BUTCE}, mor calismada ${MOR_BUTCE}.`); const T = [-38, 9, 8]; console.log("\n1. ayni yol kumesinde kim neyi biliyor"); yaz(T, "olcu", "ayri", "mor"); for (const [ad, f] of [["savunmanin bildigi yol", (r) => r.m], ["saldiri tarafinin buldugu yol", (r) => r.k], [" ikisinin de bildigi", (r) => r.ortak], [" yalniz savunmanin bildigi", (r) => r.ym], [" yalniz saldirinin buldugu (bosluk)", (r) => r.yk], ["hicbirinin gormedigi yol", (r) => r.hic]]) yaz(T, ad, f(A), f(M)); // Kapatma: bilinen yolda en az mesru istek tasiyan adim kesilir; yalnizca rapordan // ogrenilen yolda savunma adlandirabildigi tek adimi, giris adimini kapatir. const dar = (y) => y.kenar.reduce((a, e) => (kenarMesru(e) < kenarMesru(a) ? e : a)); const bedel = (kesilen) => ({ adim: kesilen.size, mesru: [...kesilen].reduce((a, e) => a + kenarMesru(e), 0) }); const yol1 = Y.filter((y) => bilir(y, ENV0)); const yol2 = Y.filter((y) => bilir(y, ENV0) || kirmiziBulur(y, BUTCE)); const yol3 = Y.filter((y) => bilir(y, ENV1) || kirmiziBulur(y, MOR_BUTCE)); const K1 = new Set(yol1.map(dar)); const K2 = new Set([...yol1.map(dar), ...yol2.filter((y) => !bilir(y, ENV0)).map((y) => y.kenar[0])]); const K3 = new Set(yol3.map(dar)); const D = [-24, 10, 8, 10, 13]; console.log("\n2. kapatmanin mesru ise bedeli (mesru istek: gun basina, kurgu)"); yaz(D, "calisma bicimi", "kapanan", "kalan", "kesilen", "duran mesru"); for (const [ad, y, k] of [["yalniz savunma", yol1, K1], ["savunma + ayri sinama", yol2, K2], ["mor calisma", yol3, K3]]) { const b = bedel(k); yaz(D, ad, y.length, Y.length - y.length, b.adim, b.mesru); } const pahali = [...K2].filter((e) => !K3.has(e)) .reduce((a, e) => (kenarMesru(e) > kenarMesru(a) ? e : a)); const oYol = yol2.find((y) => y.kenar[0] === pahali && !bilir(y, ENV0)); console.log(`\nayri sinamada en pahali kesme: ${pahali} (${kenarMesru(pahali)} mesru istek),`); console.log(` kapattigi yol: ${oYol.iz.join(" > ")}`); console.log(` mor calismada ayni yol ${dar(oYol)} kesilerek kapaniyor: ` + `${kenarMesru(dar(oYol))} mesru istek.`); const kapsamDisi = Y.filter((y) => !y.iz.every((d) => DUGUM.find((x) => x.ad === d).kapsam)); console.log(`mor calismadan sonra kalan ${M.hic} yolun ${kapsamDisi.length} tanesi ` + `kapsam disi bir dugumden geciyor.`); ``` ``` erisim grafi MODELI: 12 dugum, 20 adim, 30 basit yol; adim butcesi ayri calismada 4, mor calismada 6. 1. ayni yol kumesinde kim neyi biliyor olcu ayri mor savunmanin bildigi yol 11 22 saldiri tarafinin buldugu yol 15 22 ikisinin de bildigi 9 22 yalniz savunmanin bildigi 2 0 yalniz saldirinin buldugu (bosluk) 6 0 hicbirinin gormedigi yol 13 8 2. kapatmanin mesru ise bedeli (mesru istek: gun basina, kurgu) calisma bicimi kapanan kalan kesilen duran mesru yalniz savunma 11 19 7 1969 savunma + ayri sinama 17 13 9 2764 mor calisma 22 8 10 2037 ayri sinamada en pahali kesme: abone-portali>kimlik-dizini (760 mesru istek), kapattigi yol: abone-portali > kimlik-dizini > yonetim-agi > yedek-ucu > okuma-deposu mor calismada ayni yol yedek-ucu>okuma-deposu kesilerek kapaniyor: 9 mesru istek. mor calismadan sonra kalan 8 yolun 8 tanesi kapsam disi bir dugumden geciyor. ``` Birinci tablonun `ayri` sütunu üç takımın ayrı ayrı çalıştığı düzeni okur. Grafta 30 yol vardır. Savunma bunların **11'ini** bilir; saldırı tarafı **15'ini** bulur. İki sayı yakın görünse de aynı yolları göstermezler: kesişim yalnız **9** kalemdir. Kesişmeyen iki kalem birbirinin aynı değildir. **Yalnız savunmanın bildiği 2 yol** zararsızdır: bu yollar 5 adım uzunluğundadır ve saldırı tarafının bütçesi 4 adımdır. Savunma onları biliyor ve kapatabiliyor; sınama bulmadı diye ortadan kalkmıyorlar. **Yalnız saldırı tarafının bulduğu 6 yol** ise **bilgi boşluğudur**: envanterde yazmayan iki düğümden — şube anahtarı ve yedek ucundan — geçtikleri için savunmanın listesinde hiç yoktular. Bir kurumun kendi ağı hakkında bilmediği şeyin sayısı, ancak dışarıdan bir sınama o sayıyı ölçtüğünde yazılabilir. Son satır iki takımın da göremediğini verir: **13 yol**. Bu sayı toplam yolun neredeyse yarısıdır ve iki ayrı nedenden doğar. Bir bölümü savunmanın envanterinde olmayan düğümlerden geçer ve saldırı tarafının bütçesini aşacak kadar uzundur; kalanı ise **kapsamın dışındaki** üçüncü taraf ucundan başlar. Yazılı yetki ve tanımlı kapsam olmadan bir sistem üzerinde sınama yapmak hem yasadışı hem meslek dışıdır; kapsam dışı bir düğüme dokunulmamasının nedeni teknik bir engel değil, bu sınırdır. #### Mor Çalışma Neyi Kapatıyor `mor` sütunu iki değişikliğin sonucudur ve ikisi de bilgi alışverişidir. Savunma, sınamanın dokunduğu düğümleri envanterine ekler; şube anahtarı ve yedek ucu artık listededir. Sınama tarafı envanteri okuduğu için keşfe adım harcamaz ve bütçesi 4'ten 6'ya çıkar. Yeni bir denetim kurulmadı, yeni bir araç alınmadı, grafta tek bir adım değişmedi. Sonuç dört satırda birden değişir. Savunmanın bildiği yol 11'den **22'ye**, saldırı tarafının bulduğu yol 15'ten **22'ye** çıkar ve ikisi **aynı 22 yoldur**: kesişmeyen kalem sıfırlanır. Bilgi boşluğu **6'dan 0'a** iner. Görülmeyen yol 13'ten **8'e** düşer. Mor çalışmanın ölçülen katkısı budur: savunmanın tek başına ulaşamadığı **11 yol** ortak listeye girer. Bu yolların hiçbiri yeni değildir — 30 yol baştan beri graftaydı. Kapanan şey bir açık değil, **bir bilgi boşluğudur**. #### Kapatmanın Bedeli İkinci tablo aynı üç düzeni savunmanın asıl işi cinsinden okur: kaç yol kapanıyor ve karşılığında kaç meşru istek duruyor. Yalnız savunma çalıştığında 11 yol kapanır, 19'u açık kalır ve 7 adım kesilerek günde **1.969** meşru istek durur. Sınama eklendiğinde kapanan yol 17'ye çıkar, ama duran meşru istek **2.764'e** fırlar: 6 yol daha kapatmanın bedeli 795 istektir, yani yol başına 132. Mor çalışmada kapanan yol **22**, duran meşru istek **2.037'dir**: sınamalı düzene göre **5 yol fazla kapanıyor ve 727 meşru istek daha az duruyor**. Bu ters yön son üç satırda açıklanıyor. Ayrı çalışan bir düzende savunma, raporda okuduğu bir yolu kapatmak zorundadır ama o yolun ara düğümleri envanterinde yazmaz; adlandırabildiği tek adım giriş adımıdır. Abone portalından kimlik dizinine giden adımı keser ve günde **760** meşru istek durur. Aynı yol mor çalışmada yedek ucundan okuma deposuna giden adım kesilerek kapanır: **9** meşru istek. Kapanan yol aynıdır, bedel **84 kat** farklıdır. Kural buradan çıkar: **anlaşılmadan kapatılan yol, kapanır ama pahalıya kapanır.** Bir bulgu listesi hangi yolun açık olduğunu söyler; hangi adımın kesilmesi gerektiğini söylemez. O adımı seçmek için yolun her düğümünün ne iş yaptığını bilmek gerekir ve o bilgi savunma tarafındadır. Mor çalışmanın kapattığı boşluk çift yönlüdür: savunma yolun varlığını, sınama tarafı yolun üzerindeki meşru işi öğrenir. #### Sınamanın Yetmediği Yer Mor çalışmadan sonra bile **8 yol** kimsenin listesinde değildir ve çıktının son satırı bu 8 yolun tamamının **kapsam dışı** bir düğümden geçtiğini yazar. Üçüncü taraf ucu ne savunmanın envanterindedir ne de sınamanın yetkilendirildiği alandadır. Bu kalan, daha iyi bir sınamayla kapanmaz. Bütçeyi 6'dan 10'a çıkarmak yeni yol bulmaz, çünkü engel adım sayısı değildir. Envanteri genişletmek de yetmez, çünkü o uç başka bir kurumun elindedir ve üzerinde sınama yapma yetkisi ayrı bir yazılı anlaşmayla verilir. Yol kümesinin bir bölümü teknik bir eksiklikten değil, **yetkilendirmenin sınırından** ötürü ölçülmemiş kalır — ve ölçülmemiş bir yol, kapatılmamış bir yoldur. #### Özet - 30 yollu grafta savunma 11, saldırı tarafı 15 yol görür; kesişim 9'dur. Kesişmeyen 8 kalemin 2'si savunmanın bildiği uzun yol, **6'sı bilgi boşluğudur** — envanterde olmayan iki düğümden geçtiği için savunmanın hiç bilmediği yollar. - Ayrı çalışmada 13 yol iki tarafın da görüş alanının dışındadır; mor çalışmadan sonra bu sayı 8'e iner ve bilgi boşluğu 6'dan 0'a düşer. Grafta tek bir adım değişmez, yalnız bilgi paylaşılır. - Mor çalışma kapanan yolu 17'den 22'ye çıkarırken duran meşru isteği 2.764'ten 2.037'ye indirir: daha çok yol, daha az bedel. - Anlaşılmayan bir yol pahalıya kapanır. Rapordan öğrenilen bir yolda savunma giriş adımını keser (760 meşru istek); aynı yol mor çalışmada 9 meşru istek taşıyan adımla kapanır. - Kalan 8 yolun tamamı kapsam dışı bir düğümden geçer. Bu kalan, bütçeyi büyüterek değil ancak yetkilendirmenin sınırını değiştirerek ölçülebilir. #### Sonraki Adım Bu ders üç çalışma biçimini ayırdı ve aralarındaki farkı tek bir sayıya bağladı: aynı yol kümesinde kimin kaç yolu gördüğü. Ölçüm bir şeyi göstermiş oldu — savunma bir kadro değil, birbirini tamamlayan **işlerin** toplamıdır. Envanteri tutan iş ile yolu arayan iş ayrı ellerdedir ve ikisi konuşmadığında 11 yol ortak listeye hiç girmez. Yine de "mavi" ve "kırmızı" birer takım adıdır, iş adı değil. Envanteri kim tutuyor, kesilecek adımı kim seçiyor, kesildikten sonra kalan kaydı kim okuyor, mimarideki kararı kim veriyor? Bir sonraki ders aynı yol kümesini bu kez **rol** cinsinden böler ve iki sayıyı arar: kaç yol hiçbir rolün üzerinde değil, kaç yol iki rolün birden üzerinde. ### Güvenlik Rolleri Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/guvenlik-rolleri Rollerin sorumluluk kalemi cinsinden ayrılması: 9 kalem türü ve 3 görevden oluşan 27 hücrede tek sahipli 15, sahipsiz 7, iki sahipli 3 ve sınırın öte yanında 2 hücre; sahipsiz kalemin 12 yolu daha pahalı bir adımdan kapattırması, 2 yolun hiç kapanmaması, 15 kapatmanın iki onay istemesi ve sınırın yazılmasıyla duran meşru isteğin 2.321'den 2.135'e inmesi. Önceki ders üç çalışma biçimini aynı yol kümesinde ayırdı ve mor çalışmanın kapattığı bilgi boşluğunu saydı. O ölçüm bir soruyu açıkta bıraktı: yollar bilindikten sonra **kim** hangi adımı kesecek. "Mavi" ve "kırmızı" birer çalışma biçiminin adıdır; bir kurumda işi yapan şey biçim değil, adı yazılı bir sorumluluk kalemidir. Bu ders yolları bilindiği varsayımıyla ele alır ve sahipliği ölçer. Güvenlik işi beş rolde toplanır: **güvenlik operasyonu** kaydı okur ve olayı yürütür; **güvenlik sınaması** yolu arar ve kapalı olduğunu doğrular; **güvenlik mimarisi** tasarım kararını ve varsayılanı belirler; **yönetişim** politikayı, riski ve üçüncü taraf sözleşmesini taşır; **sistem ve ağ işletimi** değişikliği gerçekten uygular. Sorulan iki sayı şudur: aynı yol kümesinde kaç kalem **hiçbir** rolün üzerinde değil, kaç kalem **iki** rolün birden üzerinde. #### Kalem, Görev ve Sahip Rolleri isim isim saymak bir sorumluluk ölçüsü vermez; aynı isim iki kurumda başka işi kapsar. Ölçülebilir birim **sorumluluk kalemi**dir: bir adımı kesmek için değiştirilmesi gereken şey. - **AR9.** Yol kümesi önceki dersin grafından gelir: 20 adım, 30 yol. Her adım bir **kalem türüne** bağlıdır; 9 kalem türü vardır. - **AR10.** Her kalem türünün üç görevi vardır: **bul** (kalemin var olduğunu bilmek ve listede tutmak), **kapat** (değişikliği uygulamak), **sürdür** (kapalı kaldığını doğrulamak). Matris 9 × 3 = 27 hücredir. - **AR11.** Bir hücrenin sahibi 0, 1 ya da 2 rol olabilir. - **AR12.** `dis` işaretli hücre paylaşılan sorumluluk sınırının öte yanındadır. O sınırın nerede geçtiği bu dersin sorusu değildir; **girdisidir** ve kurum içi bir boşluk sayılmaz. - **AR13.** Bir yol, üzerindeki bir adım kesilerek kapanır. Bir adım ancak kaleminin **bul** ve **kapat** hücrelerinde kurum içi bir sahip varsa kesilebilir: kimsenin listesinde olmayan bir kalem gündeme gelmez, gündeme gelse de uygulayanı yoktur. - **AR14.** Savunma kesilebilir adımlar arasından en az meşru istek taşıyanı seçer. Hiçbir adımı kesilebilir olmayan yol açık kalır. - **AR15.** `kapat` hücresinde iki sahip varsa o kapatma iki ayrı onay adımı kazanır. - **AR16.** Rol sınırını yazmak, her sahipsiz hücreye bir sahip atamak ve her iki sahipli hücrede tek sahip bırakmaktır; `dis` hücreler değişmez. ```js // rol/kalem.mjs — ayni erisim grafi, bu kez SORUMLULUK KALEMI ile etiketli (MODEL). // Her adim bir kalem turune baglidir; her kalem turunun uc gorevi vardir. Sayilar kurgudur. export const KENAR = ` saha-terminali toplayici 420 saha-donanimi saha-terminali sube-anahtari 35 envanter-kaydi abone-portali dogrulayici 900 uygulama-denetimi abone-portali kimlik-dizini 760 kimlik-yetkisi tedarikci-ucu yonetim-agi 18 ucuncu-taraf-maddesi tedarikci-ucu yedek-ucu 6 ucuncu-taraf-maddesi sube-anahtari yonetim-agi 24 ag-kurali sube-anahtari toplayici 110 ag-kurali toplayici dogrulayici 380 uygulama-denetimi toplayici okuma-deposu 540 veri-siniflandirmasi dogrulayici okuma-deposu 610 veri-siniflandirmasi dogrulayici faturalama 290 uygulama-denetimi kimlik-dizini yonetim-agi 44 kimlik-yetkisi kimlik-dizini is-emri 150 kimlik-yetkisi yonetim-agi toplayici 60 ag-kurali yonetim-agi yedek-ucu 12 yedek-yolu yonetim-agi kimlik-dizini 38 kimlik-yetkisi yedek-ucu okuma-deposu 9 yedek-yolu is-emri dogrulayici 130 uygulama-denetimi is-emri faturalama 95 yama-dizeyi` .trim().split("\n").map((r) => { const [a, b, m, k] = r.trim().split(/\s+/); return { a, b, mesru: Number(m), kalem: k }; }); export const GIRIS = ["saha-terminali", "abone-portali", "tedarikci-ucu"]; export const VARLIK = ["okuma-deposu", "faturalama"]; export const GOREV = ["bul", "kapat", "surdur"]; export const ROL = ["operasyon", "sinama", "mimari", "yonetisim", "isletim"]; // Sorumluluk hucresi: kalem turu x gorev -> sahip rol listesi. "dis" = paylasilan sorumluluk // sinirinin ote yani; onceki kursta olculmus bir girdidir, kurum ici bir bosluk degildir. export const SAHIP = { "ag-kurali": { bul: ["isletim"], kapat: ["isletim", "mimari"], surdur: ["operasyon"] }, "kimlik-yetkisi": { bul: ["operasyon"], kapat: ["isletim"], surdur: ["operasyon", "yonetisim"] }, "uygulama-denetimi": { bul: ["sinama"], kapat: ["mimari"], surdur: [] }, "envanter-kaydi": { bul: [], kapat: ["isletim"], surdur: [] }, "veri-siniflandirmasi": { bul: ["yonetisim"], kapat: ["mimari", "yonetisim"], surdur: ["operasyon"] }, "yedek-yolu": { bul: [], kapat: ["isletim"], surdur: [] }, "yama-dizeyi": { bul: ["operasyon"], kapat: ["isletim"], surdur: ["operasyon"] }, "saha-donanimi": { bul: [], kapat: ["isletim"], surdur: [] }, "ucuncu-taraf-maddesi": { bul: ["yonetisim"], kapat: ["dis"], surdur: ["dis"] }, }; export function yollar() { const cikis = {}; for (const k of KENAR) (cikis[k.a] ??= []).push(k.b); const hepsi = []; const yuru = (d, iz) => { if (VARLIK.includes(d)) { hepsi.push([...iz]); return; } for (const s of cikis[d] ?? []) if (!iz.includes(s)) yuru(s, [...iz, s]); }; for (const g of GIRIS) yuru(g, [g]); return hepsi.map((iz) => ({ iz, kenar: iz.slice(0, -1).map((_, i) => KENAR.find((k) => k.a === iz[i] && k.b === iz[i + 1])) })); } ``` #### Sahipsiz Hücre ve Çakışan Hücre ```js // rol/olc.mjs — sorumluluk hucresi sayimi, rol basina yuk ve yol duzeyinde sonuc. import { KENAR, SAHIP, GOREV, ROL, yollar } from "./kalem.mjs"; const Y = yollar(), KALEM = Object.keys(SAHIP); const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const ic = (s) => s.filter((r) => r !== "dis"); const sinif = (s) => (s[0] === "dis" ? "dis" : s.length === 0 ? "BOS" : s.length > 1 ? "CAK" : "tek"); console.log(`sorumluluk matrisi MODELI: ${KALEM.length} kalem turu x ${GOREV.length} gorev ` + `= ${KALEM.length * GOREV.length} hucre; ${ROL.length} rol, ${KENAR.length} adim, ` + `${Y.length} yol.`); const T = [-22, 11, 18, 21]; console.log("\n1. hangi hucrenin sahibi var (dis = paylasilan sorumluluk sinirinin otesi)"); yaz(T, "kalem turu", ...GOREV); for (const k of KALEM) yaz(T, k, ...GOREV.map((g) => SAHIP[k][g].join("+") || "-")); const say = (c) => KALEM.reduce((a, k) => a + GOREV.filter((g) => sinif(SAHIP[k][g]) === c).length, 0); console.log(`hucre dagilimi: tek sahip ${say("tek")}, sahipsiz ${say("BOS")}, ` + `iki sahip ${say("CAK")}, dis ${say("dis")}.`); // Bir adim ancak kaleminin bul ve kapat hucrelerinde kurum ici sahip varsa kesilebilir. const kesilir = (e) => ic(SAHIP[e.kalem].bul).length > 0 && ic(SAHIP[e.kalem].kapat).length > 0; const R = [-20, 10, 10]; console.log("\n2. rol basina yuk"); yaz(R, "rol", "hucre", "yol"); for (const r of ROL) { const h = KALEM.reduce((a, k) => a + GOREV.filter((g) => SAHIP[k][g].includes(r)).length, 0); const y = Y.filter((p) => p.kenar.some((e) => kesilir(e) && GOREV.some((g) => SAHIP[e.kalem][g].includes(r)))).length; yaz(R, r, h, y); } // Rol sinirini yazmak: her sahipsiz hucreye bir sahip, her cakisan hucrede tek sahip. const YAZILI = Object.fromEntries(KALEM.map((k) => [k, Object.fromEntries(GOREV.map((g) => { const s = SAHIP[k][g]; return [g, s[0] === "dis" ? s : s.length === 0 ? ["isletim"] : [s[0]]]; }))])); const karar = KALEM.reduce((a, k) => a + GOREV.filter((g) => ["BOS", "CAK"].includes(sinif(SAHIP[k][g]))).length, 0); function kos(M) { const uygun = (e) => ic(M[e.kalem].bul).length > 0 && ic(M[e.kalem].kapat).length > 0; const kes = new Set(); let kapanan = 0, onay = 0, dogrulanmaz = 0; for (const y of Y) { const u = y.kenar.filter(uygun).sort((a, b) => a.mesru - b.mesru); if (u.length === 0) continue; kapanan++; kes.add(u[0]); if (ic(M[u[0].kalem].kapat).length > 1) onay++; if (ic(M[u[0].kalem].surdur).length === 0) dogrulanmaz++; } return { kapanan, kalan: Y.length - kapanan, adim: kes.size, dogrulanmaz, onay, mesru: [...kes].reduce((a, e) => a + e.mesru, 0) }; } const A = kos(SAHIP), B = kos(YAZILI); const D = [-30, 12, 12]; console.log(`\n3. yol duzeyinde sonuc (rol sinirini yazmak ${karar} hucre karari ister)`); yaz(D, "olcu", "mevcut", "yazili"); for (const [ad, f] of [["kapanan yol", (r) => r.kapanan], ["kalan yol", (r) => r.kalan], ["kesilen adim", (r) => r.adim], ["duran mesru istek (gun)", (r) => r.mesru], ["iki onay isteyen kapatma", (r) => r.onay], ["kapali kaldigi dogrulanmayan", (r) => r.dogrulanmaz]]) yaz(D, ad, f(A), f(B)); const kayan = Y.filter((y) => { const u = y.kenar.filter(kesilir).sort((a, b) => a.mesru - b.mesru); return u.length > 0 && u[0] !== [...y.kenar].sort((a, b) => a.mesru - b.mesru)[0]; }).length; const sahipsizKalem = KALEM.filter((k) => !ic(SAHIP[k].bul).length || !ic(SAHIP[k].kapat).length); console.log(`\nen ucuz adimi kesilemedigi icin daha pahali adimdan kapanan yol: ${kayan};`); console.log(`kesilemeyen kalem turleri: ${sahipsizKalem.join(", ")}.`); const acik = Y.filter((y) => y.kenar.every((e) => !kesilir(e))); for (const y of acik) console.log(`acik kalan yol: ${y.iz.join(" > ")}`); ``` ``` sorumluluk matrisi MODELI: 9 kalem turu x 3 gorev = 27 hucre; 5 rol, 20 adim, 30 yol. 1. hangi hucrenin sahibi var (dis = paylasilan sorumluluk sinirinin otesi) kalem turu bul kapat surdur ag-kurali isletim isletim+mimari operasyon kimlik-yetkisi operasyon isletim operasyon+yonetisim uygulama-denetimi sinama mimari - envanter-kaydi - isletim - veri-siniflandirmasi yonetisim mimari+yonetisim operasyon yedek-yolu - isletim - yama-dizeyi operasyon isletim operasyon saha-donanimi - isletim - ucuncu-taraf-maddesi yonetisim dis dis hucre dagilimi: tek sahip 15, sahipsiz 7, iki sahip 3, dis 2. 2. rol basina yuk rol hucre yol operasyon 6 26 sinama 1 18 mimari 3 25 yonetisim 4 22 isletim 7 23 3. yol duzeyinde sonuc (rol sinirini yazmak 10 hucre karari ister) olcu mevcut yazili kapanan yol 28 30 kalan yol 2 0 kesilen adim 11 12 duran mesru istek (gun) 2321 2135 iki onay isteyen kapatma 15 0 kapali kaldigi dogrulanmayan 5 0 en ucuz adimi kesilemedigi icin daha pahali adimdan kapanan yol: 12; kesilemeyen kalem turleri: envanter-kaydi, yedek-yolu, saha-donanimi, ucuncu-taraf-maddesi. acik kalan yol: tedarikci-ucu > yonetim-agi > yedek-ucu > okuma-deposu acik kalan yol: tedarikci-ucu > yedek-ucu > okuma-deposu ``` Birinci tablo 27 hücreyi dört sınıfa ayırır: **15 tek sahipli, 7 sahipsiz, 3 iki sahipli, 2 dış.** Kurum içi 25 hücrenin yalnız 15'inin tek bir sahibi vardır; **onda birinden fazlası değil, tam %40'ı tanımsız ya da çift tanımlıdır.** Sahipsiz yedi hücre dört kalem türüne dağılır ve hepsi aynı yönde eksiktir: `envanter-kaydi`, `yedek-yolu` ve `saha-donanimi` kalemlerinin **bul** ve **sürdür** hücreleri boştur, **kapat** hücreleri doludur. Bu, kurumun bu üç kalemi değiştirmeyi bildiği ama **izlemeyi** kimseye vermediği anlamına gelir: envanter kaydını kim tutar, yedek yolunun var olduğunu kim bilir, saha donanımını kim listeler sorularının yazılı yanıtı yoktur. Bir kalemi değiştirebilmek onu yönetmek değildir; değişecek kalemin listede olması gerekir. `uygulama-denetimi` kaleminde de sürdür hücresi boştur: denetim kurulur ama kaldırıldığında bunu fark edecek bir rol yazılı değildir. Üç iki sahipli hücre başka bir eksikliktir. `ag-kurali` kapatma hücresi işletim ile mimaride, `veri-siniflandirmasi` kapatma hücresi mimari ile yönetişimde, `kimlik-yetkisi` sürdürme hücresi operasyon ile yönetişimdedir. Bu hücreler **boş değildir**, fakat her değişiklik iki ayrı onaydan geçer. İkinci tablo rol başına yükü verir ve iki sütunu birbirini tutmaz. `isletim` 7 hücreyle en yüklü roldür ama güvenlik ekibinin parçası değildir: adımı gerçekten kesen eldir. `sinama` yalnız **1** hücrenin sahibidir; buna karşılık 18 yolun kapanması onun bulduğu kaleme bağlıdır. Hücre sayısı bir rolün ne kadar iş yaptığını ölçmez, **kaç yolun ondan geçtiğini** ölçmez de: iki sütun ayrı sorulara yanıt verir. Aynı yolun birden çok rolde sayılması da bundandır — bir yolun kapanması genellikle üç görevin üçünde de bir sahip ister. #### Sahipsizliğin Yol Düzeyindeki Bedeli Üçüncü tablo hücre sayımını yol kümesine indirir. Mevcut dağılımda **28 yol kapanır, 2 yol açık kalır**. Açık kalan iki yol çıktının son satırlarındadır ve ikisi de üçüncü taraf ucundan yedek ucu üzerinden okuma deposuna gider. Üzerlerindeki her adım ya sınırın öte yanındadır ya da hiçbir rolün listesindedir — bir yolun açık kalması için üzerindeki adımların hepsinin sahipsiz olması gerekir ve burada tam olarak bu olmuştur. Asıl bedel açık kalan yollarda değil, **kapanan yolların nasıl kapandığındadır.** Çıktının sondan üçüncü satırı bunu yazar: **12 yol en ucuz adımından kapatılamaz**, çünkü o adımın kalemi hiçbir rolün listesinde değildir. Savunma bir sonraki kesilebilir adıma kayar ve o adım daha çok meşru iş taşır. Duran meşru istek mevcut dağılımda günde **2.321**, rol sınırı yazıldığında **2.135'tir**. Aradaki **186 istek** hiçbir güvenlik kazancı karşılığı değildir; yalnız kesilecek adımın seçilememesinin bedelidir. `iki onay isteyen kapatma` satırı çakışmanın bedelini verir: **15 kapatma** iki ayrı onay adımı kazanır. Otuz yolun yarısı, iki rolün de sahiplendiği bir kalem üzerinden kapandığı için iki kez karar gerektirir. Çakışma bir yolu açık bırakmaz; **kapanmayı yavaşlatır ve her değişikliği iki kata çıkarır.** `kapali kaldigi dogrulanmayan` satırı üçüncü kalemi verir: **5 yol** kapanır ama kapalı kaldığını doğrulayan bir rol yoktur. Bu yollar tabloda kapalı sayılır. Bir sonraki yapılandırma değişikliğinde yeniden açılırlarsa bunu fark edecek yazılı bir sahip yoktur — sürdürme hücresinin boş olması, kapatmanın **ölçüsüz** olması demektir. #### Sınırı Yazmanın Bedeli `yazili` sütunu on hücre kararının sonucudur: yedi sahipsiz hücreye birer sahip atanır, üç çakışan hücrede tek sahip bırakılır. Kapanan yol 28'den **30'a** çıkar, açık kalan yol sıfırlanır, duran meşru istek 2.321'den **2.135'e** iner, iki onay isteyen kapatma 15'ten **0'a**, doğrulanmayan yol 5'ten **0'a** düşer. Bu on karar teknik bir çalışma değildir. Yeni bir denetim kurulmaz, yeni bir adım kesilmez, grafta hiçbir şey değişmez; yalnız on hücreye birer ad yazılır. Karşılığında iki yol daha kapanır ve günde 186 meşru istek daha az durur. Ölçüm bir uyarı da taşır. Sahipsiz hücrelerin tamamı **bul** ve **sürdür** sütunlarındadır, hiçbiri **kapat** sütununda değildir. Kurumlar yapacak eli tanımlamayı kolay bulur; listeyi tutan ve sonucun kalıcı olduğunu doğrulayan eli tanımlamayı atlar. Bir sorumluluk matrisinin en çok atlanan hücresi işin yapıldığı hücre değil, **işin gerekliliğini fark eden ve sonucunu sınayan** hücredir. #### Özet - 27 hücrelik sorumluluk matrisinde 15 hücrenin tek sahibi vardır; 7 hücre sahipsiz, 3 hücre iki sahipli, 2 hücre paylaşılan sorumluluk sınırının öte yanındadır. Kurum içi 25 hücrenin %40'ı tanımsız ya da çift tanımlıdır. - Sahipsiz yedi hücrenin tamamı **bul** ve **sürdür** sütunlarındadır. Kalemi değiştirecek el yazılıdır; kalemi listede tutacak ve kapalı kaldığını sınayacak el yazılı değildir. - Rol başına hücre sayısı ile yol sayısı birbirini tutmaz: sınama tek hücrenin sahibidir ama 18 yolun kapanması onun bulduğu kaleme bağlıdır. - Mevcut dağılımda 28 yol kapanır, 2 yol açık kalır; kapanan yolların 12'si en ucuz adımından kapatılamadığı için daha pahalı bir adımdan kapanır ve günde 186 fazla meşru istek durur. - 15 kapatma iki onay adımı kazanır, 5 yol kapalı kaldığı doğrulanmadan kapalı sayılır. Sınırı yazmak on hücre kararıdır ve bu üç sayıyı sırasıyla 30, 0 ve 0 yapar. #### Sonraki Adım Rol sınırını yazmak on hücreyi kapattı ve iki yolu daha kapanır hâle getirdi. Yine de matrisin iki hücresi baştan sona `dis` kaldı ve bu ders onlara hiç dokunmadı: üçüncü taraf maddesinin kapatma ve sürdürme hücreleri kurum içinde bir sahip almaz. O iki hücrenin nedeni teknik değildir. Bir adımı kesmek, bir yolu sınamak, bir kalemi listeye almak — hepsi birinin o sistem üzerinde işlem yapma yetkisine bağlıdır ve o yetki bir tabloyla değil bir yazıyla verilir. Bir sonraki ders bu yetkiyi sayılabilir kalem olarak kurar: yazılı kapsamda kaç varlık var, kapsamın dışında kaç varlık aynı ağda duruyor ve kapsam belirsizliği kaç kalemi tartışmaya açık bırakıyor. ### Yasal Çerçeve ve Etik Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/yasal-cerceve-ve-etik Yetkilendirme, kapsam ve sorumluluğun sayılabilir kalem olarak kurulması: 18 varlıklı envanterde dört kapsam yazımının 8, 13, 17 ve 15 varlık kapsaması, tartışmaya açık kalemin 0, 6, 9 ve 0 olması, ad listesiyle yazılan kapsamda 9 komşu varlığın aynı bölütte durması, iki varlığın ayrı yazılı izin istemesi ve tartışmasız sınanabilen yolun 8, 5, 8 ve 22 olması. Önceki ders sorumluluğu 27 hücrelik bir matriste ölçtü ve iki hücreyi kurum içinde sahipsiz bıraktı: üçüncü taraf maddesinin kapatma ve sürdürme hücreleri. O iki hücrenin nedeni teknik değildir. Bir adımı kesmek, bir yolu sınamak ya da bir varlığı listeye almak, birinin o sistem üzerinde işlem yapma yetkisine bağlıdır ve o yetki bir tabloyla değil **yazıyla** verilir. Yazılı yetki ve tanımlı kapsam olmadan bir sistem üzerinde sınama yapmak hem yasadışıdır hem meslek dışıdır; bir yolun teknik olarak yürünebilir olması onu yürünmesi meşru bir yol yapmaz. Bu ders, o yazının kendisini ölçülebilir bir nesne olarak ele alır. **Katılım kuralları** bir sınamanın neyi, ne zaman ve hangi sınıra kadar kapsadığını yazan metindir; **kapsam** o metnin varlık kümesidir. Sorulan şey metnin tonu değil, kaç kalemi tek anlamla belirlediğidir. #### Kapsamı Kalem Olarak Yazmak - **AR17.** Envanter 18 varlıktır: yol kümesinin 12 düğümü ve aynı ağ bölütlerinde duran 6 komşu varlık. Her varlığın sahibi (kurum, ortak, tedarikçi) ve ağ bölütü yazılıdır. Envanter de ağ da kurgudur. - **AR18.** Kapsam dört biçimde yazılır: **ad listesi** (her varlık adıyla), **bölüt aralığı** (yazılı bölütlerdeki her varlık), **dışlama** (belirli bir bölüt hariç her şey), **düzeltilmiş yazım**. - **AR19.** Bir varlık **tartışmasız** kapsamdadır ancak metin onu hem biçimiyle kapsıyor **hem de adıyla** yazıyorsa. Yalnız biçimin kapsadığı varlık **tartışmalıdır**: metnin dar okuması onu dışarıda, geniş okuması içeride bırakır. - **AR20.** Bir yol tartışmasız sınanabilir ancak bütün düğümleri tartışmasız kapsamdaysa. - **AR21.** Sahibi kurum olmayan varlık, kapsam metnine girse de **ayrı yazılı izin** ister; kurumun kendi yazdığı metin başka bir kurumun varlığı üzerinde yetki üretmez. - **AR22.** Ad listesiyle yazılan kapsamda bölüt düzeyinde tek bir işlem kapsam dışı komşuya değeceği için her varlık ayrı pencerede sınanır; aralıkla yazılan kapsamda bölüt başına tek pencere yeter. - **AR23.** Sınama penceresinde, sınanan varlıkların taşıdığı meşru istek durur. - **AR24.** Düzeltilmiş yazım kapsadığı her varlığı adıyla yazar ve kurum dışı sahipli varlıkları açıkça dışlar. ```js // kapsam/yetki.mjs — yazili kapsamin dort bicimi ve varlik envanteri (MODEL). // Gercek bir kurum, gercek bir sozlesme ya da gercek bir varlik yoktur; sayilar kurgudur. export const VARLIK = ` saha-terminali kurum saha evet abone-portali kurum abone evet toplayici kurum cekirdek evet dogrulayici kurum cekirdek evet is-emri kurum cekirdek evet okuma-deposu kurum cekirdek evet faturalama kurum cekirdek evet kimlik-dizini kurum yonetim evet sube-anahtari kurum saha hayir saha-ekip-tableti kurum saha hayir sube-yazici kurum saha hayir abone-kayit-kopyasi kurum abone hayir ortak-analiz-ucu ortak cekirdek hayir tedarikci-portali tedarikci abone hayir yonetim-agi kurum yonetim hayir yedek-ucu kurum yonetim hayir test-kopyasi kurum yonetim hayir tedarikci-ucu tedarikci dis hayir` .trim().split("\n").map((r) => { const [ad, sahip, bolut, liste] = r.trim().split(/\s+/); return { ad, sahip, bolut, adli: liste === "evet" }; }); export const KENAR = ` saha-terminali toplayici 420 saha-terminali sube-anahtari 35 abone-portali dogrulayici 900 abone-portali kimlik-dizini 760 tedarikci-ucu yonetim-agi 18 tedarikci-ucu yedek-ucu 6 sube-anahtari yonetim-agi 24 sube-anahtari toplayici 110 toplayici dogrulayici 380 toplayici okuma-deposu 540 dogrulayici okuma-deposu 610 dogrulayici faturalama 290 kimlik-dizini yonetim-agi 44 kimlik-dizini is-emri 150 yonetim-agi toplayici 60 yonetim-agi yedek-ucu 12 yonetim-agi kimlik-dizini 38 yedek-ucu okuma-deposu 9 is-emri dogrulayici 130 is-emri faturalama 95` .trim().split("\n").map((r) => { const [a, b, m] = r.trim().split(/\s+/); return { a, b, mesru: Number(m) }; }); export const GIRIS = ["saha-terminali", "abone-portali", "tedarikci-ucu"]; export const HEDEF = ["okuma-deposu", "faturalama"]; export const BICIM = { "ad-listesi": (v) => v.adli, "bolut": (v) => ["saha", "abone", "cekirdek"].includes(v.bolut), "dislama": (v) => v.bolut !== "dis", "duzeltilmis": (v) => v.sahip === "kurum" && v.bolut !== "dis", }; // Aralikla yazilan bicimlerde bolut basina tek sinama penceresi yeter. export const ARALIK = ["bolut", "dislama", "duzeltilmis"]; // Bu iki bicim kapsadigi her varligi ADIYLA da yazar; oteki ikisi eski ad listesine dayanir. export const ADLANDIRAN = ["ad-listesi", "duzeltilmis"]; export function yollar() { const cikis = {}; for (const k of KENAR) (cikis[k.a] ??= []).push(k.b); const hepsi = []; const yuru = (d, iz) => { if (HEDEF.includes(d)) { hepsi.push([...iz]); return; } for (const s of cikis[d] ?? []) if (!iz.includes(s)) yuru(s, [...iz, s]); }; for (const g of GIRIS) yuru(g, [g]); return hepsi.map((iz) => ({ iz })); } ``` #### Dört Yazım, Aynı Envanter ```js // kapsam/olc.mjs — dort kapsam yazimi ayni envanter ve ayni yol kumesi uzerinde. import { VARLIK, KENAR, BICIM, ARALIK, ADLANDIRAN, yollar } from "./yetki.mjs"; const Y = yollar(), AD = Object.keys(BICIM); const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); function olc(b) { const genis = VARLIK.filter(BICIM[b]); const adli = (v) => v.adli || ADLANDIRAN.includes(b); // metin varligi adiyla yaziyor mu const tartismasiz = genis.filter(adli); // hem adiyla yazili hem bicim icinde const tartismali = genis.filter((v) => !adli(v)); // yalniz genis okumada iceride const celisen = VARLIK.filter((v) => v.adli && !BICIM[b](v)); const izin = genis.filter((v) => v.sahip !== "kurum"); // ayri yazili izin ister const bolut = new Set(genis.map((v) => v.bolut)); const komsu = VARLIK.filter((v) => !BICIM[b](v) && bolut.has(v.bolut)); const d = new Set(tartismasiz.map((v) => v.ad)), g = new Set(genis.map((v) => v.ad)); return { genis: genis.length, tartismasiz: tartismasiz.length, tartismali: tartismali.length, celisen: celisen.length, izin: izin.length, komsu: komsu.length, pencere: ARALIK.includes(b) ? bolut.size : genis.length, sinanabilir: Y.filter((y) => y.iz.every((x) => d.has(x))).length, tartisilan: Y.filter((y) => y.iz.every((x) => g.has(x)) && !y.iz.every((x) => d.has(x))).length, disarida: Y.filter((y) => !y.iz.every((x) => g.has(x))).length, mesru: KENAR.filter((k) => d.has(k.a)).reduce((a, k) => a + k.mesru, 0) }; } const R = Object.fromEntries(AD.map((b) => [b, olc(b)])); console.log(`envanter MODELI: ${VARLIK.length} varlik, ${KENAR.length} adim, ${Y.length} yol; ` + `dort kapsam yazimi ayni kume uzerinde okunuyor.`); const T = [-32, 13, 9, 10, 14]; console.log("\n1. yazili kapsam kac kalemi kapsiyor, kaci tartismaya acik"); yaz(T, "olcu", ...AD); for (const [ad, f] of [["kapsamda sayilan varlik", (r) => r.genis], [" iki okumada da iceride", (r) => r.tartismasiz], [" yalniz genis okumada iceride", (r) => r.tartismali], ["ad listesiyle celisen varlik", (r) => r.celisen], ["ayri yazili izin isteyen varlik", (r) => r.izin], ["kapsam disi, ayni bolutte", (r) => r.komsu]]) yaz(T, ad, ...AD.map((b) => f(R[b]))); console.log("\n2. yol kumesinde karsiligi ve mesru ise bedel"); yaz(T, "olcu", ...AD); for (const [ad, f] of [["tartismasiz sinanabilen yol", (r) => r.sinanabilir], ["tartismali yol", (r) => r.tartisilan], ["kapsam disi kalan yol", (r) => r.disarida], ["ayri sinama penceresi", (r) => r.pencere], ["duran mesru istek (gun)", (r) => r.mesru]]) yaz(T, ad, ...AD.map((b) => f(R[b]))); const t = R["bolut"], s = R["duzeltilmis"]; console.log(`\nbolut yaziminda ${t.tartismali} varlik ve ${t.tartisilan} yol tartismaya acik; ` + `ayrica ${t.celisen} varlik ad listesinde olup aralik disinda kaliyor.`); console.log(`duzeltilmis yazim ${s.tartismali} tartismali kalem birakiyor ve ${s.sinanabilir} ` + `yolu sinanabilir yapiyor; kalan ${s.disarida} yol kurum disi sahipli bir varliktan geciyor.`); ``` ``` envanter MODELI: 18 varlik, 20 adim, 30 yol; dort kapsam yazimi ayni kume uzerinde okunuyor. 1. yazili kapsam kac kalemi kapsiyor, kaci tartismaya acik olcu ad-listesi bolut dislama duzeltilmis kapsamda sayilan varlik 8 13 17 15 iki okumada da iceride 8 7 8 15 yalniz genis okumada iceride 0 6 9 0 ad listesiyle celisen varlik 0 1 0 0 ayri yazili izin isteyen varlik 0 2 2 0 kapsam disi, ayni bolutte 9 0 0 2 2. yol kumesinde karsiligi ve mesru ise bedel olcu ad-listesi bolut dislama duzeltilmis tartismasiz sinanabilen yol 8 5 8 22 tartismali yol 0 3 14 0 kapsam disi kalan yol 22 22 8 8 ayri sinama penceresi 8 3 4 4 duran mesru istek (gun) 4354 4160 4354 4607 bolut yaziminda 6 varlik ve 3 yol tartismaya acik; ayrica 1 varlik ad listesinde olup aralik disinda kaliyor. duzeltilmis yazim 0 tartismali kalem birakiyor ve 22 yolu sinanabilir yapiyor; kalan 8 yol kurum disi sahipli bir varliktan geciyor. ``` Birinci tablo dört metni aynı 18 varlıklı envanterin üstünde okur. Kapsanan varlık sayısı 8, 13, 17 ve 15'tir. Bu satır tek başına okunduğunda dışlama yazımı en geniş, ad listesi en dar görünür ve kapsam metninin gücü bu ilk satırla ölçülüyormuş gibi durur. İkinci satır bu izlenimi bozar. **Tartışmasız kapsamda olan varlık 8, 7, 8 ve 15'tir.** Dışlama yazımı ad listesinden dokuz varlık fazla kapsar, ama o dokuz varlığın **hiçbiri** iki okumada da içeride değildir; metni dar okuyan biri onları dışarıda sayar. Kapsamı genişleten cümle, tartışmasız kalemi bir tane bile artırmamıştır. Bölüt yazımı daha keskin bir sonuç verir. Kapsanan varlık 8'den 13'e çıkar, ama tartışmasız kalem 8'den **7'ye iner**. Nedeni dördüncü satırdadır: **bir varlık ad listesinde yazılıdır ama yazılı bölüt aralığının dışında kalır.** İki cümle aynı metinde birbirini keser ve o varlığın kapsamda olup olmadığı metinden çıkmaz. Kapsamı genişletmek için yazılan bir aralık, tartışmasız kalemi azaltmıştır. #### Yetkinin Kapsamla Aynı Şey Olmadığı Yer Beşinci satır ayrı bir sınır çizer: bölüt ve dışlama yazımlarında kapsanan varlıkların **ikisi** kurum dışı sahiplidir — biri ortak kurumun analiz ucu, biri tedarikçi portalıdır. Kurumun kendi yazdığı bir metin bu iki varlığı kapsam içinde sayabilir; o metin başka bir kurumun varlığı üzerinde **yetki üretmez**. İkisi için de ayrı bir yazılı izin gerekir ve o izin gelene kadar bu kalemler kapsamda değil, **tartışmada**dır. Altıncı satır ters yöndeki sınırı verir. Ad listesiyle yazılan kapsamda **9 varlık** kapsam dışındadır ama kapsamdaki varlıklarla **aynı ağ bölütünde** durur. Bir bölüt düzeyinde yürütülen tek bir işlem bu dokuzuna da değer; kapsam dışı bir varlığa değmek yazılı yetkinin dışına çıkmak demektir. Ad listesi belirsizliği sıfırlar ama bu kesinliğin bedeli koordinasyondur: sınama tek pencerede değil, varlık başına ayrı pencerede yürütülür. Bu iki satır aynı metnin üç ayrı soruya yanıt verdiğini gösterir. **Kapsam** hangi varlığın sınanacağını yazar; **yetki** o sınamayı kimin imzasıyla verildiğini yazar; **sorumluluk** bir zarar doğduğunda kimin yanıt vereceğini yazar. Üçü ayrı kalemlerdir ve bir metinde biri yazılıp öteki ikisi atlanabilir. Kurum dışı sahipli iki varlıkta kapsam yazılıdır, yetki eksiktir. Ad listesindeki dokuz komşuda kapsam açıktır — dışarıdadırlar — ama bir bölüt işlemi onlara değdiğinde sorumluluğun kimde olduğu yazılı değildir. Bir metnin ölçüsü kaç varlığı saydığı değil, **her varlık için bu üç sorunun üçüne de yanıt verip vermediğidir.** Etik yükümlülük bu üç kalemin dışında ve onlardan geniştir. Kapsam dışı bir yol sınama sırasında kendini gösterebilir; onu sınamamak yasal bir zorunluluk, **bildirmek** meslek gereğidir. Aynı biçimde pencerenin dışına taşmamak, kapsam metninin izin verdiğinden fazlasını denememek ve bulunanı yalnız imza sahibine iletmek yazılı metinde geçmese de sınamayı yürüten tarafın yükümlülüğüdür. Yazılı yetki bir tavan çizer; meslek ölçüsü o tavanın altında kalmayı da kapsar. #### Kapsamın Yol Kümesindeki Karşılığı İkinci tablo aynı dört metni yol kümesine indirir ve kapsamın asıl ölçüsünü verir. Tartışmasız sınanabilen yol 8, 5, 8 ve **22'dir**. Ad listesi ile dışlama yazımı aynı sayıyı verir: dışlamanın kapsadığı dokuz fazla varlık, tartışmalı oldukları için hiçbir yolu tartışmasız hâle getirmez. Bölüt yazımı **5'e düşer** — çelişen tek varlık, üzerinden geçen üç yolu tartışmalı kılmıştır. Tartışmalı yol satırı 0, 3, 14 ve 0'dır. Dışlama yazımında otuz yolun **neredeyse yarısı** için sınamanın meşru olup olmadığı metinden çıkmaz. Bu on dört yolun her biri bir sorumluluk sorusudur: sınanır ve bir kesinti doğarsa yazılı metin kimi işaret eder. Sorunun yanıtsız kalması, hem sınamayı yürüten tarafı hem sınamayı isteyen tarafı savunmasız bırakır. **Tartışmaya açık kalem, sınanmazsa ölçülmemiş bir yol, sınanırsa yazısız bir işlemdir.** Kapsam dışı kalan yol 22, 22, 8 ve 8'dir. Düzeltilmiş yazımda kalan sekiz yolun tamamı kurum dışı sahipli bir varlıktan geçer. Bu sekiz yol, birinci derste mor çalışmadan sonra geriye kalan sekiz yolun **aynısıdır**: orada yetkilendirmenin sınırı yüzünden görülmemişlerdi, burada aynı sınır yüzünden sınanamıyorlar. Bir kurumun kendi ağında ölçemeyeceği yol kümesinin boyu, kendi metniyle değil **başka bir kurumun imzasıyla** belirlenir. #### Doğru Yazımın Bedeli Düzeltilmiş yazım her kalemi adıyla yazar ve kurum dışı sahipli varlıkları açıkça dışlar: 15 varlık, 0 tartışmalı kalem, 0 ayrı izin, 22 sınanabilir yol. Son iki satır bu sonucun bedelini verir. Sınama 4 ayrı pencerede yürütülür ve pencerelerde duran meşru istek günde **4.607'dir** — dört yazımın **en yükseği**. Bu ters yön kasıtlıdır. Ad listesi 4.354, bölüt yazımı 4.160 meşru istek durdurur; ikisi de daha az varlığı tartışmasız kapsadığı için daha az işi durdurur. Kapsamı doğru yazmak sınamayı ucuzlatmaz; **pahalılaştırır.** Karşılığında alınan şey sınanan yol sayısının 8'den 22'ye çıkması ve tartışmaya açık kalemin sıfırlanmasıdır. Sınamanın hiç durdurmadığı bir iş varsa, muhtemelen sınamanın hiç dokunmadığı bir varlık da vardır. #### Özet - 18 varlıklı envanterde dört kapsam yazımı 8, 13, 17 ve 15 varlık kapsar; tartışmasız kapsamda olan varlık 8, 7, 8 ve 15'tir. Kapsamı genişleten iki cümle — bölüt aralığı ve dışlama — tartışmasız kalemi artırmaz; artıran tek yazım her varlığı adıyla yazandır. - Bölüt yazımında bir varlık ad listesinde yazılı olduğu hâlde aralığın dışında kalır; bu tek çelişki tartışmasız sınanabilen yolu 8'den 5'e indirir. - Kurum dışı sahipli iki varlık kapsam metnine girer ama metin onlar üzerinde yetki üretmez; her biri ayrı yazılı izin ister. Ad listesiyle yazılan kapsamda ise 9 kapsam dışı varlık kapsamdaki varlıklarla aynı bölütte durur ve sınama 8 ayrı pencereye bölünür. - Tartışmalı yol sayısı 0, 3, 14 ve 0'dır. Tartışmaya açık bir kalem sınanmazsa ölçülmemiş bir yol, sınanırsa yazısız bir işlemdir. - Düzeltilmiş yazım 22 yolu sınanabilir yapar ve tartışmalı kalemi sıfırlar; kalan 8 yol kurum dışı sahipli bir varlıktan geçer ve ancak başka bir kurumun yazılı izniyle ölçülebilir. - Doğru yazımın bedeli en yüksektir: günde 4.607 meşru istek durur, 4.160 ve 4.354 yerine. Hiçbir meşru işi durdurmayan sınama, dokunmadığı varlıkları da ölçmemiştir. #### Sonraki Adım Yetki bir metindir ve o metin ölçüldü: kaç kalemi tek anlamla belirlediği, kaç kalemi tartışmaya açtığı, kaç yolu sınanabilir yaptığı ve karşılığında kaç meşru işi durdurduğu sayıldı. Metin yazıldığında sınama yürütülebilir hâle gelir. Geriye tek bir soru kalır: metnin yetkilendirdiği işi **yapabilen** kişi nasıl ayırt edilir. Bir kurum bir yolu sınatmak istediğinde karşısına iki ayrı ölçüm çıkar — bir sınav salonunda ölçülen bilgi ile bir laboratuvarda ölçülen beceri. Son ders bu ikisinin ölçtüğü yetenek kümesini aynı kalem listesi üzerinde karşılaştırır: kaç kalemde kesişiyorlar, kaçında ayrışıyorlar ve hangi kalem ikisinde de ölçülmüyor. ### Mesleki Yetkinlik Yolları Source: https://academia.sh/tr/kurslar/siber-guvenlige-giris/mesleki-yetkinlik-yollari Yetkinlik yollarının ölçtüğü şey cinsinden ayrılması: 15 kalemlik yetkinlik kümesinde çoktan seçmeli belgelendirmenin 2, uygulamalı sınavın 9 ve laboratuvar ortamının 6 kalemi ölçmesi, iki sınav biçiminin 2 kalemde kesişip 7 kalemde ayrışması, üç yolun birlikte 10 kalemi ölçmesi ve hiçbirinin ölçmediği 5 kalemin toplam yol yükünün %39,2'sini taşıması. Önceki ders yetkiyi bir metin olarak ölçtü: kaç kalemi tek anlamla belirlediğini, kaç kalemi tartışmaya açtığını ve kaç yolu sınanabilir yaptığını saydı. Metin yazıldığında iş yürütülebilir hâle gelir; geriye o işi **yapabilen** kişinin nasıl ayırt edileceği kalır. Bir kurum bu soruyu üç ayrı ölçüme havale eder. **Çoktan seçmeli belgelendirme** bir sınav salonunda yanıt tanımayı ölçer. **Uygulamalı sınav** belirli bir süre içinde bir bitiş durumuna ulaşmayı ölçer. **Laboratuvar ortamı** kişinin kendi kurduğu, gerçek sonucu olmayan bir düzende tekrar tekrar çalışmasını sağlar. Üçü de bir şey ölçer, ama aynı şeyi ölçmez. Bu ders üçünü tek bir soruda ayırır: **kursun gerektirdiği yetkinlik kalemlerinden kaçını ölçüyorlar.** #### Yetkinliği Kalem Olarak Yazmak - **AR25.** Yetkinlik kümesi 15 kalemdir ve kursun on beş dersinin gerçekten gerektirdiği işlerden çıkarılmıştır: yol saymak, katman eklemek, yetki daraltmak, kesilecek adımı seçmek, kapsam yazmak gibi. - **AR26.** Her kalemin üç niteliği vardır. **Biçim:** kalem bilgiyle mi (`b`) uygulamayla mı (`u`) gösterilir. **Tek anlam:** sınanabilir tek bir doğru bitiş durumu var mı. **Sonuç:** yanlış yapıldığında gerçek bir bedeli var mı — meşru iş durur, başka bir ekip etkilenir. - **AR27.** Çoktan seçmeli belgelendirme yalnız biçimi bilgi olan ve tek anlamlı kalemi ölçer. Uygulamalı sınav tek anlamlı her kalemi ölçer; bitiş durumu tanımsızsa notlandıramaz. Laboratuvar ortamı sonucu olmayan her kalemi kapsar; gerçek bedeli olan kalem laboratuvarda **oluşmaz**. - **AR28.** Her kalemin **yol yükü**, bu kursun 30 yollu modelinde o kalem olmadan kapatılamayan yol sayısıdır. Yükler toplanabilir ama aynı yol birden çok kalemde sayılır; toplam bir **yük**tür, ayrık yol sayısı değildir. - **AR29.** Model kurgudur; gerçek bir sınav, belgelendirme, kurum ya da laboratuvar ürünü yoktur. ```js // yetkinlik/olc.mjs — kursun gerektirdigi 15 yetkinlik kalemi ve uc olcme yolunun kapsami (MODEL). // Gercek bir sinav, belgelendirme, kurum ya da laboratuvar urunu yoktur; sayilar kurgudur. // bicim: b = bilgiyle gosterilir, u = uygulamayla gosterilir // tek: sinanabilir tek bir dogru bitis durumu var mi | sonuc: yanlisin gercek bir bedeli var mi // yol: bu kursun 30 yollu modelinde, bu kalem olmadan kapatilamayan yol sayisi const KALEM = ` terim-ayrimi b evet hayir 30 risk-siralamasi b evet hayir 12 yol-sayimi u evet hayir 30 katman-ekleme u evet evet 22 yetki-daraltma u evet evet 17 bolme-tasarimi u evet evet 14 varsayilan-denetimi u evet hayir 8 gunluk-cozumleme u evet hayir 6 olay-yurutme u evet evet 5 ortam-hazirlama u hayir hayir 0 kesilecek-adim-secimi u hayir evet 22 mesru-is-bedeli u hayir evet 22 envanter-tutma u hayir evet 19 kapsam-yazimi b hayir evet 22 sinir-tanima b hayir evet 8` .trim().split("\n").map((r) => { const [ad, bicim, tek, sonuc, yol] = r.trim().split(/\s+/); return { ad, bicim, tek: tek === "evet", sonuc: sonuc === "evet", yol: Number(yol) }; }); // Uc olcme yolu, kalem nitelikleri uzerinde tanimli yuklemlerdir. const YOL = { "coktan-secmeli": (k) => k.bicim === "b" && k.tek, // taninabilir tek dogru yanit "uygulamali-sinav": (k) => k.tek, // sinanabilir bitis durumu "laboratuvar": (k) => !k.sonuc, // gercek bedeli olan kalem burada olusmaz }; const AD = Object.keys(YOL); const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const yuk = (s) => s.reduce((a, k) => a + k.yol, 0); const TOP = yuk(KALEM), pay = (x) => `${((x / TOP) * 100).toFixed(1)}%`; console.log(`yetkinlik MODELI: ${KALEM.length} kalem, toplam yol yuku ${TOP} ` + `(ayni yol birden cok kalemde sayilir; bu bir yuk toplamidir, ayrik yol sayisi degildir).`); const T = [-26, 18, 20, 16]; console.log("\n1. her olcme yolu kac kalemi olcuyor"); yaz(T, "olcu", ...AD); for (const [ad, f] of [["olctugu kalem", (b) => `${KALEM.filter(YOL[b]).length}/${KALEM.length}`], ["olctugu yol yuku", (b) => yuk(KALEM.filter(YOL[b]))], ["yol yukunun payi", (b) => pay(yuk(KALEM.filter(YOL[b])))]]) yaz(T, ad, ...AD.map(f)); const ikisi = KALEM.filter((k) => YOL["coktan-secmeli"](k) && YOL["uygulamali-sinav"](k)); const ayrik = KALEM.filter((k) => YOL["coktan-secmeli"](k) !== YOL["uygulamali-sinav"](k)); const hicbiri = KALEM.filter((k) => !AD.some((b) => YOL[b](k))); const hepsi = KALEM.filter((k) => AD.some((b) => YOL[b](k))); const K = [-38, 10, 12]; console.log("\n2. iki sinav bicimi nerede kesisiyor, nerede ayrisiyor"); yaz(K, "kume", "kalem", "yol yuku"); for (const [ad, s] of [["ikisinde de olculen", ikisi], ["yalniz birinde olculen", ayrik], ["ikisinde de olculmeyen", KALEM.filter((k) => !k.tek)], ["laboratuvarin kapsamadigi", KALEM.filter((k) => k.sonuc)], ["uc yolun birlikte olctugu", hepsi], ["hicbirinde olculmeyen", hicbiri]]) yaz(K, ad, s.length, `${yuk(s)} (${pay(yuk(s))})`); console.log("\n3. hicbir olcme yolunun olcmedigi kalemler"); yaz([-26, 8, 8], "kalem", "yol", "bicim"); for (const k of hicbiri) yaz([-26, 8, 8], k.ad, k.yol, k.bicim); console.log(`bu ${hicbiri.length} kalemin ortak yani: tek dogru bitis durumu yok, ` + `yanlisin gercek bedeli var.`); ``` ``` yetkinlik MODELI: 15 kalem, toplam yol yuku 237 (ayni yol birden cok kalemde sayilir; bu bir yuk toplamidir, ayrik yol sayisi degildir). 1. her olcme yolu kac kalemi olcuyor olcu coktan-secmeli uygulamali-sinav laboratuvar olctugu kalem 2/15 9/15 6/15 olctugu yol yuku 42 144 86 yol yukunun payi 17.7% 60.8% 36.3% 2. iki sinav bicimi nerede kesisiyor, nerede ayrisiyor kume kalem yol yuku ikisinde de olculen 2 42 (17.7%) yalniz birinde olculen 7 102 (43.0%) ikisinde de olculmeyen 6 93 (39.2%) laboratuvarin kapsamadigi 9 151 (63.7%) uc yolun birlikte olctugu 10 144 (60.8%) hicbirinde olculmeyen 5 93 (39.2%) 3. hicbir olcme yolunun olcmedigi kalemler kalem yol bicim kesilecek-adim-secimi 22 u mesru-is-bedeli 22 u envanter-tutma 19 u kapsam-yazimi 22 b sinir-tanima 8 b bu 5 kalemin ortak yani: tek dogru bitis durumu yok, yanlisin gercek bedeli var. ``` Birinci tablo üç yolu kapsam cinsinden sıralar. Çoktan seçmeli belgelendirme 15 kalemin **2'sini** ölçer ve toplam yol yükünün %17,7'sini kapsar. Uygulamalı sınav **9 kalemi** ve yükün %60,8'ini kapsar. Laboratuvar ortamı **6 kalemi** ve %36,3'ünü. İki sınav biçiminin arasındaki fark bir derece farkı değildir. Çoktan seçmeli belgelendirmenin ölçtüğü iki kalem — terim ayrımı ve risk sıralaması — uygulamalı sınavın ölçtüğü dokuz kalemin **içindedir**. İkinci tablonun ilk satırı bunu yazar: kesişim 2 kalem, ayrışma 7 kalemdir ve ayrışan yedi kalemin tamamı uygulamalı sınav tarafındadır. Bu iki ölçüm kardeş değil, **iç içedir**: biri ötekinin ölçtüğü kümenin dar bir alt kümesini ölçer. #### Laboratuvarın Kapsamadığı Laboratuvar ortamı bu iki sınavdan başka bir eksende ayrışır. Ölçtüğü kalemler tek anlamlı olup olmamalarına göre değil, **sonucu olup olmamasına** göre seçilir. `laboratuvarin kapsamadigi` satırı 9 kalem ve toplam yükün **%63,7'sini** yazar. Nedeni laboratuvarın tanımındadır. Bir laboratuvar ortamında meşru trafik yoktur; kimse faturalamayı kullanmadığı için yanlış kesilen bir adımın kimseyi durdurduğu görülmez. Başka bir ekip yoktur; bir kalemi devretmenin ya da devretmemenin sonucu doğmaz. Kapsam yoktur; sınır dışına çıkmanın karşılığı yoktur. Laboratuvar, **yanlışın bedelsiz olduğu** bir ortamdır ve tam olarak bu yüzden bedeli olan kalemleri ölçemez. Laboratuvarın değeri tekrar sayısındadır, sonucun gerçekliğinde değil. Üçü birlikte alındığında kapsam 10 kaleme ve yükün %60,8'ine çıkar. Laboratuvarın eklediği tek kalem `ortam-hazirlama`dır ve yol yükü **0'dır**: laboratuvar en çok, en az yol taşıyan kalemde katkı sağlar. #### Hiçbirinin Ölçmediği Beş Kalem Üçüncü tablo dersin asıl bulgusudur. Üç ölçme yolu birlikte bile **5 kalemi hiç ölçmez** ve bu beş kalem toplam yol yükünün **%39,2'sini** taşır. Beşinin ortak yanı çıktının son satırındadır: tek doğru bitiş durumu yoktur ve yanlışın gerçek bir bedeli vardır. Bu iki nitelik birlikte bir kalemi her üç ölçümün de dışına atar. Tek doğru yanıtı olmadığı için notlandırılamaz; gerçek bedeli olduğu için laboratuvarda oluşmaz. Kalemler tek tek okunduğunda tablo daha da keskinleşir. `kesilecek-adim-secimi` ve `mesru-is-bedeli` bu kursun iki temel işidir ve ikisi de **22 yol** taşır: bu kursun ilk dersinden son dersine kadar ölçülen şey, hangi adımın kesileceği ve o kesmenin kaç meşru işi durduracağıdır. `envanter-tutma` 19 yol taşır — birinci derste savunmanın bilmediği yolların sayısı. `kapsam-yazimi` 22, `sinir-tanima` 8 yol taşır. Beşi de bu kursun **ölçtüğü** kalemlerdir; hiçbiri bu kursun **ölçülebildiği** kalemler değildir. Bu, üç ölçme yolunun değersiz olduğu anlamına gelmez. Belgelendirme terim ayrımını gerçekten ölçer ve terim ayrımı olmadan hiçbir yol adlandırılamaz; uygulamalı sınav yükün %60,8'ini kapsar ve bu, sıradan bir eşik değildir. Ölçüm yalnız şunu söyler: **bir yetkinlik ölçüsünün kapsamadığı alan, o ölçünün geçersiz olduğu anlamına gelmez; ölçülmemiş kaldığı anlamına gelir.** Bir belge ya da bir sınav sonucu, taşıdığı yol yükü kadar bilgi verir — ne eksik ne fazla. #### Ölçünün Rolle Eşleşmesi Üç ölçme yolunun kapsamı, ikinci derste ayrılan beş rolün üstüne düşürüldüğünde soru bir seçim sorusuna dönüşür. Ölçülen on kalem ağırlıklı olarak **kapat** görevinin kalemleridir: katman eklemek, yetki daraltmak, bölme tasarlamak, olay yürütmek. Ölçülmeyen beş kalem ise **bul** ve **sürdür** görevlerine düşer: envanteri tutmak, kapsamı yazmak, sınırı tanımak. İki derste ayrı ayrı çıkan aynı boşluk buradadır: sorumluluk matrisinde sahipsiz kalan yedi hücrenin tamamı bu iki sütundaydı ve yetkinlik ölçümünde de ölçüsüz kalan beş kalem aynı iki sütuna düşüyor. **Kurumlar işi yapan eli hem tanımlamayı hem ölçmeyi biliyor; listeyi tutan ve sonucu sınayan eli ikisinde de atlıyor.** Bunun pratik karşılığı bir sıralama değil, bir eşleştirmedir. Uygulamalı sınav bir adayın kesme işini yapabildiğini gösterir; hangi adımın kesileceğini ve o kesmenin kaç meşru işi durduracağını göstermez. O iki kalem, birinci dersin ölçtüğü **mor çalışmanın** kendisidir: savunma ile sınama tarafı aynı yol kümesi üzerinde birlikte yürüdüğünde ortaya çıkar ve orada da bir sınav notuyla değil, kapanan yol ile duran meşru isteğin oranıyla ölçülür. Yetkinliğin ölçülmemiş kısmı ölçülemez değildir; **kursun kendi üç sütunuyla, işin üstünde ölçülür.** #### Özet - 15 kalemlik yetkinlik kümesinde çoktan seçmeli belgelendirme 2, uygulamalı sınav 9, laboratuvar ortamı 6 kalem ölçer; kapsadıkları yol yükü payı sırasıyla %17,7, %60,8 ve %36,3'tür. - İki sınav biçimi kardeş değil iç içedir: kesişim 2 kalem, ayrışma 7 kalemdir ve ayrışan yedi kalemin tamamı uygulamalı sınav tarafındadır. - Laboratuvar ortamı 9 kalemi kapsamaz ve bunlar toplam yükün %63,7'sini taşır. Nedeni ortamın tanımıdır: meşru trafik, başka ekip ve kapsam sınırı olmadığı için yanlışın bedeli oluşmaz. - Üç yol birlikte 10 kalemi ölçer; laboratuvarın tek eklediği kalemin yol yükü 0'dır. - Hiçbir yolun ölçmediği 5 kalem yükün %39,2'sini taşır ve ortak yanları aynıdır: tek doğru bitiş durumu yok, yanlışın gerçek bedeli var. İkisi bu kursun temel işidir ve 22'şer yol taşır. #### Kurs Kapanışı | Ders | Kaç yol | Kapanan yol | Meşru işe bedel | |---|---|---|---| | Gizlilik, Bütünlük ve Erişilebilirlik | 8 varlık × 3 eksen | 6 karar: 27 artış, 22 düşüş | net sıfır kararda gizlilik −6 | | Varlık, Tehdit ve Açık | 576 üçlüden 19 geçerli | 5 açık, 12 üçlü | bölge daraltmada 3, 2, 1, 0 üçlü | | Risk Tanımı | 12 kalem, 176,05 birim | 4 kalemlik bütçe, 77,00 birim | puanlama biçimi 9,40 birim | | İstismar ve Yük | 12 zincir, 53 adım | tek adım en çok 8 zincir | orta adımlar kırık, 1 zincir kalır | | Saldırı Yüzeyi | 35 yol, 21 kenar | ilk üç kaldırma %68,6 | 7 iş, kalan 4 yola 24 iş | | Derinlemesine Savunma | 55 yol | 52 kapanır, 3 kalır | 63 yönetilen kalem, 1.793 ek adım | | En Az Yetki | 55 yol | 43 yol, 15'i bedelsiz | günde 11 istekten 3.502'ye | | Yalıtım | 14 düğüm, 4 varlık | erişilen varlık 4 → 2,8 | 20 geçit, günde 3.513 istek | | Sıfır Güven | 55 yol | konumda 5, her adımda 35 | günde 7.019 doğrulama, +2,00 adım | | Kimlik Doğrulama ve Yetkilendirme Ayrımı | 55 yol, iki istek türü | yanlış katmanda 0, doğruda 35 | istek başına 2,57; +1,43 adıma 0 yol | | Güvenli Varsayılanlar | 22 kalem, 20 yol | unutulan tek kalem 12 yol açar | kapalıda günde 319, en kötü 1.440 | | Mavi, Kırmızı ve Mor Takımlar | 30 yol | 17 → 22 | günde 2.764 istekten 2.037'ye | | Güvenlik Rolleri | 30 yol | 28 → 30 | günde 2.321 istekten 2.135'e | | Yasal Çerçeve ve Etik | 30 yol | 8 → 22 sınanabilir | günde 4.607 istek, 4 pencere | | Mesleki Yetkinlik Yolları | 237 yol yükü | 144 ölçülür (%60,8) | 5 kalem, 93 yük ölçüsüz | Kursun kuralı on beş satırın hepsinde aynıdır: **savunma bir yasak listesi değil, sayılabilir bir yol kümesinin daraltılmasıdır; bedeli yazılmayan savunma ölçülmemiş sayılır.** Orta sütun olmadan sol sütun bir envanter dökümü, sağ sütun olmadan orta sütun bir başarı ilanıdır. Sağ sütun on beş satırda dört aileye iner. **Durdurulan meşru iş** altı derste tekrar eder (en az yetki, yalıtım, güvenli varsayılanlar ve son üç ders): bedel doğrudan kullanıcının önüne çıkar ve bu yüzden en çabuk fark edilen ailedir. **Her isteğe eklenen adım** üç derste (derinlemesine savunma, sıfır güven, kimlik ile yetki ayrımı): fark edilmez ama her istekte ödenir. **Elle yönetilen kalem** üç derste (63 yönetilen kalem, 20 geçit, 4 sınama penceresi): bir olay yaşanmadığı sürece kimse saymaz. **Sayı cinsinden bedel** ilk dört derste, henüz yol birimi kurulmadan ölçülmüştür. Sol sütun kendi hikâyesini anlatır. İlk dört ders yol birimini hiç kullanmaz: orada sayılan şey eksen, üçlü, kalem ve zincirdir. Birim beşinci derste kurulur ve o noktadan sonra on ders boyunca hiç değişmez. Yol sayısının kendisi ise sabit değildir — 35, 55 ve 30 — çünkü sayı grafın nasıl çizildiğine, kaç giriş ucu ve kaç hedef tanımlandığına bağlıdır. **Yol sayısı bir gerçek değil, bir modelin çıktısıdır**; karşılaştırılabilir olması için grafın da yazılı olması gerekir. Orta sütun ise iki derste savunmanın **yetmediğini** yazar. Derinlemesine savunma elli beş yolun elli ikisini kapatır ve kalan üç yol meşru kanalın kendisidir: katman eklemek onları kapatmaz. Sıfır güven her adımda doğrulama yaparak yirmi yolu açık bırakır ve o yirmi yolun kaynağı bir denetim eksiği değil, dört iç akışın tasarımıdır. Bir yol kümesi hiçbir zaman sıfırlanmaz; ancak kalanın **neden** kaldığı yazılır. Yollar sayıldı, ilkeler ölçüldü, ölçümü kimin hangi sınırda yapacağı yazıldı. Yine de bu on beş dersin tamamı yolları soyut düğümler ve adımlar olarak ele aldı. **M24/K02 Bilgi Teknolojileri ve Sistem Temelleri** o soyutlamayı açar: bütün bu yolların üzerinden geçtiği **makinenin kendisi** hangi bileşenlerden kurulur, işletim sistemi bir kullanıcı ile bir başkasının arasına hangi sınırı çizer, dosya izni bir adımı nasıl kesebilir ve sanallaştırma bir konuk ile konak arasına ne kadar sağlam bir duvar koyar.