---
title: 'Ağ Akış Verisi'
source: 'https://academia.sh/tr/kurslar/guvenlik-operasyonlari/ag-akis-verisi'
course: 'Güvenlik Operasyonları ve Olay Müdahalesi'
language: tr
updated: '2026-08-17T18:08:41+00:00'
license: 'CC BY-SA 4.0'
---

# Ağ Akış Verisi

2.979 kurgu akış kaydı üzerinde yalnız meta veriye bakan dört ölçüt koşturulur: düzenli aralık 7 çift işaretliyor ve 6'sı sayaç aktarımı, çıkış oranı 23 işaretliyor ve 22'si gecelik yedekleme, yeni hedef 7 işaretliyor ve 6'sı yeni iş kalemi, uzun oturum 6 işaretliyor ve 5'i yönetim oturumu. Dört kurgu kalemin dördü de işaretleniyor, ama toplam 43 çiftin 39'u meşrudur. Aynı kayıt kümesine sorulan on sorunun 6'sı yalnız meta veriden yanıtlanıyor; ne gönderildiği, hangi hesabın yaptığı, isteğin kabul edilip edilmediği ve hangi sürecin başlattığı yanıtsız kalıyor. İşaretlenenlerin tümü kesilirse 630 akış ve 8,8 GB meşru iş durur.

Bir önceki dersin k4 kalemi hiçbir kimlik ya da yönetim kaydında görünmüyordu; üçüncü adımı yalnız
giden bir bağlantı olarak, ağ akış verisinde vardı. O kaynak öteki ikisinden **yapı olarak** ayrılır.
Bir akış kaydı bağlantının içeriğini yazmaz; kimin kiminle, hangi kapıda, ne kadar süreyle ve kaç
bayt konuştuğunu yazar.

Bu ders o kısıtı ölçüye çevirir. Soru "akış verisi yararlı mıdır" değil, **içerik olmadan hangi
sorunun yanıtlanabildiğidir** — ve bunun karşılığında kaç meşru bağlantının işaretlendiğidir. Aşağıdaki
kayıt kümesi bir **modeldir**; dış adresler belgeleme için ayrılmış bloklardan seçilmiştir ve gerçek
bir uca karşılık gelmez.

- **TA18.** Akış kaydının yedi alanı vardır: zaman, konak, hedef, kapı, süre, giden bayt, gelen bayt.
  **İçerik alanı yoktur** ve bu bir yapılandırma eksikliği değil, kaynağın tanımıdır.
- **TA19.** Kurgu ağda dört meşru trafik biçimi bulunur: personel gezinmesi, sayaç toplayıcıların
  on beş dakikalık aktarımı, gecelik yedekleme ve uzun yönetim oturumları.
- **TA20.** Dört kurgu kalem yalnız **kayıt olarak** verilir: düzenli aralıklı bağlantı dizisi,
  yüksek çıkış oranlı aktarım, taban çizgisinde bulunmayan hedef ve tek uzun oturum.
- **TA21.** Ölçüt bir `(konak, hedef, kapı)` üçlüsü üzerinde çalışır ve yalnız meta veriye bakar.
  Etiket modelin doğrusudur, kayda yazılmaz.
- **TA22.** Taban çizgisi, önceki günlerde görülmüş `(hedef, kapı)` ikililerinin kümesidir ve model
  verisi olarak verilir.

## Meta Veriye Bakan Dört Ölçüt

```js
// akisveri.mjs — kurgu ag akis kayitlari ve yalniz meta veriye bakan dort olcut. MODELDIR.
// Dis adresler belgeleme icin ayrilmis bloklardandir; gercek uc ve kurum yoktur.
export const TOHUM = 20260404;
const uretec = (t) => { let s = t >>> 0;
  return () => (s = (s * 1664525 + 1013904223) >>> 0) / 4294967296; };
const r = uretec(TOHUM);
const tam = (n) => Math.floor(r() * n);

const UC = Array.from({ length: 40 }, (_, i) => `uc-${101 + i}`);
const TOPLAYICI = Array.from({ length: 6 }, (_, i) => `tp-${11 + i}`);
const IC = Array.from({ length: 8 }, (_, i) => `10.90.1.${20 + i}`);
const DIS = Array.from({ length: 30 }, (_, i) => `198.51.100.${10 + i}`);

// Akis kaydi: baglantinin ICERIGI yoktur. Yalniz kim, kimle, ne kadar, ne sure.
const ham = [];
const ek = (t, konak, hedef, port, sure, giden, gelen, etiket) =>
  ham.push({ t: Math.round(t), konak, hedef, port, sure, giden, gelen, etiket });

// Personel gezinmesi: gelen bayt giden bayttan cok buyuk, hedef degisken.
for (const u of UC)
  for (let k = 0, n = 30 + tam(60); k < n; k++)
    ek(tam(1440), u, DIS[tam(30)], 443, 1 + tam(90), 800 + tam(9000),
      20000 + tam(900000), "gezinme");
// Sayac toplayicilar: on bes dakikada bir ic hedefe kucuk ve DUZENLI aktarim.
for (const [j, tp] of TOPLAYICI.entries())
  for (let t = j * 2; t < 1440; t += 15)
    ek(t, tp, IC[j % 8], 5671, 2 + tam(3), 40000 + tam(4000), 900 + tam(400), "olcum-aktarimi");
// Gecelik yedekleme: buyuk giden, dusuk gelen, gunde bir kez.
for (const u of UC.slice(0, 22))
  ek(120 + tam(120), u, IC[6], 8443, 40 + tam(40), 3e8 + tam(2e8), 5000 + tam(4000), "yedekleme");
// Uzun yonetim oturumlari.
for (const u of UC.slice(0, 5)) ek(540 + tam(120), u, IC[7], 22, 150 + tam(180),
  90000 + tam(50000), 300000 + tam(200000), "yonetim-oturumu");

// Dort kurgu kalem. Yalnizca KAYIT verilir; yontem anlatilmaz.
const KALEM = ["d1-duzenli-aralik", "d2-cikis-orani", "d3-yeni-hedef", "d4-uzun-oturum"];
for (let t = 30, k = 0; k < 96; k++, t += 15)                       // d1
  ek(t + (r() < 0.5 ? 0 : 1), UC[7], "203.0.113.24", 443, 1 + tam(2), 1200 + tam(400),
    600 + tam(300), KALEM[0]);
for (let k = 0, t = 800; k < 12; k++)                               // d2
  ek(t += 4 + tam(9), UC[19], "203.0.113.31", 443, 20 + tam(40), 4e7 + tam(2e7),
    3000 + tam(2000), KALEM[1]);
for (let k = 0; k < 3; k++)                                         // d3
  ek(1010 + k * 7, UC[31], "203.0.113.9", 9443, 3 + tam(6), 9000 + tam(4000),
    12000 + tam(9000), KALEM[2]);
ek(300, UC[24], IC[3], 8443, 415, 2200000, 6100000, KALEM[3]);      // d4
// Yeni is kalemi: uc mesru dis hedef gun icinde ilk kez goruluyor.
for (const [j, u] of UC.slice(30, 36).entries())
  for (let k = 0, n = 2 + tam(5); k < n; k++)
    ek(600 + tam(500), u, `192.0.2.${40 + (j % 3)}`, 443, 2 + tam(30), 3000 + tam(9000),
      40000 + tam(300000), "yeni-is-kalemi");
ham.sort((a, b) => a.t - b.t);
export const AKIS = ham.map(({ etiket, ...a }, i) => ({ ...a, i }));
export const ETIKET = ham.map((a) => a.etiket);   // modelin dogrusu; olcutler GORMEZ

// Taban cizgisi: onceki gunlerde gorulmus (hedef, port) ikilileri (model verisi).
export const TABAN = new Set([...IC.flatMap((h) => [`${h}|5671`, `${h}|8443`, `${h}|22`]),
  ...DIS.map((h) => `${h}|443`), "203.0.113.24|443", "203.0.113.31|443"]);

// Dort olcut: yalniz meta veriye bakar, icerige degil.
const ciftler = () => {
  const m = new Map();
  for (const a of AKIS) {
    const k = `${a.konak}|${a.hedef}|${a.port}`;
    (m.get(k) || m.set(k, []).get(k)).push(a);
  }
  return m;
};
export const OLCUT = {
  "duzenli aralik": () => [...ciftler()].filter(([, l]) => {
    if (l.length < 12) return false;
    const d = l.slice(1).map((a, i) => a.t - l[i].t);
    const o = d.reduce((x, y) => x + y, 0) / d.length;
    return o > 0 && Math.sqrt(d.reduce((x, y) => x + (y - o) ** 2, 0) / d.length) / o < 0.15;
  }),
  "cikis orani": () => [...ciftler()].filter(([, l]) => {
    const g = l.reduce((x, a) => x + a.giden, 0), a = l.reduce((x, b) => x + b.gelen, 0);
    return g > 5e6 && g / a > 20;
  }),
  "yeni hedef": () => [...ciftler()].filter(([k]) => {
    const [, h, p] = k.split("|");
    return !TABAN.has(`${h}|${p}`);
  }),
  "uzun oturum": () => [...ciftler()].filter(([, l]) => l.some((a) => a.sure > 120)),
};

if (import.meta.url === `file://${process.argv[1]}`) {
  const gen = (B) => (h) => h.map((v, j) => (j ? String(v).padStart(B[j])
    : String(v).padEnd(B[0]))).join("");
  const yz = gen([16, 12, 10, 13, 34]);
  console.log(`model (tohum ${TOHUM}): ${AKIS.length} akis kaydi, ` +
    `${new Set(AKIS.map((a) => a.konak)).size} konak; kayitta icerik alani yok`);
  console.log(`ornek: ${JSON.stringify(AKIS[ETIKET.indexOf(KALEM[0])])}`);
  console.log();
  console.log(yz(["olcut", "isaretlenen", "kalem", "yanlis poz.", "yanlis pozitifin kaynagi"]));
  for (const [ad, f] of Object.entries(OLCUT)) {
    const l = f();
    const et = ([, x]) => ETIKET[x[0].i];
    const dogru = l.filter((c) => KALEM.includes(et(c)));
    const yp = l.filter((c) => !KALEM.includes(et(c)));
    console.log(yz([ad, l.length, dogru.map((c) => et(c).slice(0, 2)).join(",") || "-",
      yp.length, [...new Set(yp.map(et))].join(", ") || "-"]));
  }
  const hepsi = new Set(Object.values(OLCUT).flatMap((f) => f().map(([, x]) => ETIKET[x[0].i])
    .filter((e) => KALEM.includes(e))));
  const toplam = Object.values(OLCUT).reduce((a, f) => a + f().length, 0);
  console.log(`\ndort kurgu kalemin ${hepsi.size} tanesi en az bir olcutle isaretleniyor; ` +
    `dort olcut toplam ${toplam} cift isaretliyor`);
}
```

```
model (tohum 20260404): 2979 akis kaydi, 46 konak; kayitta icerik alani yok
ornek: {"t":31,"konak":"uc-108","hedef":"203.0.113.24","port":443,"sure":1,"giden":1402,"gelen":676,"i":70}

olcut            isaretlenen     kalem  yanlis poz.          yanlis pozitifin kaynagi
duzenli aralik             7        d1            6                    olcum-aktarimi
cikis orani               23        d2           22                         yedekleme
yeni hedef                 7        d3            6                    yeni-is-kalemi
uzun oturum                6        d4            5                   yonetim-oturumu

dort kurgu kalemin 4 tanesi en az bir olcutle isaretleniyor; dort olcut toplam 43 cift isaretliyor
```

Örnek kayıt dersin sınırını gösteriyor: yedi alan var ve hiçbiri ne taşındığını söylemiyor. Buna
karşılık dört ölçüt dört kurgu kalemin **dördünü de** işaretliyor. İçerik görülmeden bir düzen
görülebilir; ölçülen şey içeriğin kendisi değil, bağlantının **şeklidir**.

Şeklin ayırt edici gücü ise düşüktür ve tablonun son iki sütunu bunu yazıyor. Düzenli aralık ölçütü
yedi çift işaretliyor, altısı sayaç toplayıcıların on beş dakikalık aktarımıdır. Aynı düzenlilik —
sabit aralık, küçük ve eşit boyutlu paketler — bu ağın **normal işidir**; kurgu kalem tam olarak
normal işin şekline sahiptir. Çıkış oranı ölçütü daha da kötüdür: yirmi üç çiftin yirmi ikisi
gecelik yedeklemedir.

Yeni hedef ölçütü altı meşru kalemi işaretliyor, çünkü üç yeni iş bağlantısı da gün içinde ilk kez
görülüyor. Bir ayrıntı burada önemlidir: d1 kaleminin hedefi taban çizgisinde **vardır**, yani yeni
hedef ölçütü onu hiç görmez. Dört kalemin dördünü birden yakalayan tek bir ölçüt yoktur; kapsama
dört ölçütün birleşiminden gelir ve o birleşim 43 çift işaretler.

## İçerik Olmadan Yanıtlanan Soru

```js
// soru.mjs — akis kaydinin yanitlayabildigi ve yanitlayamadigi sorular, sonra kesme bedeli.
import { AKIS, ETIKET, TABAN, OLCUT } from "./akisveri.mjs";

const cift = AKIS.filter((a) => ETIKET[a.i] === "d1-duzenli-aralik");
const bayt = (n) => (n > 1e9 ? `${(n / 1e9).toFixed(1)} GB` : `${(n / 1e6).toFixed(1)} MB`);
const ortanca = (v) => v.slice().sort((a, b) => a - b)[Math.floor(v.length / 2)];
// Her soru bir islev: akis kaydindan yanit uretebiliyorsa yaniti, uretemiyorsa null doner.
const SORU = [
  ["hangi iki uc konustu", (l) => `${l[0].konak} -> ${l[0].hedef}:${l[0].port}`],
  ["kac kez baglandi", (l) => `${l.length} kez`],
  ["hangi araliklarla", (l) => `${ortanca(l.slice(1).map((x, i) => x.t - l[i].t))} dk`],
  ["ne kadar veri gitti", (l) => bayt(l.reduce((a, x) => a + x.giden, 0))],
  ["ne kadar surdu", (l) => `en cok ${Math.max(...l.map((x) => x.sure))} dk`],
  ["hedef daha once gorulmus mu",
    (l) => (TABAN.has(`${l[0].hedef}|${l[0].port}`) ? "evet" : "hayir")],
  ["ne gonderildi", () => null],
  ["hangi hesap yapti", () => null],
  ["istek kabul edildi mi", () => null],
  ["hangi surec baslatti", () => null],
];
const gen = (B) => (h) => h.map((v, j) => (j ? String(v).padStart(B[j])
  : String(v).padEnd(B[0]))).join("");
const ys = gen([30, 16, 28]);
console.log(`d1 kalemi: ${cift.length} akis kaydi. Ayni kayit kumesine on soru soruluyor.`);
console.log();
console.log(ys(["soru", "yanitlanabilir", "yanit"]));
for (const [ad, f] of SORU) {
  const y = f(cift);
  console.log(ys([ad, y === null ? "hayir" : "evet", y === null ? "-" : y]));
}
const acik = SORU.filter(([, f]) => f(cift) !== null).length;
console.log(`\non sorunun ${acik} tanesi yalniz meta veriden yanitlaniyor, ` +
  `${SORU.length - acik} tanesi baska kaynak istiyor`);

// Erken karar: yalniz akis olcutune bakip baglanti kesilirse kesilen mesru is.
const KAYNAK = { "olcum-aktarimi": ["sayac toplama durur", 0], "yedekleme": ["gecelik yedek", 0],
  "yeni-is-kalemi": ["yeni is baglantisi", 0], "yonetim-oturumu": ["yonetim erisimi", 0] };
const isaret = new Map();
for (const [, f] of Object.entries(OLCUT))
  for (const [k, l] of f()) if (!isaret.has(k)) isaret.set(k, l);
let mesruCift = 0, mesruKayit = 0, mesruBayt = 0;
for (const [, l] of isaret) {
  const e = ETIKET[l[0].i];
  if (!KAYNAK[e]) continue;
  mesruCift++; mesruKayit += l.length;
  mesruBayt += l.reduce((a, x) => a + x.giden + x.gelen, 0);
  KAYNAK[e][1]++;
}
const yk = gen([22, 10, 30]);
console.log(`\nisaretlenen ayri cift ${isaret.size}, bunlarin ${mesruCift} tanesi mesru; ` +
  `kesilirse ${mesruKayit} akis ve ${bayt(mesruBayt)} durur`);
console.log(yk(["kesilen is turu", "cift", "duran is"]));
for (const [e, [ne, n]] of Object.entries(KAYNAK)) console.log(yk([e, n, ne]));
```

```
d1 kalemi: 96 akis kaydi. Ayni kayit kumesine on soru soruluyor.

soru                            yanitlanabilir                       yanit
hangi iki uc konustu                      evet  uc-108 -> 203.0.113.24:443
kac kez baglandi                          evet                      96 kez
hangi araliklarla                         evet                       15 dk
ne kadar veri gitti                       evet                      0.1 MB
ne kadar surdu                            evet                 en cok 2 dk
hedef daha once gorulmus mu               evet                        evet
ne gonderildi                            hayir                           -
hangi hesap yapti                        hayir                           -
istek kabul edildi mi                    hayir                           -
hangi surec baslatti                     hayir                           -

on sorunun 6 tanesi yalniz meta veriden yanitlaniyor, 4 tanesi baska kaynak istiyor

isaretlenen ayri cift 43, bunlarin 39 tanesi mesru; kesilirse 630 akis ve 8.8 GB durur
kesilen is turu             cift                      duran is
olcum-aktarimi                 6           sayac toplama durur
yedekleme                     22                 gecelik yedek
yeni-is-kalemi                 6            yeni is baglantisi
yonetim-oturumu                5               yonetim erisimi
```

Soru tablosu akış verisinin sınırını sayıya çeviriyor: on sorunun altısı yanıtlanıyor, dördü
yanıtsız kalıyor. Yanıtlananlar tek başına bir **karar** vermeye yetmez. `uc-108` on beş dakikada bir
aynı hedefe 96 kez bağlanmış ve toplam 0,1 megabayt göndermiş; bu tanım hem yinelenen bir denetim
isteğine hem de başka bir şeye uyar. Ayrımı yapacak alanlar — hangi hesap, hangi süreç, istek kabul
edildi mi — akış kaydında **yoktur**.

Yanıtsız dört sorunun her biri belirli bir kaynağı adlandırır. Hangi hesabın yaptığı sorusu ikinci
dersteki adres eşlemesini gerektirir ve o eşleme beş dakikalık pencerede 404 kaydın 190'ına yanıt
verebiliyordu. Hangi sürecin başlattığı sorusu uç nokta kaydını, isteğin kabul edilip edilmediği
sorusu yönetim düzlemi kaydını ister. Akış verisi bir **karar kaynağı değil, bir yönlendirme
kaynağıdır**: hangi konağa ve hangi zaman aralığına bakılacağını söyler.

Son tablo erken kararın bedelini yazıyor. İşaretlenen 43 çiftin 39'u meşrudur ve tümü kesilirse 630
akış ile 8,8 gigabayt iş durur. Bu, düz bir sayı değildir: kesilenlerin altısı sayaç toplama
aktarımıdır ve bu aktarım durduğunda ölçüm verisi merkeze hiç ulaşmaz. Yirmi iki çift gecelik
yedeklemedir; bir gün yedeksiz kalmak, kursun ilerleyen bölümünde kurtarma kararını doğrudan
etkileyen bir kayıptır.

## Özet

- Akış kaydının yedi alanı vardır ve içerik alanı yoktur; buna karşın yalnız şekle bakan dört ölçüt
  dört kurgu kalemin dördünü de işaretliyor.
- Ayırt edicilik düşüktür: düzenli aralık 7 çiftin 6'sında sayaç aktarımını, çıkış oranı 23 çiftin
  22'sinde gecelik yedeklemeyi, yeni hedef 7 çiftin 6'sında yeni iş bağlantısını işaretliyor.
- Tek bir ölçüt dört kalemin dördünü birden yakalamıyor; d1'in hedefi taban çizgisinde bulunduğu
  için yeni hedef ölçütü onu hiç görmez, kapsama dört ölçütün birleşiminden gelir.
- On sorunun 6'sı yalnız meta veriden yanıtlanıyor; ne gönderildiği, hangi hesabın yaptığı, isteğin
  kabul edilip edilmediği ve hangi sürecin başlattığı dört soru başka kaynak ister.
- İşaretlenen 43 çiftin 39'u meşrudur; tümü kesilirse 630 akış ve 8,8 gigabayt iş durur, bunun altı
  çifti sayaç toplama aktarımıdır.

## Sonraki Adım

Bu dersin dört ölçütü sabit eşiklerle çalıştı ve sonuç 43 işaretin 39'unun meşru çıkmasıydı.
Eşikleri sıkılaştırmak akla gelen ilk düzeltmedir: değişim katsayısını 0,15 yerine 0,05 yapmak,
çıkış oranını yirmi yerine iki yüz istemek. Sonraki ders bunu bir tarama olarak koşturur ve iki
eğriyi aynı eksende çizer — eşik sıkılaştıkça yanlış pozitif düşer, ama kaçırılan yükselir. Ölçülen
şey hangi eşiğin doğru olduğu değil, iki eğrinin **kesişmediği** noktadır: kurgu kalemlerin
puanlarıyla meşru işin puanlarının üst üste bindiği bantta hiçbir eşik ikisini birden azaltamaz ve o
bandın kaç kalem içerdiği sayılabilir.
