---
title: 'Güvenlik Duvarı Nesilleri'
source: 'https://academia.sh/tr/kurslar/ag-guvenligi/guvenlik-duvari-nesilleri'
course: 'Ağ Güvenliği'
language: tr
updated: '2026-08-17T18:08:39+00:00'
license: 'CC BY-SA 4.0'
---

# Güvenlik Duvarı Nesilleri

Sekiz akış sınıfının taşıdığı kırk sekiz iddia üç güvenlik duvarı neslinde koşturulur: paket filtreleyen kutu kaçını görüyor, durum bilgili kaçını, uygulama farkındalıklı kaçını kanıtlıyor, her nesil karşılığında kaç yeni kaleme bakmak zorunda ve şifreli akış kanıtlananın ne kadarını geri alıyor.

Önceki konu protokollerin taşıdığı iddiaları saydı ve bunların hepsi aynı düz ağda dolaşıyordu:
bir mesajın kaynak adresi, ait olduğu oturum ve arkasındaki özne yolun hiçbir noktasında
sınanmıyordu. Ağın ortasına bir sınır çizmenin ilk biçimi güvenlik duvarıdır. Sınırı çizmek tek
başına hiçbir iddiayı kanıtlamaz; sınırda duran kutu yalnız **gördüğü** alan üzerinde karar
verebilir.

Bu dersin sorusu kutuların karşılaştırılması değildir. Aynı akış kümesinde paket filtreleyen,
durum bilgili ve uygulama farkındalıklı güvenlik duvarının her biri kaç iddiayı görüyor, kaçını
kanıtlayabiliyor, kaçını kanıtsız kabul ediyor ve gördüğünü kanıtlayabilmek için kaç yeni kaleme
bakmak zorunda kalıyor. Kural yazımı, varsayılan reddet ve kural genişliği başka bir kursta
ölçüldü; buradaki eksen kuralın kendisi değil, kuralın dayandığı alanın kanıtlanabilir olup
olmadığıdır.

- **CS1.** Sekiz akış sınıfı, iddia türleri ve oturum sayıları kurgusal bölgesel ölçüm ağına
  aittir. Gerçek paket akmıyor; ölçülen şey `node` ile kurulan modeldir.
- **CS2.** İddia türü sekize indirgendi. Gerçek bir alışverişte alan sayısı çok daha büyüktür;
  kalem sayısını büyütür, nesiller arasındaki farkın yönünü değiştirmez.
- **CS3.** "Kanıtlar" burada dar anlamda kullanılıyor: kutunun elinde iddiayı sınayacak bir
  karşılık var demektir. Kriptografik kanıt ve sertifika doğrulaması bu kursun dışındadır.
- **CS4.** Durum kaydı sayısı dönemin eşzamanlı oturum toplamı alındı. Gerçekte tablo zaman
  aşımıyla boşalır; kayıt sayısını düşürür, tablonun bir kalem olduğunu değiştirmez.
- **CS5.** Sahte iddia sınıfları yalnız model olarak yazıldı; hiçbiri çalıştırılabilir biçimde
  verilmedi. Sayılan şey hangi neslin durdurduğudur.
- **CS6.** Uçtan uca şifreli akışta dışarıdan görünen tek uygulama iddiası sunucu adı sayıldı.

## İddia ve Nesil Modeli

Model iki şey tutuyor: her iddia türünün hangi nesilden itibaren görülebildiği ve hangi nesilden
itibaren kanıtlanabildiği. Bu ikisi aynı şey değildir; ayrımın kendisi dersin bütün iddiasıdır.
Hedef kapı numarasını paket filtreleyen kutu da görür, ama o numaranın arkasındaki hizmetin
gerçekten o hizmet olduğunu ancak akışı çözümleyen kutu sınayabilir.

```js
// nesil.mjs — akis kumesi ve uc guvenlik duvari neslinin gordugu/kanitlayabildigi iddia; model, gercek trafik degil
export const NESIL = ['paket', 'durum', 'uygulama'];
const D = (gorur, kanit) => ({ gorur, kanit });
export const IDDIA = {                       // iddia: hangi nesilden itibaren gorulur / kanitlanabilir
  'kaynak-adres': D('paket', 'paket'),       // kanit: geldigi yonun beklenen adres blogu
  'hedef-hizmet': D('paket', 'uygulama'),    // kapi numarasi hizmetin kendisini kanitlamaz
  'yon-baslangici': D('paket', 'durum'),     // kanit: durum tablosunda kayit var mi
  'oturum-uyeligi': D('durum', 'durum'),
  'sunucu-adi': D('uygulama', 'uygulama'),
  'istek-yolu': D('uygulama', 'uygulama'),
  'icerik-turu': D('uygulama', 'uygulama'),
  'ozne-kimligi': D('uygulama', null),       // tasinan kimlik; ag katmani kanitlayamaz
};
const sr = (n) => NESIL.indexOf(n);
export const gorur = (n, i) => sr(n) >= sr(IDDIA[i].gorur);
export const kanitlar = (n, i) => IDDIA[i].kanit !== null && sr(n) >= sr(IDDIA[i].kanit);
const T = Object.keys(IDDIA);
const k = (...a) => T.filter((_, i) => a[i]);
// [ad, tasidigi iddialar, donemdeki eszamanli oturum] — kurgu bolgesel olcum agi
export const AKIS = [
  ['sayac -> toplayici', k(1, 1, 1, 1, 0, 0, 0, 0), 41200],
  ['toplayici -> dogrulayici', k(1, 1, 1, 1, 1, 1, 0, 0), 8600],
  ['sube -> fatura arayuzu', k(1, 1, 1, 1, 1, 1, 0, 1), 12400],
  ['saha terminali -> api', k(1, 1, 1, 1, 1, 1, 1, 1), 5100],
  ['yonetim -> kabuk', k(1, 1, 1, 1, 0, 0, 0, 0), 310],
  ['dis -> genel arayuz', k(1, 1, 1, 1, 1, 1, 1, 1), 26400],
  ['uygulama -> paket deposu', k(1, 1, 1, 1, 1, 1, 0, 0), 90],
  ['yedek -> dis depo', k(1, 1, 1, 1, 1, 0, 0, 0), 12],
];
export const TOPLAM = AKIS.reduce((a, [, i]) => a + i.length, 0);
export const OTURUM = AKIS.reduce((a, x) => a + x[2], 0);
// Ucdan uca sifreli akislar: disaridan gorulebilen tek uygulama iddiasi sunucu adidir
export const SIFRELI = ['sube -> fatura arayuzu', 'saha terminali -> api', 'dis -> genel arayuz',
  'uygulama -> paket deposu', 'yedek -> dis depo'];
const kapali = (ad, i) => SIFRELI.includes(ad) && IDDIA[i].gorur === 'uygulama' && i !== 'sunucu-adi';
export function say(n, sifre = false) {      // bir nesil icin: gorulen, kanitlanan, kanitsiz kabul
  let gor = 0, kan = 0;
  for (const [ad, iddia] of AKIS) for (const i of iddia) {
    if (sifre && kapali(ad, i)) continue;
    if (gorur(n, i)) gor++;
    if (kanitlar(n, i)) kan++;
  }
  return { gor, kan, kanitsiz: TOPLAM - kan, gormedigi: TOPLAM - gor };
}
export const SIFRELI_OTURUM = AKIS.filter((a) => SIFRELI.includes(a[0])).reduce((a, x) => a + x[2], 0);
export const KALEM = {                       // her neslin bakmak zorunda oldugu kalem
  paket: { 'kural satiri': 34, 'durum kaydi': 0, 'akis tamponu': 0, 'protokol cozumleyici': 0 },
  durum: { 'kural satiri': 34, 'durum kaydi': OTURUM, 'akis tamponu': 0, 'protokol cozumleyici': 0 },
  uygulama: { 'kural satiri': 34, 'durum kaydi': OTURUM, 'akis tamponu': OTURUM, 'protokol cozumleyici': 6 },
};
// Iddia sahteciligi siniflari model olarak yazildi; hicbiri calistirilabilir bicimde verilmedi.
export const SINIF = [                       // [ad, sahte iddia, o iddiayi kanitlayan en dusuk nesil]
  ['kaynak adresi baska bolgeden', 'kaynak-adres', 'paket'],
  ['kurulmus oturum gibi gorunen paket', 'yon-baslangici', 'durum'],
  ['izinli kapida baska protokol', 'hedef-hizmet', 'uygulama'],
  ['izinli akista baska sunucu adi', 'sunucu-adi', 'uygulama'],
  ['istekte tasinan ozne basligi', 'ozne-kimligi', null],
];
export const durduran = (s) => s[2] === null ? '-' : s[2];
```

Akış listesindeki her satır bir sınıfı, taşıdığı iddia kümesini ve dönemdeki eşzamanlı oturum
sayısını tutuyor. İddia kümesi sekiz basamaklı bir maskeyle yazılıyor; sıfır o alanın o akışta hiç
bulunmadığı demektir. Sayaç toplayıcısına giden akış yalnız dört alan taşır, çünkü uygulama
katmanında sunucu adı da istek yolu da yoktur — ikili bir akıştır. Şube ağından faturalama
arayüzüne giden istek ise yedi alan taşır ve bunlardan biri, isteğin arkasındaki öznenin kim
olduğunu söyleyen başlıktır.

## Kanıtlanan ve Kanıtsız Kabul Edilen

```js
// kosum1.mjs — sekiz akis sinifinin tasidigi iddia sayilir, uc nesil ayni kume uzerinde kosturulur
import { NESIL, AKIS, TOPLAM, IDDIA, gorur, kanitlar, say } from './nesil.mjs';

console.log(`${'akis sinifi'.padEnd(25)} ${'iddia'.padStart(5)}` + NESIL.map((n) => `${n} gor/kanit`.padStart(19)).join(''));
for (const [ad, iddia] of AKIS)
  console.log(`${ad.padEnd(25)} ${String(iddia.length).padStart(5)}` +
    NESIL.map((n) => `${iddia.filter((i) => gorur(n, i)).length}/${iddia.filter((i) => kanitlar(n, i)).length}`.padStart(19)).join(''));
console.log(`\nsekiz akis sinifi ${TOPLAM} iddia tasiyor\n`);
console.log(`${'nesil'.padEnd(10)} ${'goremiyor'.padStart(9)} ${'goruyor'.padStart(7)} ${'kanitliyor'.padStart(10)} ${'kanitsiz kabul'.padStart(14)}`);
for (const n of NESIL) {
  const s = say(n);
  console.log(`${n.padEnd(10)} ${String(s.gormedigi).padStart(9)} ${String(s.gor).padStart(7)} ${String(s.kan).padStart(10)} ${String(s.kanitsiz).padStart(14)}`);
}
const hic = Object.keys(IDDIA).filter((i) => !NESIL.some((n) => kanitlar(n, i)));
console.log(`\nhicbir neslin kanitlayamadigi tur: ${hic.join(', ')} — ${AKIS.filter(([, i]) => i.includes(hic[0])).length} akis sinifinda`);
```

```
akis sinifi               iddia    paket gor/kanit    durum gor/kanit uygulama gor/kanit
sayac -> toplayici            4                3/1                4/3                4/4
toplayici -> dogrulayici      6                3/1                4/3                6/6
sube -> fatura arayuzu        7                3/1                4/3                7/6
saha terminali -> api         8                3/1                4/3                8/7
yonetim -> kabuk              4                3/1                4/3                4/4
dis -> genel arayuz           8                3/1                4/3                8/7
uygulama -> paket deposu      6                3/1                4/3                6/6
yedek -> dis depo             5                3/1                4/3                5/5

sekiz akis sinifi 48 iddia tasiyor

nesil      goremiyor goruyor kanitliyor kanitsiz kabul
paket             24      24          8             40
durum             16      32         24             24
uygulama           0      48         45              3

hicbir neslin kanitlayamadigi tur: ozne-kimligi — 3 akis sinifinda
```

İlk tablonun en anlatıcı sütunu paket filtreleyen kutununkidir: akış sınıfı ne taşırsa taşısın
sayı değişmiyor, her satırda üç görülüyor ve bir kanıtlanıyor. Sekiz iddia taşıyan bir akışla dört
iddia taşıyan bir akış o kutu için aynı şeydir; aradaki dört alan onun bakış alanının dışındadır.
Kanıtladığı tek iddia kaynak adresidir ve bunu ancak paketin geldiği yönün beklenen adres bloğunu
bildiği için yapabilir. Kalan iki alanı, hedef kapıyı ve yön başlangıcını, gördüğü hâlde
sınayamaz.

Toplamda kırk sekiz iddianın kırkı paket filtreleyen kutuda kanıtsız kabul ediliyor. Durum bilgili
nesil bu sayıyı yirmi dörde indiriyor ve kazancının tamamı tek bir yerden geliyor: oturum
tablosundan. Yön başlangıcı iddiası, "bu paket zaten kurulmuş bir bağlantıya ait" demektir ve
paketin kendi içindeki bir alan bunu söyler. Tablo tutan kutu o alanı söylenene bakarak değil,
kendi kaydına bakarak sınar. On altı iddia hâlâ görüş alanının dışındadır.

Uygulama farkındalıklı nesil görmediği alan bırakmıyor; kırk sekiz iddianın kırk beşini
kanıtlıyor. Kalan üç iddia aynı türdendir ve alt satır onu adlandırıyor. İstekte taşınan özne
kimliği, üç akış sınıfında geçiyor ve hiçbir nesil onu kanıtlayamıyor — çünkü ağ katmanındaki
hiçbir kutunun elinde o kimliği sınayacak bir karşılık yoktur. Kutu yalnızca başlığın orada
yazdığını görür. Bu iddianın kanıtı ağın dışındadır; kime ait olduğu ve neye dayandığı bu kursun
konusu değildir.

## Sahte İddia, Bakılan Kalem ve Şifreli Akış

Kanıtlanmayan bir iddia, o iddianın yanlış olduğu anlamına gelmez; sınanmadığı anlamına gelir.
Farkın nerede önem kazandığını görmek için aynı iddia türlerinin sahte olduğu beş sınıf modele
konuldu. Bunlar birer yöntem tarifi değil, tek satırlık birer etikettir: hangi alanın söylediğiyle
gerçeğin ayrıştığı yer.

```js
// kosum2.mjs — bes iddia sahteciligi sinifi hangi nesilde duruyor, her nesil kac kaleme bakiyor
import { NESIL, SINIF, KALEM, OTURUM, SIFRELI, SIFRELI_OTURUM, say, durduran, kanitlar } from './nesil.mjs';

console.log(`${'sahte iddia sinifi'.padEnd(36)} ${'iddia turu'.padEnd(16)}` + NESIL.map((n) => n.padStart(11)).join(''));
for (const s of SINIF)
  console.log(`${s[0].padEnd(36)} ${s[1].padEnd(16)}` +
    NESIL.map((n) => (kanitlar(n, s[1]) ? 'durur' : 'gecer').padStart(11)).join(''));
const durur = (n) => SINIF.filter((s) => kanitlar(n, s[1])).length;
console.log('\n' + `${'nesil'.padEnd(10)} ${'duran sinif'.padStart(11)}` +
  Object.keys(KALEM.uygulama).map((k) => k.padStart(22)).join(''));
for (const n of NESIL)
  console.log(`${n.padEnd(10)} ${`${durur(n)}/${SINIF.length}`.padStart(11)}` +
    Object.values(KALEM[n]).map((v) => String(v).padStart(22)).join(''));
console.log(`\ndurum kaydi = donemdeki eszamanli oturum (${OTURUM}); tablo dolarsa yeni oturum ya reddedilir ya kayitsiz gecer`);
console.log(`hicbir nesil ${SINIF.filter((s) => durduran(s) === '-').length} sinifi durdurmuyor: ${SINIF.filter((s) => durduran(s) === '-').map((s) => s[0]).join(', ')}`);
const [acik, sifre] = [say('uygulama'), say('uygulama', true)];
console.log(`\nucdan uca sifreli akis: ${SIFRELI.length}/8 sinif, ${SIFRELI_OTURUM} oturum`);
console.log(`uygulama farkindalikli nesil kanitladigi iddia  ${acik.kan} -> ${sifre.kan}  (sifreli akista yalniz sunucu adi gorunur)`);
console.log(`kanitsiz kabul edilen iddia                     ${acik.kanitsiz} -> ${sifre.kanitsiz}`);
console.log(`kaybi kapatmak: ${SIFRELI_OTURUM} oturumu sonlandirip yeniden kurmak, oturum basina 1 ek tur ve 2 ek anahtar kalemi`);
```

```
sahte iddia sinifi                   iddia turu            paket      durum   uygulama
kaynak adresi baska bolgeden         kaynak-adres          durur      durur      durur
kurulmus oturum gibi gorunen paket   yon-baslangici        gecer      durur      durur
izinli kapida baska protokol         hedef-hizmet          gecer      gecer      durur
izinli akista baska sunucu adi       sunucu-adi            gecer      gecer      durur
istekte tasinan ozne basligi         ozne-kimligi          gecer      gecer      gecer

nesil      duran sinif          kural satiri           durum kaydi          akis tamponu  protokol cozumleyici
paket              1/5                    34                     0                     0                     0
durum              2/5                    34                 94112                     0                     0
uygulama           4/5                    34                 94112                 94112                     6

durum kaydi = donemdeki eszamanli oturum (94112); tablo dolarsa yeni oturum ya reddedilir ya kayitsiz gecer
hicbir nesil 1 sinifi durdurmuyor: istekte tasinan ozne basligi

ucdan uca sifreli akis: 5/8 sinif, 44002 oturum
uygulama farkindalikli nesil kanitladigi iddia  45 -> 39  (sifreli akista yalniz sunucu adi gorunur)
kanitsiz kabul edilen iddia                     3 -> 9
kaybi kapatmak: 44002 oturumu sonlandirip yeniden kurmak, oturum basina 1 ek tur ve 2 ek anahtar kalemi
```

Üst tablo beş sahte iddia sınıfını aynı üç kutuya veriyor. Kural satırı üç nesilde de otuz dörttür;
duran sınıf sayısı birden dörde çıkıyor. Aradaki fark yazılan kuralda değil, kutunun elindeki
karşılıktadır. İkinci tablo o karşılığın adını koyuyor: durum bilgili nesil doksan dört bin kayıtlık
bir tablo tutmak zorundadır ve o tabloyu tutmasa yön başlangıcı iddiasını sınayamaz. Uygulama
farkındalıklı nesil aynı tabloya ek olarak her oturum için bir akış tamponu ve altı protokol
çözümleyicisi taşır. Bir sınıf daha durdurmanın bedeli, bakılan kalemin sıfırdan doksan dört bine,
oradan iki katına çıkmasıdır.

Sıralamanın bir yönü daha var. Beş sınıfın ilki üç nesilde de duruyor ve bunu durduran şey en ucuz
neslin en ucuz denetimidir: paketin geldiği yön ile taşıdığı kaynak adresinin uyuşup uyuşmadığı.
Bakılan kalem sıfırdır, çünkü karşılık zaten yönlendirme kararının içindedir. Nesli yükseltmek bu
denetimi güçlendirmez; yalnız arkasına yenilerini ekler. Pahalı olan nesil, ucuz denetimi yapmayı
unutan bir düzende de aynı sınıfı geçirir.

Durum tablosunun kendisi yeni bir kalemdir ve dolabilir. Doluluk anında iki seçenek vardır: yeni
oturumu reddetmek — meşru trafiği kesmek — ya da kayıtsız geçirmek, yani o oturum için yön
başlangıcı iddiasını yeniden kanıtsız kabul etmek. Durum tutan bir kutunun kapasitesi bu yüzden
bir başarım kalemi değil, bir güvenlik kalemidir.

Alt blok savunmanın yetmediği yeri veriyor. Sekiz akış sınıfının beşi uçtan uca şifrelidir ve
bunlarda kutunun dışarıdan görebildiği tek uygulama iddiası sunucu adıdır. Kanıtlanan iddia kırk
beşten otuz dokuza, kanıtsız kabul edilen üçten dokuza gidiyor. Uygulama farkındalığı yalnız
akışın açık olduğu yerde çalışır. Kaybı geri almanın tek yolu bağlantıyı kutuda sonlandırıp arkaya
yeniden kurmaktır: kırk dört bin oturumun her biri için bir ek tur, iki ek anahtar kalemi ve
akışın açık hâlde görüldüğü yeni bir nokta. Kanıtlanan iddia sayısını yükselten hamle, ağa daha
önce olmayan bir yoğunlaşma noktası ekliyor.

## Özet

- Sekiz akış sınıfı 48 iddia taşıyor. Paket filtreleyen kutu her sınıfta aynı 3 alanı görüyor ve
  yalnız 1'ini kanıtlıyor; toplamda 40 iddia kanıtsız kabul ediliyor.
- Durum bilgili nesil kanıtsız kabul edilen iddiayı 24'e indiriyor ve kazancının tamamı oturum
  tablosundan geliyor: paketin kendi söylediği yön başlangıcı yerine kutunun kendi kaydına bakıyor.
- Uygulama farkındalıklı nesil 48 iddianın 45'ini kanıtlıyor. Kalan 3'ü aynı türdendir: istekte
  taşınan özne kimliğini hiçbir nesil kanıtlayamıyor, çünkü ağ katmanında sınayacak karşılık yoktur.
- Bedel bakılan kalemdir: kural satırı üç nesilde de 34 kalırken durum kaydı 0'dan 94.112'ye, akış
  tamponu 0'dan 94.112'ye çıkıyor ve 6 protokol çözümleyicisi ekleniyor. Tablo dolduğunda seçenek
  meşru oturumu reddetmek ya da kanıtsız geçirmektir.
- 8 akış sınıfının 5'i uçtan uca şifreli; bu 44.002 oturumda kanıtlanan iddia 45'ten 39'a iniyor.
  Geri almanın yolu bağlantıyı sonlandırmaktır: oturum başına 1 ek tur, 2 ek anahtar kalemi ve
  akışın açık göründüğü yeni bir nokta.

## Sonraki Adım

Bu dersin bütün ölçümü tek bir sınırda duran tek bir kutu varsaydı ve o kutunun kanıtlayamadığı
her iddia arkasındaki ağın tamamına girdi. Sekiz akış sınıfı da aynı düzlükte duruyordu: sayaç
toplayıcısına ulaşan bir mesaj, faturalama arayüzüne de aynı hamleyle ulaşabiliyordu. Sonraki
dersin sorusu kutunun ne gördüğü değil, ağın kaç parçaya ayrıldığıdır: bölgeler arasına sınır
konulduğunda bir bölge düştüğünde kaç bölgeye ulaşılıyor, kaç yol kapanıyor, silahtan arındırılmış
bölge dışarıya bakan kalemleri hangi tarafta bırakıyor ve bölgeler arasındaki meşru trafiğin
sürmesi kaç kural satırı istiyor.
