Denetim Kontrol Kümeleri

Önceki iki ders kontrolün kendisini ölçtü: ne kadar kurumsallaştığını ve denetimin nereye kadar uzandığını. Belgeyi okuyan tarafın sorusu ise başkadır — kendi gereksinimini getirir ve onu hangi kontrolün karşıladığını sorar. Bu soruya yanıt veren yapı denetim kontrol kümesidir: güven ilkelerine göre gruplanmış, belirli bir dönem boyunca işlediği kanıtlanan bir kontrol seti.

Buradaki “belirli bir dönem boyunca” ifadesi bu ders için belirleyicidir. Bir kontrolün tasarım olarak var olduğunu göstermek bir belgeyle olur; işlediğini göstermek ancak dönem boyunca üretilmiş kayıtların örneklenmesiyle olur. M23/K05’te kiralanan katmanda kanıtın kimden geldiği sayılmıştı; o ayrım burada girdidir. Sağlayıcının belgesi tasarımı gösterir, dönem boyunca işlediğini göstermez — ve bu, bir gereksinimi “karşılanmış” saymaya yetmeyebilir.

• CE14. Kontrol kümesi 28 kalemdir ve beş güven ilkesine bölünmüştür: güvenlik, erişilebilirlik, işleme bütünlüğü, gizlilik, mahremiyet. Küme ve sayılar kurgudur.
• CE15. Her kontrolün bir kanıt kaynağı vardır: kendi kaydı, sağlayıcı belgesi ya da hiçbiri.
• CE16. Her kontrol bir dönemde belirli sayıda kanıt kalemi üretir; sıfır üreten kontrol denetimde örneklenemez.
• CE17. Gereksinim kümesi 25 kalemdir; her gereksinim sıfır ya da daha çok kontrole eşlenir. Eşleme iddiadır, kanıt değildir.
• CE18. Bir gereksinimin durumu dörde ayrılır: en az bir işletim kanıtı taşıyan kontrolü varsa işletim kanıtı; yalnız sağlayıcı belgesine dayanıyorsa yalnız beyan; eşlendiği kontroller hiç kanıt üretmiyorsa kanıtsız; hiç kontrolü yoksa eşlenmemiş.
• CE19. Paylaşılan bir kontrolün kanıt yükü, karşıladığı gereksinimlere eşit bölünür.
• CE20. Denetçi bir kontrolden en çok 25 kalem inceler ve kalem başına 0,25 kişi-saat derleme harcar (kurgu).

// matris/eslem.mjs — denetim kontrol kumesinde kontrol-gereksinim matrisi.
// MODELDIR: bolgesel olcum agi (kurgu); kontroller, gereksinimler ve kanit sayilari kurgudur.
export const satir = (s) => s.trim().split("\n").map((l) => l.trim().split("|"));
export const gen = (B) => (...h) => h.map((v, j) =>
  (j ? String(v).padStart(B[j]) : String(v).padEnd(B[0]))).join("");

// kod | guven ilkesi | kanit kaynagi (kendi|saglayici|yok) | donemde uretilen kanit kalemi
export const KONTROL = Object.fromEntries(satir(`
  K01|guvenlik|kendi|240
  K02|guvenlik|kendi|180
  K03|guvenlik|kendi|60
  K04|guvenlik|kendi|48
  K05|guvenlik|kendi|365
  K06|guvenlik|kendi|52
  K07|guvenlik|kendi|12
  K08|guvenlik|saglayici|1
  K09|guvenlik|saglayici|1
  K10|guvenlik|kendi|4
  K11|guvenlik|kendi|3
  K12|guvenlik|kendi|2
  K13|erisilebilirlik|kendi|365
  K14|erisilebilirlik|kendi|4
  K15|erisilebilirlik|kendi|365
  K16|erisilebilirlik|saglayici|1
  K17|erisilebilirlik|kendi|1
  K18|isleme-butunlugu|kendi|365
  K19|isleme-butunlugu|kendi|12
  K20|isleme-butunlugu|kendi|52
  K21|isleme-butunlugu|kendi|310
  K22|gizlilik|kendi|1
  K23|gizlilik|kendi|365
  K24|gizlilik|kendi|365
  K25|gizlilik|saglayici|1
  K26|mahremiyet|yok|0
  K27|mahremiyet|kendi|30
  K28|mahremiyet|yok|0`)
  .map(([kod, ilke, kaynak, kalem]) => [kod, { kod, ilke, kaynak, kalem: +kalem }]));

// gereksinim | onu karsiladigi ileri surulen kontroller
export const GEREKSINIM = satir(`
  G01 yetkisiz erisimin engellenmesi|K01 K03 K04
  G02 ayricalikli islemin izlenmesi|K01 K02
  G03 personel degisiminin yansitilmasi|K04
  G04 uc nokta korumasinin surekliligi|K05 K06
  G05 acigin makul surede kapatilmasi|K06
  G06 ag sinir kurallarinin gozden gecirilmesi|K07
  G07 fiziksel erisimin denetlenmesi|K08
  G08 donanimin guvenli imhasi|K09
  G09 personelin bilinclendirilmesi|K10
  G10 tedarikcinin degerlendirilmesi|K11
  G11 olaya hazirlikli olma|K12
  G12 verinin kaybolmamasi|K13 K14
  G13 hizmetin kesintisiz surmesi|K15 K16
  G14 kesintiden sonra ayaga kalkma|K14 K17
  G15 girdinin dogrulanmasi|K18
  G16 islemin eksiksizligi|K19 K20
  G17 degisikligin yetkilendirilmesi|K21
  G18 verinin siniflandirilmasi|K22
  G19 saklama suresine uyulmasi|K23
  G20 verinin sifrelenmesi|K24 K25
  G21 verinin nereye aktigi|K26
  G22 silme talebinin karsilanmasi|K26 K27
  G23 islemenin dayanagi|K28
  G24 alt yuklenici zincirinin gorunurlugu|
  G25 kayitlarin degistirilemezligi|`)
  .map(([ad, k]) => ({ ad, kod: ad.split(" ")[0], kontrol: k ? k.split(" ") : [] }));

export const ILKE = ["guvenlik", "erisilebilirlik", "isleme-butunlugu", "gizlilik", "mahremiyet"];
// Isletim kaniti: bir donem boyunca kendi kaydindan uretilen kalem. Saglayici belgesi
// tasarimi gosterir, donem boyunca isledigini gostermez (model varsayimi).
export const isletim = (k) => KONTROL[k].kaynak === "kendi" && KONTROL[k].kalem > 0;
export const durum = (g) => !g.kontrol.length ? "eslenmemis"
  : g.kontrol.some(isletim) ? "isletim kaniti"
  : g.kontrol.some((k) => KONTROL[k].kaynak === "saglayici") ? "yalniz beyan" : "kanitsiz";

if (import.meta.url === `file://${process.argv[1]}`) {
  const bag = GEREKSINIM.reduce((a, g) => a + g.kontrol.length, 0);
  console.log(`model: ${Object.keys(KONTROL).length} kontrol, ${GEREKSINIM.length} gereksinim, ` +
    `${bag} bag, ${ILKE.length} guven ilkesi`);

  const y = gen([18, 9, 11, 20, 16, 14]);
  console.log("\n" + y("guven ilkesi", "kontrol", "isletimli", "karsiladigi gerek.",
    "donem kalemi", "kalem/gerek."));
  for (const i of ILKE) {
    const kume = Object.values(KONTROL).filter((k) => k.ilke === i);
    const kodlar = kume.map((k) => k.kod);
    const gerek = GEREKSINIM.filter((g) => g.kontrol.some((k) => kodlar.includes(k)));
    const kalem = kume.reduce((a, k) => a + k.kalem, 0);
    console.log(y(i, kume.length, kume.filter((k) => isletim(k.kod)).length, gerek.length,
      kalem, gerek.length ? (kalem / gerek.length).toFixed(1) : "-"));
  }

  const z = gen([18, 12, 12, 12]);
  const DURUM = ["isletim kaniti", "yalniz beyan", "kanitsiz", "eslenmemis"];
  console.log("\n" + z("gereksinim durumu", "sayi", "yuzde", "kontrol"));
  for (const d of DURUM) {
    const k = GEREKSINIM.filter((g) => durum(g) === d);
    console.log(z(d, k.length, (100 * k.length / GEREKSINIM.length).toFixed(0),
      k.reduce((a, g) => a + g.kontrol.length, 0)));
  }
  for (const d of DURUM.slice(1)) {
    console.log(`${d}: ${GEREKSINIM.filter((g) => durum(g) === d)
      .map((g) => g.kod).join(", ")}`);
  }

  // Kaldirac: bir kontrol kac gereksinimi karsiliyor.
  const kaldirac = Object.values(KONTROL).map((k) =>
    ({ ...k, g: GEREKSINIM.filter((x) => x.kontrol.includes(k.kod)).length }));
  const cok = kaldirac.filter((k) => k.g > 1), tek = kaldirac.filter((k) => k.g === 1);
  console.log(`\nbirden cok gereksinimi karsilayan kontrol ${cok.length}/${kaldirac.length}: ` +
    `${cok.map((k) => `${k.kod} (${k.g})`).join(", ")}`);
  console.log(`tek gereksinim tasiyan kontrol ${tek.length}; hicbir gereksinime baglanmayan ` +
    `${kaldirac.filter((k) => k.g === 0).length}`);
  const toplam = Object.values(KONTROL).reduce((a, k) => a + k.kalem, 0);
  console.log(`donemde uretilen kanit kalemi ${toplam}; kontrol basina ` +
    `${(toplam / kaldirac.length).toFixed(1)}, karsilanan gereksinim basina ` +
    `${(toplam / GEREKSINIM.filter((g) => durum(g) === "isletim kaniti").length).toFixed(1)}`);
}

model: 28 kontrol, 25 gereksinim, 33 bag, 5 guven ilkesi

guven ilkesi        kontrol  isletimli  karsiladigi gerek.    donem kalemi  kalem/gerek.
guvenlik                 12         10                  11             968          88.0
erisilebilirlik           5          4                   3             736         245.3
isleme-butunlugu          4          4                   3             739         246.3
gizlilik                  4          3                   3             732         244.0
mahremiyet                3          1                   3              30          10.0

gereksinim durumu         sayi       yuzde     kontrol
isletim kaniti              19          76          29
yalniz beyan                 2           8           2
kanitsiz                     2           8           2
eslenmemis                   2           8           0
yalniz beyan: G07, G08
kanitsiz: G21, G23
eslenmemis: G24, G25

birden cok gereksinimi karsilayan kontrol 5/28: K01 (2), K04 (2), K06 (2), K14 (2), K26 (2)
tek gereksinim tasiyan kontrol 23; hicbir gereksinime baglanmayan 0
donemde uretilen kanit kalemi 3205; kontrol basina 114.5, karsilanan gereksinim basina 168.7

İkinci tablo dersin ana sonucudur. Yirmi beş gereksinimin yalnız on dokuzu bir dönem boyunca işlediği kanıtlanabilir durumdadır; kalan altısı üç ayrı nedenle kanıtsızdır ve bu üç neden birbirine hiç benzemez. G24 ve G25 eşlenmemiştir: matriste satırları vardır, hücreleri boştur — kimse bir kontrol önermemiştir. G21 ve G23 eşlenmiştir ama eşlendikleri kontroller hiç kanıt kalemi üretmiyor; matriste dolu görünürler ve denetimde çıplak kalırlar. G07 ve G08 ise sağlayıcı belgesine dayanıyor: tasarımı gösterilebilir, dönem boyunca işlediği gösterilemez.

Bu üçlü ayrım, matrisi “kaç hücre dolu” diye okumanın neden yanıltıcı olduğunu söylüyor. Otuz üç bağın dördü — G21, G22 ve G23’ün K26 ve K28 bağları — hiçbir kanıt üretmiyor. Doluluk oranına bakılırsa yirmi beş gereksinimin yirmi üçü eşlenmiştir (yüzde 92); işletim kanıtına bakılırsa on dokuzu karşılanmıştır (yüzde 76). Eşleme bir iddiadır; onu kanıta çeviren kalem ayrı sayılmalıdır.

Kaldıraç satırı ikinci gözlemi veriyor: yirmi sekiz kontrolün yalnız beşi birden çok gereksinimi karşılıyor, yirmi üçü tek gereksinim taşıyor. Kaldıraçlı kontroller kanıt üretiminde ölçek kazandırır — K01 tek başına iki gereksinime yetiyor. Ama beşinci kaldıraçlı kontrol K26’dır ve hiç kanıt üretmez: iki gereksinimi birden kanıtsız bırakır. Kaldıraç, kontrolün işlemesi koşuluyla değerlidir; işlemeyen bir kaldıraçlı kontrol hatanın yayılma çarpanıdır.

Kanıt Yükü ve Kritik Kontrol

// matris/kanit.mjs — matristen kanit yuku, kritik kontrol ve iki siralama cikarilir.
import { KONTROL, GEREKSINIM, ILKE, isletim, durum, gen } from "./eslem.mjs";

const ORNEK_UST = 25;    // denetci bir kontrolden en cok 25 kalem inceler (kurgu)
const DERLEME = 0.25;    // incelenen kalem basina 0,25 kisi-saat derleme (kurgu)

// Bir kontrol duserse hangi gereksinimler isletim kanitini yitirir
const dususEtkisi = (kod) => GEREKSINIM.filter((g) => durum(g) === "isletim kaniti" &&
  g.kontrol.filter(isletim).every((k) => k === kod));
const kritik = Object.keys(KONTROL).map((k) => ({ k, g: dususEtkisi(k) }))
  .filter((x) => x.g.length > 0);

// Paylasilan kontrolun kanit yuku, karsiladigi gereksinimlere bolunur.
const gerekSay = (kod) => GEREKSINIM.filter((g) => g.kontrol.includes(kod)).length || 1;
const yuk = (g) => g.kontrol.filter(isletim).reduce((a, k) => a + KONTROL[k].kalem / gerekSay(k), 0);
const TOPLAM = GEREKSINIM.reduce((a, g) => a + yuk(g), 0);

const y = gen([40, 10, 12, 12, 10]);
console.log(`${GEREKSINIM.length} gereksinim, toplam kanit yuku ${TOPLAM.toFixed(0)} kalem/donem`);
console.log("\n" + y("en yuksek kanit yuku tasiyan gereksinim", "kontrol", "kalem", "pay %",
  "birikim %"));
let birikim = 0;
for (const g of [...GEREKSINIM].sort((a, b) => yuk(b) - yuk(a)).slice(0, 5)) {
  birikim += 100 * yuk(g) / TOPLAM;
  console.log(y(g.ad, g.kontrol.length, yuk(g).toFixed(0),
    (100 * yuk(g) / TOPLAM).toFixed(1), birikim.toFixed(1)));
}
const sifir = GEREKSINIM.filter((g) => yuk(g) === 0);
console.log(`\nhic kanit yuku uretmeyen gereksinim ${sifir.length}: ` +
  `${sifir.map((g) => g.kod).join(", ")}`);

// Iki siralama: kontrol sayisina gore ve kanit yukune gore
const sK = [...GEREKSINIM].sort((a, b) => b.kontrol.length - a.kontrol.length ||
  a.kod.localeCompare(b.kod)).map((g) => g.kod);
const sY = [...GEREKSINIM].sort((a, b) => yuk(b) - yuk(a) || a.kod.localeCompare(b.kod))
  .map((g) => g.kod);
const ortak = sY.slice(0, 5).filter((k) => sK.slice(0, 5).includes(k));
console.log(`kontrol sayisina gore ilk bes: ${sK.slice(0, 5).join(", ")}`);
console.log(`kanit yukune gore ilk bes  : ${sY.slice(0, 5).join(", ")}`);
console.log(`ortak: ${ortak.length}/5`);

// Kritik kontrol ve denetci is yuku
console.log(`\nduserse en az bir gereksinimi kanitsiz birakan kontrol ${kritik.length}/` +
  `${Object.keys(KONTROL).length}; ${kritik.filter((x) => gerekSay(x.k) === 1).length} tanesi ` +
  `zaten tek gereksinim tasiyan kontrollerdir`);
const tekDayanak = GEREKSINIM.filter((g) => g.kontrol.filter(isletim).length === 1);
console.log(`tek isletim kontroluyle ayakta duran gereksinim ${tekDayanak.length}/` +
  `${GEREKSINIM.length}: ${tekDayanak.map((g) => g.kod).join(", ")}`);

const z = gen([18, 12, 13, 13, 14]);
console.log("\n" + z("guven ilkesi", "uretilen", "incelenen", "inceleme %", "kisi-saat"));
for (const i of ILKE) {
  const kume = Object.values(KONTROL).filter((k) => k.ilke === i);
  const ure = kume.reduce((a, k) => a + k.kalem, 0);
  const inc = kume.reduce((a, k) => a + Math.min(ORNEK_UST, k.kalem), 0);
  console.log(z(i, ure, inc, ure ? (100 * inc / ure).toFixed(1) : "-",
    (inc * DERLEME).toFixed(1)));
}
const ure = Object.values(KONTROL).reduce((a, k) => a + k.kalem, 0);
const inc = Object.values(KONTROL).reduce((a, k) => a + Math.min(ORNEK_UST, k.kalem), 0);
console.log(`toplam: ${ure} kalem uretiliyor, ${inc} kalem inceleniyor (%` +
  `${(100 * inc / ure).toFixed(1)}), ${(inc * DERLEME).toFixed(1)} kisi-saat derleme`);

25 gereksinim, toplam kanit yuku 3201 kalem/donem

en yuksek kanit yuku tasiyan gereksinim    kontrol       kalem       pay % birikim %
G04 uc nokta korumasinin surekliligi             2         391        12.2      12.2
G12 verinin kaybolmamasi                         2         367        11.5      23.7
G13 hizmetin kesintisiz surmesi                  2         365        11.4      35.1
G15 girdinin dogrulanmasi                        1         365        11.4      46.5
G19 saklama suresine uyulmasi                    1         365        11.4      57.9

hic kanit yuku uretmeyen gereksinim 6: G07, G08, G21, G23, G24, G25
kontrol sayisina gore ilk bes: G01, G02, G04, G12, G13
kanit yukune gore ilk bes  : G04, G12, G13, G15, G19
ortak: 3/5

duserse en az bir gereksinimi kanitsiz birakan kontrol 13/28; 11 tanesi zaten tek gereksinim tasiyan kontrollerdir
tek isletim kontroluyle ayakta duran gereksinim 13/25: G03, G05, G06, G09, G10, G11, G13, G15, G17, G18, G19, G20, G22

guven ilkesi          uretilen    incelenen   inceleme %     kisi-saat
guvenlik                   968          173         17.9          43.3
erisilebilirlik            736           56          7.6          14.0
isleme-butunlugu           739           87         11.8          21.8
gizlilik                   732           52          7.1          13.0
mahremiyet                  30           25         83.3           6.3
toplam: 3205 kalem uretiliyor, 393 kalem inceleniyor (%12.3), 98.3 kisi-saat derleme

Kanıt yükü beş gereksinimde yoğunlaşıyor: yirmi beş gereksinimin beşi toplam yükün yüzde 57,9’unu taşıyor. Ortak yanları, günlük çalışan bir kontrole bağlı olmalarıdır — uç nokta durumu, yedek alma, kapasite izleme, girdi doğrulama ve yaşam döngüsü koşumu yılda 365 kalem üretir. Buna karşılık hiç yük üretmeyen altı gereksinim, yukarıdaki altı kanıtsız gereksinimin tam olarak kendisidir. Kanıt yükü sıfır olan gereksinim ucuz değildir; karşılanmamıştır. Bir uyum bütçesi yalnız üretilen kalem sayısına bakarak dağıtılırsa, bu altı satır hiç görünmez.

İki sıralamanın ilk beşi yalnız üç üyede örtüşüyor. Kontrol sayısına göre sıralamak G01 ve G02’yi öne alır — üç ve iki kontrolle en çok “kapsanmış” görünen gereksinimlerdir. Kanıt yüküne göre sıralamak ise G15 ve G19’u öne alır; ikisinin de tek kontrolü vardır, ama o tek kontrol dönemde 365 kalem üretir. Kontrol sayısı bir kapsama ölçüsüdür, kanıt yükü bir maliyet ölçüsüdür ve ikisi aynı listeyi farklı dizer.

Kritik kontrol sayısı üçüncü sonucu veriyor: yirmi sekiz kontrolün on üçü düşerse en az bir gereksinim kanıtsız kalır ve bunların on biri zaten tek gereksinim taşıyan kontrollerdir. Yani kırılganlık, kaldıraçlı kontrollerde değil, yedeksiz kontrollerde toplanmıştır: on üç gereksinim tek bir işletim kontrolünün üzerinde durur. Kaldıraçlı bir kontrolü kaybetmek genellikle bir gereksinimi düşürmez, çünkü yanında başka kontrol vardır.

Son tablo denetimin iş yükünü veriyor. Dönemde 3.205 kanıt kalemi üretiliyor, denetçi bunların yüzde 12,3’ünü — 393 kalemini — inceliyor ve 98,3 kişi-saat derleme gerektiriyor. Örneklem üst sınırı yüzünden yüksek hacimli kontroller oransal olarak daha az inceleniyor: erişilebilirlikte oran yüzde 7,6, mahremiyette yüzde 83,3. Bu, kanıt üretmenin asıl bedelinin denetlenmek olmadığını gösteriyor — üretilen 3.205 kalemin 2.812’si hiç okunmadan saklanır, ama gerektiğinde gösterilebilir olması için yine de üretilmek ve saklanmak zorundadır.

Özet

• Denetim kontrol kümesi tasarımı değil, bir dönem boyunca işlemeyi kanıtlar; sağlayıcı belgesi tasarımı gösterir, dönem boyunca işlediğini göstermez.
• Yirmi beş gereksinimin on dokuzu işletim kanıtı taşıyor; kalan altısı üç ayrı nedenle kanıtsız: ikisi hiç eşlenmemiş, ikisi eşlenip hiç kanıt üretmiyor, ikisi yalnız beyana dayanıyor.
• Doluluk oranı yüzde 92, işletim kanıtı oranı yüzde 76’dır: eşleme bir iddiadır ve onu kanıta çeviren kalem ayrı sayılmalıdır.
• Yirmi sekiz kontrolün beşi birden çok gereksinimi karşılıyor; ama biri hiç kanıt üretmediği için iki gereksinimi birden kanıtsız bırakıyor — kaldıraç ancak kontrol işliyorsa değerlidir.
• Kırılganlık yedeksiz kontrollerdedir: on üç kontrol düşerse bir gereksinim kanıtsız kalır ve on üç gereksinim tek işletim kontrolünün üzerinde durur.
• Kanıt yükünün yüzde 57,9’u beş gereksinimde toplanıyor; hiç yük üretmeyen altı gereksinim ise tam olarak kanıtsız olanlardır. Dönemde 3.205 kalem üretiliyor, yüzde 12,3’ü inceleniyor.

Sonraki Adım

Bu dersin matrisi gereksinimleri kaynaklarından bağımsız aldı: her satır bir cümleydi ve nereden geldiği sorulmadı. Gereksinimlerin bir bölümü ise kurumun ne yaptığından değil, hangi veriye dokunduğundan doğar. Ödeme kartı verisini işleyen bir sistem, sağlık verisini tutan bir sistem ve kişisel veriyi saklayan bir sistem, başka hiçbir farkları olmasa bile farklı kontrol listeleri taşır.

Sonraki ders gereksinimi veri türüne bağlar: her tür kaç ek kontrol getiriyor, aynı sistemde iki tür birden bulunduğunda listeler nasıl birikiyor ve kapsamı daraltmanın en sert biçimi — veriyi hiç tutmamak — kaç kontrolü ortadan kaldırıyor. Ortadan kaldırılamayan kalan kontroller de sayılacak.