---
title: 'Konak Tabanlı Güvenlik Duvarı ve Önleme'
source: 'https://academia.sh/tr/kurslar/uc-nokta-guvenligi/konak-tabanli-guvenlik-duvari'
course: 'Uç Nokta ve Sistem Sertleştirme'
language: tr
updated: '2026-08-17T18:08:35+00:00'
license: 'CC BY-SA 4.0'
---

# Konak Tabanlı Güvenlik Duvarı ve Önleme

432 uçlu bir modelde 729.252 bağlantı yolu sayılır ve bölge sınırında duran kuralın hiç görmediği 290.772 bölge içi yol ayrılır: on iki kalemlik konak tabanlı izin listesinin kapattığı yol, açık bırakmak zorunda kaldığı eşler arası akış, listeye yazılmadığı için kesilen iki meşru akış, reddedilen yolun kayda düşmesi ve ele geçen bir uçtan tek atlamada ulaşılan uç sayısı.

Önceki ders uçtaki telemetriyi ölçtü ve uçlar arasındaki bağlantıyı gören tek kaynağın kapsam
gerekçesiyle savunulamadığını gösterdi. Bu ders o bağlantının kendisini sayar. Ağın sınırında duran
kutu başka bir kursta ölçülmüştü ve orada bölgeler arasındaki akış sayılmıştı; o ölçümün yapısal
bir kör noktası vardı: aynı bölgedeki iki ucun arasındaki bağlantı sınırdan hiç geçmez, dolayısıyla
sınırdaki hiçbir kural onu ne görür ne değerlendirir.

Ölçülen üç sayı var. Birincisi bölge içinde kaç bağlantı yolu olduğudur — çevre kuralının hiç
görmediği küme budur. İkincisi konak tarafında duran bir filtrenin bunların kaçını kapattığıdır.
Üçüncüsü kapatmanın bedelidir: kaç meşru akış listeye yazılmak zorunda, listeye yazılmayan kaç akış
kesiliyor ve kapatılamayan yol hangileri. Bu derste hiçbir saldırı adımı yazılmadı; sayılan şey
yolun kendisidir.

- **UK19.** 432 uç, dört uç sınıfı, on sekiz dinleyen hizmet tanımı ve on iki meşru akış kurgusal
  bölgesel ölçüm ağına aittir. Ölçülen şey `node` ile kurulan modeldir.
- **UK20.** Yol tanımı sabittir: bir yol, yönlü bir uç çifti ile hedefte dinleyen bir hizmetin
  bileşimidir. Aynı hizmete iki farklı yoldan ulaşmak modelde tek yoldur.
- **UK21.** Bir uç sınıfındaki bütün uçlar aynı hizmetleri dinler. Gerçekte uçlar sapar ve sapma
  yol sayısını büyütür; sabit sınıf sayıyı olduğundan küçük gösterir.
- **UK22.** İzin listesi uç **sınıfı** düzeyinde yazıldı. Uç adresine yazılmış bir liste daha çok
  yol kapatır ve bakım kalemini uç sayısıyla çarpar.
- **UK23.** Konak tarafındaki kural kümesinin uçta değiştirilemediği varsayıldı; kuralı kaldırabilen
  bir yetki varsa bu ölçüm geçersizdir.
- **UK24.** Bölge sınırındaki kural yalnız bölgeler arası yolu değerlendirir. Bu sınırın tanımıdır;
  o kuralın kapattığı yol burada girdi olarak alınıyor.

## Sınırın Görmediği Küme

```js
// ag.mjs — uc siniflari, dinleyen hizmetler ve mesru ic akislar; model, gercek ag degil
// sinif -> [bolge, uc sayisi, dinleyen hizmetler]
export const SINIF = {
  'saha dizustu': ['saha', 120, ['uzak destek', 'dosya paylasimi', 'yazici kesfi']],
  'sube ucu': ['sube', 240, ['uzak destek', 'dosya paylasimi', 'yazici kesfi', 'yerel onbellek']],
  'toplayici': ['toplayici', 60, ['uzak destek', 'olcum alimi', 'durum sorgusu', 'dosya paylasimi', 'yonetim arayuzu']],
  'merkez sunucu': ['merkez', 12, ['uzak destek', 'olcum alimi', 'durum sorgusu', 'veritabani', 'yonetim arayuzu', 'rapor arayuzu']],
};
export const AD = Object.keys(SINIF);
export const bolge = (s) => SINIF[s][0];
export const sayi = (s) => SINIF[s][1];
export const hizmet = (s) => SINIF[s][2];
// [kaynak sinifi, hedef sinifi, hizmet] — listeye yazilmis mesru akislar
export const IZIN = [
  ['toplayici', 'merkez sunucu', 'olcum alimi'],
  ['merkez sunucu', 'toplayici', 'durum sorgusu'],
  ['saha dizustu', 'merkez sunucu', 'rapor arayuzu'],
  ['sube ucu', 'merkez sunucu', 'rapor arayuzu'],
  ['merkez sunucu', 'saha dizustu', 'uzak destek'],
  ['merkez sunucu', 'sube ucu', 'uzak destek'],
  ['merkez sunucu', 'toplayici', 'uzak destek'],
  ['sube ucu', 'sube ucu', 'yerel onbellek'],
  ['sube ucu', 'sube ucu', 'yazici kesfi'],
  ['saha dizustu', 'saha dizustu', 'dosya paylasimi'],
  ['toplayici', 'toplayici', 'dosya paylasimi'],
  ['merkez sunucu', 'merkez sunucu', 'veritabani'],
];
// listeye yazilmamis, sonradan ortaya cikan mesru akislar
export const UNUTULAN = [
  ['sube ucu', 'saha dizustu', 'dosya paylasimi'],
  ['saha dizustu', 'toplayici', 'durum sorgusu'],
];
export const cift = (a, b) => (a === b ? sayi(a) * (sayi(a) - 1) : sayi(a) * sayi(b));
export function yollar() {
  const l = [];
  for (const a of AD) for (const b of AD) for (const h of hizmet(b)) l.push([a, b, h, cift(a, b)]);
  return l;
}
export const ici = (y) => bolge(y[0]) === bolge(y[1]);
export const izinli = (y, liste) => liste.some((i) => i[0] === y[0] && i[1] === y[1] && i[2] === y[2]);
export const topla = (l) => l.reduce((a, y) => a + y[3], 0);
```

```js
// kosum1.mjs — bolge ici ve bolgeler arasi yol sayimi: cevre kuralinin gordugu ve hic gormedigi
import { SINIF, AD, sayi, hizmet, yollar, ici, topla } from './ag.mjs';

const Y = yollar(), N = AD.reduce((a, s) => a + sayi(s), 0);
console.log(`${N} uc, ${AD.length} uc sinifi, ${AD.reduce((a, s) => a + hizmet(s).length, 0)} dinleyen hizmet tanimi\n`);
console.log(`${'uc sinifi'.padEnd(14)} ${'bolge'.padStart(9)} ${'uc'.padStart(4)} ${'hizmet'.padStart(6)} ` +
  `${'bolge ici yol'.padStart(13)} ${'bolgeler arasi'.padStart(14)}`);
for (const s of AD) {
  const hedef = Y.filter((y) => y[1] === s);
  console.log(`${s.padEnd(14)} ${SINIF[s][0].padStart(9)} ${String(sayi(s)).padStart(4)} ${String(hizmet(s).length).padStart(6)} ` +
    `${String(topla(hedef.filter(ici))).padStart(13)} ${String(topla(hedef.filter((y) => !ici(y)))).padStart(14)}`);
}
const [ic, dis] = [topla(Y.filter(ici)), topla(Y.filter((y) => !ici(y)))];
console.log(`${'toplam'.padEnd(14)} ${''.padStart(9)} ${String(N).padStart(4)} ${''.padStart(6)} ` +
  `${String(ic).padStart(13)} ${String(dis).padStart(14)}`);
console.log(`\ntoplam yol            : ${ic + dis}`);
console.log(`cevre kuralinin gordugu: ${dis} (%${(dis * 100 / (ic + dis)).toFixed(1)})`);
console.log(`cevre kuralinin hic gormedigi: ${ic} (%${(ic * 100 / (ic + dis)).toFixed(1)})`);
```

```
432 uc, 4 uc sinifi, 18 dinleyen hizmet tanimi

uc sinifi          bolge   uc hizmet bolge ici yol bolgeler arasi
saha dizustu        saha  120      3         42840         112320
sube ucu            sube  240      4        229440         184320
toplayici      toplayici   60      5         17700         111600
merkez sunucu     merkez   12      6           792          30240
toplam                    432               290772         438480

toplam yol            : 729252
cevre kuralinin gordugu: 438480 (%60.1)
cevre kuralinin hic gormedigi: 290772 (%39.9)
```

Toplam yedi yüz yirmi dokuz bin iki yüz elli iki yolun iki yüz doksan bin yedi yüz yetmiş ikisi
bölge içinde kalıyor: yüzde otuz dokuz virgül dokuz. Bu küme sınırdaki hiçbir kural tarafından
değerlendirilmiyor — reddedilmiyor, izin verilmiyor, kaydedilmiyor. Sınır kuralı bu yollara "izin
verir" bile denemez; onları hiç görmez.

Dağılım da tek yönlü değil. Bölge içi yolun iki yüz yirmi dokuz bin dört yüz kırkı şube
bölgesinden geliyor; nedeni yol tanımının kendisinde, çünkü yol sayısı uç sayısının karesiyle
büyür. Merkez bölgesi en çok hizmeti dinliyor ve bölge içi yolu yalnızca yedi yüz doksan iki.

## İzin Listesinin Kapattığı ve Kestiği

```js
// kosum2.mjs — konak tabanli varsayilan reddet: kapanan yol, kalan yol ve kesilen mesru is
import { AD, IZIN, UNUTULAN, sayi, yollar, ici, izinli, topla } from './ag.mjs';

const Y = yollar(), IC = Y.filter(ici), DIS = Y.filter((y) => !ici(y));
const kur = (liste) => ({
  ic: topla(IC.filter((y) => izinli(y, liste))), dis: topla(DIS.filter((y) => izinli(y, liste))),
  kesilen: UNUTULAN.filter((u) => !liste.some((i) => i.join() === u.join())),
});
console.log(`${'yerlesim'.padEnd(30)} ${'bolge ici kalan'.padStart(15)} ${'bolge disi kalan'.padStart(16)} ` +
  `${'toplam kalan'.padStart(12)} ${'kesilen mesru akis'.padStart(18)}`);
for (const [ad, liste] of [['konak filtresi yok', Y.map((y) => [y[0], y[1], y[2]])],
  ['izin listesi (12 kalem)', IZIN], ['+ unutulan iki akis eklendi', [...IZIN, ...UNUTULAN]]]) {
  const r = kur(liste);
  console.log(`${ad.padEnd(30)} ${String(r.ic).padStart(15)} ${String(r.dis).padStart(16)} ` +
    `${String(r.ic + r.dis).padStart(12)} ${String(r.kesilen.length).padStart(18)}`);
}
const r = kur(IZIN), t = topla(IC), d = topla(DIS);
console.log(`\nbolge ici yolun kapanani : ${t - r.ic}/${t} (%${((t - r.ic) * 100 / t).toFixed(1)})`);
console.log(`bolgeler arasi kapanani  : ${d - r.dis}/${d} (%${((d - r.dis) * 100 / d).toFixed(1)})`);
console.log(`cevrenin hic gormedigi kumede kapanan yol: ${t - r.ic}`);
console.log(`kayda dusen reddedilen yol turu: ${IC.filter((y) => !izinli(y, IZIN)).length} ic + ` +
  `${DIS.filter((y) => !izinli(y, IZIN)).length} dis = ${Y.filter((y) => !izinli(y, IZIN)).length}`);
console.log(`\nizin listesinde acik kalan bolge ici akislar:`);
for (const y of IC.filter((y) => izinli(y, IZIN)))
  console.log(`  ${`${y[0]} -> ${y[1]}`.padEnd(32)} ${y[2].padEnd(16)} ${String(y[3]).padStart(6)} yol`);
console.log(`\nlisteye yazilmadigi icin kesilen mesru akislar:`);
for (const u of kur(IZIN).kesilen) {
  const y = Y.find((y) => y[0] === u[0] && y[1] === u[1] && y[2] === u[2]);
  console.log(`  ${`${u[0]} -> ${u[1]}`.padEnd(32)} ${u[2].padEnd(16)} ${String(y[3]).padStart(6)} yol`);
}

console.log(`\n${'ele gecen uc sinifi'.padEnd(16)} ${'filtresiz'.padStart(9)} ${'izin listesiyle'.padStart(15)} ${'kapanan'.padStart(7)}`);
for (const a of AD) {
  const hedefler = AD.filter((b) => IZIN.some((i) => i[0] === a && i[1] === b));
  const ulasan = hedefler.reduce((t, b) => t + (a === b ? sayi(b) - 1 : sayi(b)), 0);
  const N = AD.reduce((t, s) => t + sayi(s), 0) - 1;
  console.log(`${a.padEnd(16)} ${String(N).padStart(9)} ${String(ulasan).padStart(15)} ${String(N - ulasan).padStart(7)}`);
}
```

```
yerlesim                       bolge ici kalan bolge disi kalan toplam kalan kesilen mesru akis
konak filtresi yok                      290772           438480       729252                  0
izin listesi (12 kalem)                 132672            10800       143472                  2
+ unutulan iki akis eklendi             132672            46800       179472                  0

bolge ici yolun kapanani : 158100/290772 (%54.4)
bolgeler arasi kapanani  : 427680/438480 (%97.5)
cevrenin hic gormedigi kumede kapanan yol: 158100
kayda dusen reddedilen yol turu: 13 ic + 47 dis = 60

izin listesinde acik kalan bolge ici akislar:
  saha dizustu -> saha dizustu     dosya paylasimi   14280 yol
  sube ucu -> sube ucu             yazici kesfi      57360 yol
  sube ucu -> sube ucu             yerel onbellek    57360 yol
  toplayici -> toplayici           dosya paylasimi    3540 yol
  merkez sunucu -> merkez sunucu   veritabani          132 yol

listeye yazilmadigi icin kesilen mesru akislar:
  sube ucu -> saha dizustu         dosya paylasimi   28800 yol
  saha dizustu -> toplayici        durum sorgusu      7200 yol

ele gecen uc sinifi filtresiz izin listesiyle kapanan
saha dizustu           431             131     300
sube ucu               431             251     180
toplayici              431              71     360
merkez sunucu          431             431       0
```

On iki kalemlik bir liste bölge içi yolun yüzde elli dört virgül dördünü kapatıyor. Kalan yüz otuz
iki bin altı yüz yetmiş ikinin nereden geldiği alt listede yazıyor ve tek bir satırda toplanıyor:
şube uçlarının birbirine açtığı yazıcı keşfi ile yerel önbellek akışları, ikisi birlikte yüz on
dört bin yedi yüz yirmi yol. Bunlar meşru akışlardır ve listeden çıkarıldıklarında iki yüz kırk uç
birbirini görmeyi bırakır. Eşler arası meşru trafiği olan bir bölgede konak tabanlı filtrelemenin
kapatabileceği yolun bir tavanı vardır ve o tavanı belirleyen şey saldırı değil, işin kendisidir.

Bölgeler arası sütun tersini gösteriyor: yüzde doksan yedi virgül beş kapanıyor. Fark, bölgeler
arasında meşru akış sayısının azlığındandır — yedi kalem. Aynı liste iki kümede bu kadar farklı
davranıyorsa, konak tabanlı filtrelemenin değeri sınırdaki kuralın **yerine geçmesinde** değil,
sınırın hiç bakmadığı kümede bir şey yapmasındadır: yüz elli sekiz bin yüz yol, sınırdaki hiçbir
kural değişmeden kapanıyor.

Üçüncü satır bedelin biçimini veriyor. İzin listesi yazıldığında iki meşru akış listede yoktu ve
kesildi: şube ucundan saha dizüstüne dosya paylaşımı ve saha dizüstünden toplayıcıya durum
sorgusu. İkisi eklendiğinde bölge içi kalan hiç değişmiyor — ikisi de bölgeler arası — ama bölgeler
arası kalan on bin sekiz yüzden kırk altı bin sekiz yüze çıkıyor. İki kalem eklemek bölgeler arası
açık yolu dört katına çıkarıyor. Listeye yazılan her kalem böyle davranır ve bakımın asıl bedeli
budur: on iki kalemlik liste bir kereye mahsus bir iş değil, sürekli büyüyen bir envanterdir.

Reddedilen altmış yol türü ise ikinci sütuna, görünürlüğe yazılır. Konak tarafındaki filtre bu
dersteki tek katmandır ki aynı hamlede hem kapatıyor hem kaydediyor: reddettiği bağlantı denemesi
bir kayıt üretir ve o kayıt önceki dersin telemetri kaynaklarına eklenir. Kapatılan yol ile kayda
düşen yol burada aynı kümedir — kursta bu iki sütunun çakıştığı ender yerlerden biri.

Son tablo dersin en sert sayısını veriyor. Ele geçen bir toplayıcıdan tek atlamada ulaşılan uç
dört yüz otuz birden yetmiş bire, bir saha dizüstünden yüz otuz bire iniyor. Ele geçen bir merkez
sunucusundan ise dört yüz otuz bir uça ulaşılmaya devam ediyor ve kapanan sıfırdır. Neden açık:
uzak destek akışı merkezden üç uç sınıfının hepsine yazılıdır ve o akış kaldırılırsa uzaktan destek
diye bir iş kalmaz. Yönetim yolunun kendisi kapatılamaz; kapatılamayan yol da en azından görünür
kılınmalıdır.

## Her Kalem Ne Kadar Açıyor

Liste kalemleri eşit değildir. Boş bir listeden başlayıp kalemleri tek tek eklemek, her kalemin
kaç yol açtığını ve karşılığında kaç meşru akışı kurtardığını ayrı ayrı gösterir.

```js
// kosum3.mjs — liste buyudukce acilan yol: her kalem kac yol aciyor, kac mesru akisi kurtariyor
import { IZIN, UNUTULAN, yollar, ici, izinli, topla } from './ag.mjs';

const Y = yollar(), TAM = [...IZIN, ...UNUTULAN];
console.log(`${'liste kalemi'.padEnd(4)} ${'eklenen akis'.padEnd(46)} ${'actigi yol'.padStart(10)} ` +
  `${'kalan yol'.padStart(10)} ${'kesilen akis'.padStart(12)}`);
for (let n = 0; n <= TAM.length; n++) {
  const liste = TAM.slice(0, n);
  const kalan = topla(Y.filter((y) => izinli(y, liste)));
  const yeni = n === 0 ? 0 : kalan - topla(Y.filter((y) => izinli(y, TAM.slice(0, n - 1))));
  const ad = n === 0 ? '(bos liste: her sey reddedilir)' : `${TAM[n - 1][0]} -> ${TAM[n - 1][1]} / ${TAM[n - 1][2]}`;
  console.log(`${String(n).padEnd(4)} ${ad.padEnd(46)} ${String(yeni).padStart(10)} ${String(kalan).padStart(10)} ` +
    `${String(TAM.length - n).padStart(12)}`);
}
const ilkUc = topla(Y.filter((y) => izinli(y, TAM.slice(0, 3))));
console.log(`\nilk 3 kalem toplam yolun %${(ilkUc * 100 / topla(Y)).toFixed(2)}'sini aciyor`);
const ic = TAM.filter((i) => ici([i[0], i[1]]));
console.log(`bolge ici kalem sayisi: ${ic.length}/${TAM.length}; actiklari yol: ` +
  `${topla(Y.filter((y) => izinli(y, ic)))} (kalanin %${(topla(Y.filter((y) => izinli(y, ic))) * 100 / topla(Y.filter((y) => izinli(y, TAM)))).toFixed(1)}'i)`);
```

```
liste kalemi eklenen akis                                   actigi yol  kalan yol kesilen akis
0    (bos liste: her sey reddedilir)                         0          0           14
1    toplayici -> merkez sunucu / olcum alimi              720        720           13
2    merkez sunucu -> toplayici / durum sorgusu            720       1440           12
3    saha dizustu -> merkez sunucu / rapor arayuzu        1440       2880           11
4    sube ucu -> merkez sunucu / rapor arayuzu            2880       5760           10
5    merkez sunucu -> saha dizustu / uzak destek          1440       7200            9
6    merkez sunucu -> sube ucu / uzak destek              2880      10080            8
7    merkez sunucu -> toplayici / uzak destek              720      10800            7
8    sube ucu -> sube ucu / yerel onbellek               57360      68160            6
9    sube ucu -> sube ucu / yazici kesfi                 57360     125520            5
10   saha dizustu -> saha dizustu / dosya paylasimi      14280     139800            4
11   toplayici -> toplayici / dosya paylasimi             3540     143340            3
12   merkez sunucu -> merkez sunucu / veritabani           132     143472            2
13   sube ucu -> saha dizustu / dosya paylasimi          28800     172272            1
14   saha dizustu -> toplayici / durum sorgusu            7200     179472            0

ilk 3 kalem toplam yolun %0.39'sini aciyor
bolge ici kalem sayisi: 5/14; actiklari yol: 132672 (kalanin %73.9'i)
```

Eğri iki bölgeye ayrılıyor. İlk yedi kalem — bölgeler arası akışların hepsi — toplam on bin sekiz
yüz yol açıyor; on dört kalemin yarısı, kalan yolun yüzde altısını üretiyor. Sekizinci ve dokuzuncu
kalemler tek başına yüz on dört bin yedi yüz yirmi yol açıyor. İki kalem, öteki on ikinin toplamının
altı katını açıyor ve ikisi de aynı cümleyle savunulabilir: şube uçlarının birbirini görmesi
gerekiyor.

Kalem sayısıyla ölçülen bir liste bu yüzden yanıltıcıdır. On dört kalemin beşi bölge içidir ve
kalan yolun yüzde yetmiş üç virgül dokuzunu açar. Bir izin listesini gözden geçirmek kalemleri
saymak değil, her kalemin açtığı yolu yanına yazmaktır.

## Özet

- 432 uçlu modelde 729.252 bağlantı yolu var; 290.772'si (%39,9) bölge içindedir ve sınırdaki kural
  bu kümeyi ne reddeder ne kaydeder — hiç görmez.
- Bölge içi yolun %79'u tek bir bölgeden (şube) geliyor: yol sayısı uç sayısının karesiyle büyür,
  hizmet sayısıyla doğrusal büyür.
- 12 kalemlik konak tabanlı izin listesi bölge içi yolun %54,4'ünü (158.100 yol), bölgeler arası
  yolun %97,5'ini kapatıyor. Farkı yaratan, bölge içinde meşru eşler arası akış olmasıdır: şube
  uçlarının yazıcı keşfi ve yerel önbellek akışları tek başına 114.720 yol açık bırakır.
- Bedel iki kalemdir: listeye yazılmayan 2 meşru akış kesildi; eklendiklerinde bölgeler arası açık
  yol 10.800'den 46.800'e çıktı. Liste bir kerelik iş değil, her eklemede yüzeyi büyüten bir
  envanterdir.
- Reddedilen 60 yol türü aynı hamlede kayda düşüyor: konak tabanlı filtre kapatan ve görünür kılan
  sütunların çakıştığı ender katmandır.
- Ele geçen bir uçtan tek atlamada ulaşılan uç sayısı toplayıcıda 431'den 71'e, saha dizüstünde
  131'e iniyor; merkez sunucusunda 431'de kalıyor ve kapanan sıfırdır — uzak destek akışı
  kaldırılamaz.

## Sonraki Adım

Bu dersin izin listesi bir varsayıma dayanıyordu: kapatılan yolu kullanmak isteyen şeyin **kendine
ait** bir aracı olduğu. Listeye yazılı meşru akışlar zaten açıktı ve o akışları yürüten araçlar
uçta duruyordu. Uzak destek akışını yürüten aracın kendisi kötü niyetle çalıştırılırsa hiçbir kural
ihlal edilmez; hiçbir yol kapanmaz, hiçbir ret kaydı üretilmez. Sonraki dersin sorusu budur: uçtaki
yerleşik ve imzalı araçlardan kaçı aynı işi yapabiliyor, imza tabanlı bir kural bunları neden
birbirinden ayıramıyor ve üst süreç, komut deseni ve zamanlama gibi davranış bağlamları kaçını
ayırabiliyor.
