Güvenlik Bağlamı

Önceki dersin politikası kapsüller arasındaki trafiği sınırladı. Kapsülün kendi içinde ne yapabildiğini sınırlamadı: ayrıcalıklı çalışan, ana makinenin ağını paylaşan ya da geniş bir yetenek kümesiyle açılan bir süreç, ağ politikası eksiksiz yazılmış olsa bile durduğu düğümde başka bir alan açar. Bu ayarların tek tek ne yaptığı ve tek makinede neye mal olduğu daha önce ölçüldü — yetenek sayımı, salt okunur kök, kaynak sınırı. O ölçüm burada tekrarlanmıyor.

Buranın sorusu farklı ve daha dar: küme bu ayarları nasıl dayatıyor. Bir ayarın doğru değeri bilinse bile, yirmi dört ayrı tanımın hepsinde o değerin bulunması kendiliğinden olmaz. Devredilen karar şudur: bir kapsül tanımının kümeye kabul edilip edilmeyeceğine, tanımın içeriğine bakarak bir kabul denetimi karar verir. Bilmesi gereken kalem tektir ve ucuzdur — tanımın kendisi, zaten kümeye gönderilmiştir. Bu dersin ölçüsü bilginin maliyeti değil, kararın sonucudur: dayatma açıldığında ne duruyor.

• OI25. Yirmi dört kapsül tanımı üç ad alanına dağılmıştır ve kurgusal bölgesel ölçüm ağına aittir. Tanımlar tohumu görünür bir üreteçle kuruldu; gerçek bir depodan okunmadılar. Gerçek bir küme koşturulmuyor.
• OI26. Güvenlik bağlamı altı alana indirgendi. Alanların anlamı ve tek makinedeki bedeli daha önce ölçüldü; burada yalnız kaç tanımda hangi değerin bulunduğu sayılıyor.
• OI27. Kabul denetimi tanımın bildirdiğine bakar. Görüntünün çalışma zamanında gerçekte ne yaptığı bu denetimin görüş alanı dışındadır; bu sınır ölçümün sonunda ayrıca ele alınıyor.
• OI28. Dağıtım akışı kırk denemedir ve ayrı bir tohumla üretildi. Aynı tanım akışta birden çok kez görünebilir; kırk deneme on dokuz ayrı tanıma dokunuyor.
• OI29. Muafiyet iki biçimde verildi: bir ad alanının tamamına ve “eski” işaretli tanımlara. Tanım başına tek tek muafiyet modellenmiyor; modellenseydi açıkta kalan sayısı düşer, yönü değişmezdi.
• OI30. Uyarma kipinde hiçbir dağıtım durmaz. Uyarı kaydı ihlal başına bir satırdır, tanım başına değil.

Tanımlar ve Kural

// kabul.mjs — kapsul tanimlari ve kabul denetimi; gercek kume degil, node ile kurulan bir model
export const TOHUM = 20260805, ALAN = ['gelistirme', 'hazirlik', 'uretim'], TANIM_SAYISI = 24;
export function uretec(tohum) {                        // dogrusal eslesik uretec, tohum gorunur
  let x = tohum >>> 0;
  return () => { x = (Math.imul(x, 1664525) + 1013904223) >>> 0; return x / 4294967296; };
}
// Kendi semamiz: her tanim alti guvenlik baglami alani tasir.
export function tanimlar() {
  const r = uretec(TOHUM), t = [];
  for (let i = 0; i < TANIM_SAYISI; i += 1) {
    const alan = ALAN[i % ALAN.length];
    const eski = r() < 0.45;                           // eski tanimlar daha gevsek yazilmis
    t.push({ ad: `tanim-${String(i + 1).padStart(2, '0')}`, alan, eski,
      ayricalikli: r() < (eski ? 0.30 : 0.04),
      kokKullanici: r() < (eski ? 0.80 : 0.35),
      saltOkunurKok: r() < (eski ? 0.10 : 0.55),
      yukseltmeyeIzin: r() < (eski ? 0.85 : 0.40),
      anaMakineAgi: r() < (eski ? 0.25 : 0.04),
      ekYetenek: Math.floor(r() * (eski ? 5 : 2)) });
  }
  return t;
}
export const KURAL = [                                 // kabul denetimi kurallari
  ['ayricalikli calismasin', (d) => !d.ayricalikli],
  ['kok kullanici olmasin', (d) => !d.kokKullanici],
  ['kok dosya sistemi salt okunur olsun', (d) => d.saltOkunurKok],
  ['yetki yukseltmeye izin verilmesin', (d) => !d.yukseltmeyeIzin],
  ['ana makine agi kullanilmasin', (d) => !d.anaMakineAgi],
  ['ek yetenek istenmesin', (d) => d.ekYetenek === 0],
];
export const ihlal = (d, kural = KURAL) => kural.filter(([, f]) => !f(d)).map(([ad]) => ad);
export const uygun = (d, kural = KURAL) => ihlal(d, kural).length === 0;

Kural, tanımın bir alanına bakan bir yüklemdir; politika bu yüklemlerin listesidir. Tanımların “eski” işareti modelin tek eğrisidir: daha önce yazılmış tanımların gevşek değerler taşıma olasılığı yüksek tutuldu. Gerçek bir depoda bu eğri ölçülür, varsayılmaz.

Mevcut Tanımlar Kurala Vuruluyor

// kosum10.mjs — mevcut tanimlar kurala vuruluyor: kac tanim uymuyor, hangi kural kac kez
import { tanimlar, KURAL, ALAN, TOHUM, ihlal, uygun } from './kabul.mjs';

const t = tanimlar();
console.log(`tohum ${TOHUM} | ${t.length} kapsul tanimi, ${ALAN.length} ad alani, ${KURAL.length} kural`);
console.log(`politikaya uymayan tanim: ${t.filter((d) => !uygun(d)).length}/${t.length}\n`);
console.log('kural                                 ihlal eden tanim');
for (const [ad, f] of KURAL) console.log(`${ad.padEnd(37)} ${t.filter((d) => !f(d)).length}`);
console.log('\nihlal sayisi  tanim');
const dagilim = new Map();
for (const d of t) dagilim.set(ihlal(d).length, (dagilim.get(ihlal(d).length) ?? 0) + 1);
for (const n of [...dagilim.keys()].sort((a, b) => a - b)) console.log(`${String(n).padEnd(13)} ${dagilim.get(n)}`);
console.log('\nad alani     tanim  uymayan  toplam ihlal');
for (const a of ALAN) {
  const g = t.filter((d) => d.alan === a);
  console.log(`${a.padEnd(12)} ${String(g.length).padEnd(6)} ${String(g.filter((d) => !uygun(d)).length).padEnd(8)} ` +
    `${g.reduce((s, d) => s + ihlal(d).length, 0)}`);
}

tohum 20260805 | 24 kapsul tanimi, 3 ad alani, 6 kural
politikaya uymayan tanim: 19/24

kural                                 ihlal eden tanim
ayricalikli calismasin                2
kok kullanici olmasin                 14
kok dosya sistemi salt okunur olsun   11
yetki yukseltmeye izin verilmesin     11
ana makine agi kullanilmasin          5
ek yetenek istenmesin                 10

ihlal sayisi  tanim
0             5
1             6
2             2
3             5
4             3
5             2
6             1

ad alani     tanim  uymayan  toplam ihlal
gelistirme   8      6        19
hazirlik     8      7        13
uretim       8      6        21

Yirmi dört tanımın on dokuzu politikaya uymuyor. Bu sayı tek başına bir şey söylemez; ilginç olan ikinci tablodur. Uymayan on dokuz tanımın altısında tek ihlal var, birinde altısı birden. Yani “politikaya uymayan tanım” tek bir sınıf değil: bir ucunda tek satırlık bir düzeltmeyle uygun hâle gelecek tanımlar, öteki ucunda baştan yazılması gereken bir tanım duruyor. Toplam ihlal sayısı elli üçtür, tanım sayısının iki katından fazla.

Kural tablosu dayatmanın nereden zorlaşacağını gösteriyor. En sert görünen kural — ayrıcalıklı çalışmasın — yalnız iki tanımı vuruyor; en çok tanımı vuran kural, kök kullanıcı yasağı, on dördü. Bir politikanın “ne kadar sıkı” olduğu kurallarının sertliğiyle değil, mevcut tanımlara ne kadar uzak olduğuyla ölçülüyor. Ad alanı tablosu bunu doğruluyor: uymayan tanım sayısı üç ortamda da altı ile yedi arasında, ama toplam ihlal üretimde yirmi bir, hazırlıkta on üç. Üretimdeki tanımlar daha az sayıda değil, daha derin uyumsuz.

Uyarma, Engelleme, Muafiyet

// kosum11.mjs — uyarma kipi, engelleme kipi ve muafiyet ayri ayri sayiliyor
import { tanimlar, KURAL, uretec, ihlal, uygun } from './kabul.mjs';

const AKIS_TOHUM = 77021, DAGITIM = 40;
const t = tanimlar(), r = uretec(AKIS_TOHUM);
const akis = Array.from({ length: DAGITIM }, () => t[Math.floor(r() * t.length)]);
console.log(`dagitim akisi: tohum ${AKIS_TOHUM}, ${DAGITIM} deneme, ${new Set(akis.map((d) => d.ad)).size} ayri tanim`);
console.log(`akistaki uymayan deneme: ${akis.filter((d) => !uygun(d)).length}\n`);

const SENARYO = [
  ['uyarma, muafiyet yok', KURAL, () => false, false],
  ['engelleme, muafiyet yok', KURAL, () => false, true],
  ['engelleme, gelistirme muaf', KURAL, (d) => d.alan === 'gelistirme', true],
  ['engelleme, eski tanimlar muaf', KURAL, (d) => d.eski, true],
  ['engelleme, yalniz iki kural', KURAL.slice(0, 1).concat([KURAL[4]]), () => false, true],
];
console.log('senaryo                        kural  durdurulan  gecen uymayan  tam politikaya  uyari');
console.log('                                      dagitim     dagitim        gore acikta     kaydi');
for (const [ad, kural, muaf, engelle] of SENARYO) {
  let durdurulan = 0, gecenUymayan = 0, uyari = 0;
  for (const d of akis) {
    const i = ihlal(d, kural);
    if (i.length === 0) continue;
    if (muaf(d)) { gecenUymayan += 1; uyari += i.length; continue; }
    if (engelle) durdurulan += 1; else { gecenUymayan += 1; uyari += i.length; }
  }
  const acikta = t.filter((d) => !uygun(d) && (muaf(d) || !engelle || uygun(d, kural))).length;
  console.log(`${ad.padEnd(30)} ${String(kural.length).padEnd(6)} ${String(durdurulan).padEnd(11)} ` +
    `${String(gecenUymayan).padEnd(14)} ${String(acikta).padEnd(15)} ${uyari}`);
}
console.log('\nalti kural birlikte degil tek tek dayatilsaydi, kural basina durdurulan dagitim:');
for (const k of KURAL) {
  const d = akis.filter((x) => ihlal(x, [k]).length).length;
  console.log(`  ${k[0].padEnd(37)} ${d}`);
}

dagitim akisi: tohum 77021, 40 deneme, 19 ayri tanim
akistaki uymayan deneme: 33

senaryo                        kural  durdurulan  gecen uymayan  tam politikaya  uyari
                                      dagitim     dagitim        gore acikta     kaydi
uyarma, muafiyet yok           6      0           33             19              89
engelleme, muafiyet yok        6      33          0              0               0
engelleme, gelistirme muaf     6      22          11             6               33
engelleme, eski tanimlar muaf  6      17          16             11              59
engelleme, yalniz iki kural    2      6           0              13              0

alti kural birlikte degil tek tek dayatilsaydi, kural basina durdurulan dagitim:
  ayricalikli calismasin                3
  kok kullanici olmasin                 24
  kok dosya sistemi salt okunur olsun   23
  yetki yukseltmeye izin verilmesin     17
  ana makine agi kullanilmasin          5
  ek yetenek istenmesin                 17

Aynı politika, aynı tanımlar, aynı akış; değişen tek şey dayatma kipi. Uyarma kipinde hiçbir dağıtım durmadı, seksen dokuz uyarı kaydı üretildi ve on dokuz tanım açıkta kaldı. Engelleme kipinde kırk denemenin otuz üçü durdu — yüzde seksen ikisi. Bu iki satır arasındaki mesafe, politikayı yazmakla dayatmak arasındaki mesafedir; ikisi arasında bir gün bile geçmeden geçilirse kümenin dağıtım akışı fiilen durur.

Muafiyet satırları bu mesafeyi kısaltmanın iki yolunu ölçüyor ve ikisi aynı şeyi yapmıyor. Geliştirme ad alanı muaf tutulduğunda durdurulan dağıtım otuz üçten yirmi ikiye iniyor ve altı tanım açıkta kalıyor. Eski tanımlar muaf tutulduğunda durdurulan dağıtım on yediye kadar iniyor — akış daha rahat geçiyor — ama açıkta kalan tanım on bire, uyarı kaydı elli dokuza çıkıyor. Ölçünün söylediği şu: muafiyet ne kadar rahatlatıyorsa o kadar açık bırakıyor ve “eski tanımlar” muafiyeti tam olarak en kötü tanımları muaf tutuyor, çünkü ihlallerin çoğu zaten onlarda.

Son satır üçüncü bir yolu ölçüyor: bütün politikayı değil, iki kuralını dayatmak. Durdurulan dağıtım altıya iniyor, geçen uymayan dağıtım sıfır — o iki kurala göre hiçbir şey kaçmıyor. Ama son sütun tam politikaya göre on üç tanımın açıkta olduğunu söylüyor. Bu, muafiyetten farklı bir açıklık türüdür: muafiyette kural vardır ve bazı tanımlara uygulanmaz; kural alt kümesinde ise kural hiç yoktur, dolayısıyla hiçbir uyarı da üretilmez. Uyarı sütununun sıfır olması bunun kanıtıdır — on üç açık tanımın hiçbiri hiçbir yerde görünmüyor.

Alt blok hangi iki kuralın seçileceğini sayıya bağlıyor. Kök kullanıcı yasağı tek başına kırk denemenin yirmi dördünü durdururdu, salt okunur kök yirmi üçünü. Ayrıcalık yasağı üçünü, ana makine ağı yasağı beşini. İlk adımda dayatılacak kurallar bu sütuna bakılarak seçilir: en az dağıtımı durduran kurallar, en az direnişle kapatılabilen kurallardır ve kapandıktan sonra geri açılmazlar.

Aşamalı Dayatma

Alt bloğun sıraladığı sayılar bir program üretiyor: kurallar en az durduran sırayla, birikimli olarak açılabilir. Her adımda durdurulan dağıtım, düzeltilmesi gereken tanım ve hâlâ açıkta olan tanım ayrı ayrı sayılır.

// kosum12.mjs — kurallar en az durduran sirayla, birikimli dayatiliyor
import { tanimlar, KURAL, uretec, ihlal, uygun } from './kabul.mjs';

const t = tanimlar(), r = uretec(77021);
const akis = Array.from({ length: 40 }, () => t[Math.floor(r() * t.length)]);
const sira = [...KURAL].sort((a, b) =>
  akis.filter((x) => !a[1](x)).length - akis.filter((x) => !b[1](x)).length);
console.log('adim  eklenen kural                        durdurulan  duzeltilecek  tam politikaya');
console.log('                                           dagitim     tanim         gore acikta');
for (let n = 1; n <= sira.length; n += 1) {
  const alt = sira.slice(0, n);
  const durdurulan = akis.filter((d) => ihlal(d, alt).length).length;
  const duzeltilecek = t.filter((d) => !uygun(d, alt)).length;
  const acikta = t.filter((d) => !uygun(d) && uygun(d, alt)).length;
  console.log(`${String(n).padEnd(5)} ${sira[n - 1][0].padEnd(36)} ${String(durdurulan).padEnd(11)} ` +
    `${String(duzeltilecek).padEnd(13)} ${acikta}`);
}

adim  eklenen kural                        durdurulan  duzeltilecek  tam politikaya
                                           dagitim     tanim         gore acikta
1     ayricalikli calismasin               3           2             17
2     ana makine agi kullanilmasin         6           6             13
3     yetki yukseltmeye izin verilmesin    20          13            6
4     ek yetenek istenmesin                30          17            2
5     kok dosya sistemi salt okunur olsun  30          17            2
6     kok kullanici olmasin                33          19            0

İlk iki adım ucuz: altı dağıtım durur, altı tanım düzeltilir ve on üç tanım açıkta kalır. Üçüncü adım sıçramayı yapıyor — durdurulan dağıtım altıdan yirmiye çıkıyor — ama karşılığında açıkta kalan tanım on üçten altıya iniyor. Eğrinin bu biçimi bir yerde durulabileceğini gösteriyor: üç adımda tam politikanın açıklığının yaklaşık üçte ikisi, dağıtım akışının yarısını durdurmadan kapanıyor.

Dördüncü ve beşinci satırlar aynı üç sayıyı taşıyor. Salt okunur kök kuralı eklendiğinde hiçbir şey değişmiyor: dördüncü adımdan sonra o kuralı ihlal eden her tanım zaten başka bir kuralı da ihlal ediyor. Kural tek başına on bir tanımı vuruyordu, birikimli sırada sıfır yeni tanım getiriyor. Bir kuralın değeri tek başına vurduğu tanım sayısıyla değil, ötekilerin üstüne ne eklediğiyle ölçülüyor; sıralamayı bilmeden yazılan bir dayatma programı bu farkı göremez.

Denetimin Görmediği

Bu ölçümün tamamı tanımların bildirdiği değerler üzerinden yapıldı. Kabul denetimi kapsül tanımını okur, altı alana bakar ve karar verir; kararın maliyeti bir okuma, gecikmesi bir istektir. Bu ucuzluğun kaynağı, denetimin bakabildiği tek şeyin bildirim olmasıdır.

Bildirimin doğru olması, davranışın da doğru olduğu anlamına gelmez. Ek yetenek istemediğini bildiren bir tanımın görüntüsü, açılışta o yeteneği gerektiren bir işlem deneyebilir; denetim bunu göremez, çünkü denetim dağıtımdan önce çalışır ve süreç henüz yoktur. Tersi de geçerlidir: kök kullanıcı olarak çalıştığını bildiren bir tanım, kökle hiçbir şey yapmıyor olabilir. İlk durumda küme uyumlu sanır ve süreç çalışma zamanında başarısız olur; ikinci durumda küme uymuyor sayar ve gereksiz yere durdurur. On dokuz uymayan tanımın kaçının ikinci sınıfa girdiği bu modelden okunamaz — okunması için çalışma zamanı gözlemi gerekir, o da başka bir bilgi kalemidir.

Devredilen kararın sınırı budur. Kabul denetimi “bu tanım politikaya uyuyor mu” sorusunu kesin cevaplar; “bu iş yükü güvenli mi” sorusunu cevaplamaz. İkisi arasındaki farkı kapatan şey bir kural daha değil, bildirimlerin gerçeği yansıtmasını sağlayan bir üretim düzenidir.

Özet

• Yirmi dört tanımın on dokuzu altı kurallı politikaya uymuyor ve toplam ihlal elli üç; uymayan tanımların altısında tek ihlal, birinde altı ihlal var, yani uyumsuzluk tek bir sınıf değil. Politikanın sıkılığı da kuralların sertliğinden değil mevcut tanımlara uzaklığından gelir: ayrıcalık yasağı iki tanımı, kök kullanıcı yasağı on dördünü vuruyor.
• Uyarma kipinde sıfır dağıtım durur ve seksen dokuz uyarı üretilir; engelleme kipinde kırk denemenin otuz üçü, yüzde seksen ikisi durur. İki kip arasındaki geçiş bu mesafeyi kat eder.
• Muafiyet rahatlattığı ölçüde açık bırakır: geliştirme ad alanı muafiyeti durdurulanı yirmi ikiye indirip altı tanımı, eski tanım muafiyeti on yediye indirip on bir tanımı açıkta bırakır.
• Kural alt kümesi dayatmak muafiyetten farklı bir açıklık üretir: iki kuralla altı dağıtım durur ve tam politikaya göre on üç tanım açıkta kalır, ama uyarı kaydı sıfırdır — açıklık hiçbir yerde görünmez.
• Kurallar en az durduran sırayla açıldığında üç adımda açıklık on dokuzdan altıya iner; beşinci adımda eklenen kural hiçbir yeni tanım getirmez, çünkü ihlalleri öteki kurallar zaten kapsar.
• Kabul denetimi tanımın bildirdiğine bakar, sürecin yaptığına değil; “politikaya uyuyor mu” sorusunu kesin, “güvenli mi” sorusunu hiç cevaplamaz.

Sonraki Adım

Bu dersin altı alanı yirmi dört tanımın her birine ayrı ayrı yazılmak zorundaydı ve on dokuzunda yanlış yazılmıştı. Aynı durum önceki üç dersin çıktıları için de geçerli: dağıtım kalıbının adımları, üç denetimin periyot ve eşikleri, rol tanımları ve ağ kuralları hep aynı tanım dosyalarında duruyor ve her servis için yeniden yazılıyor. Tekrarın kendisi bir ölçüdür — aynı değerin kaç dosyada geçtiği, bir değeri değiştirmenin kaç dosyaya dokunmayı gerektirdiği. Sonraki ders bu tekrarı sayar ve tanımları tek bir kaynaktan üretmenin neyi azaltıp neyi eklediğini ölçer.