---
title: 'Bellek Dökümü Analizi'
source: 'https://academia.sh/tr/kurslar/guvenlik-operasyonlari/bellek-dokumu-analizi'
course: 'Güvenlik Operasyonları ve Olay Müdahalesi'
language: tr
updated: '2026-08-17T18:08:42+00:00'
license: 'CC BY-SA 4.0'
---

# Bellek Dökümü Analizi

Uçuculuk sırasının kurulması ve toplama sırasının kaybettirdiği kalemin sayılması: 28 kanıt kalemi 10 uçuculuk sınıfına dizilir, tek kişilik toplamada doğru sıra 7, konak konak toplama 12, en büyük kalem önce toplama 18 kalem kaybettirir. Üç kişilik ekip doğru sırayla 0 kayıp verir, altı kişilik ekip yanlış sırayla 13; yanlış sıra en hızlı biten toplamadır, çünkü kaybolan kalem süre harcamaz. Bellek dökümü 12 sorunun 8'ine değer, 4'ünü tek başına yanıtlar.

Bir önceki ders kaynağın yedi bölgesini saydı ve kanıt kalemlerinin çoğunun dosya olmayan
bölgelerde durduğunu gösterdi. O listede bellek yoktu. Olmaması bir eksiklik değil, tanımın kendisi:
bellek diskte değildir ve hiçbir kopyalama kapsamı ona ulaşmaz. Takas alanındaki artık bellekten
düşmüş parçaları taşır, ama parçadır ve tam da kopyalama sırasında en çok değişen bölgelerdendir.

Bellek bu konuda ayrı bir ders açıyor, çünkü ölçü birimini değiştiriyor. Disk imajında soru
"kapsam kaç kalem getiriyor" idi ve kapsam genişletilebilir bir karardı. Bellekte soru
"**ne zaman**" olur ve zaman genişletilemez. Bu ders o zamanı ölçer: kalemler ömürlerine göre
sıralanır, üç farklı toplama sırası aynı küme üzerinde koşturulur ve her sıranın kaybettirdiği kalem
sayılır. Ölçüm bir **modeldir**; **bellek dökümü çıkarma aracı ve komutu yazılmaz**, ölçülen şey
sıra ve kalem sayısıdır.

- **AI13.** Bir kalemin **ömrü**, toplanmaya başlanmazsa kaybolmadan önce geçen süredir. Ömür
  kalemin sınıfından gelir ve kurgudur.
- **AI14.** **Uçuculuk sırası** (order of volatility), kalemlerin ömürlerine göre artan sıralamasıdır:
  ağ durumu, süreç listesi, açık tanıtıcılar, oturum durumu, bellek içeriği, geçici dosyalar, sonra
  disk ve uzak kayıtlar.
- **AI15.** Toplama **sıralıdır**: bir toplayıcı aynı anda tek kalem alır ve kalemin süresi kadar
  meşguldür. Ekip büyüdükçe koşut kuyruk sayısı artar.
- **AI16.** Bir kalem, toplanmaya **başlanmadan** ömrünü doldurursa kaybolur ve süre harcamaz.
- **AI17.** Zamanın sıfır noktası müdahale ekibinin konaklara erişim kazandığı andır; tespit ve karar
  süreleri bu derste sayılmaz.
- **AI18.** Kalem kümesi ilk dersteki kümenin aynısıdır: altı konak, 28 kalem.

## Uçuculuk Sırası

```js
// adli/sira.mjs — uculuk sirasi ve toplama sirasinin kaybettirdigi kalem MODELIDIR.
// Bellek cikarma araci ve komutu yazilmaz; olculen sey sira ve kalem sayisidir.

// sinif -> [omur(sn): toplanmaya baslanmazsa kaybolmadan once gecen sure, toplama suresi(sn)]
export const SINIF = {
  "ag-durumu": [120, 45], "surec-listesi": [240, 60], "acik-tanitici": [300, 55],
  "oturum-durumu": [600, 70], "bellek-icerigi": [900, 420], "gecici-dosya": [3600, 180],
  "akis-kaydi": [86400, 240], "uzak-gunluk": [2592000, 300],
  "disk-imaji": [604800, 5400], "yapilandirma": [604800, 90],
};

export const KONAK = {
  "sube-ucu-3": ["ag-durumu", "surec-listesi", "acik-tanitici", "oturum-durumu",
    "bellek-icerigi", "gecici-dosya", "disk-imaji", "yapilandirma"],
  "saha-dizustu-14": ["ag-durumu", "surec-listesi", "oturum-durumu", "bellek-icerigi",
    "disk-imaji"],
  "toplayici-2": ["ag-durumu", "surec-listesi", "acik-tanitici", "oturum-durumu",
    "bellek-icerigi", "disk-imaji", "yapilandirma"],
  "portal-onyuz": ["ag-durumu", "surec-listesi", "bellek-icerigi", "yapilandirma"],
  "merkez-gunluk": ["uzak-gunluk", "yapilandirma"],
  "akis-toplayici": ["akis-kaydi", "yapilandirma"],
};

export const KUME = Object.entries(KONAK).flatMap(([konak, siniflar]) =>
  siniflar.map((s) => ({ ad: `${konak}/${s}`, konak, sinif: s,
    omur: SINIF[s][0], sure: SINIF[s][1] })));

// Uc siralama: uculuge gore, konak konak (gelis sirasi), en buyuk kalem once.
export const DIZI = {
  "uculuk sirasi": [...KUME].sort((a, b) => a.omur - b.omur || a.sure - b.sure),
  "konak konak": [...KUME],
  "en buyuk once": [...KUME].sort((a, b) => b.sure - a.sure),
};

// Toplama: n toplayici paralel calisir, sirasi gelen kalem ilk bosalan toplayiciya gider.
// Kalem, omru dolduktan sonra baslanirsa kaybolur ve sure harcanmaz.
export function topla(dizi, n) {
  const bos = Array(n).fill(0), kayip = [], alinan = [];
  for (const k of dizi) {
    const i = bos.indexOf(Math.min(...bos)), bas = bos[i];
    if (bas > k.omur) kayip.push({ ...k, bas });
    else { alinan.push({ ...k, bas }); bos[i] = bas + k.sure; }
  }
  return { alinan, kayip, sure: Math.max(...bos) };
}
```

Sıralamanın üç adayı da gerçekte karşılaşılan alışkanlıklardır. **Konak konak** toplama en doğal
olanıdır: ekip bir makinenin başına geçer, o makinede ne varsa alır, sonrakine geçer. **En büyük
önce** toplama bir tedbir gibi görünür: en pahalı kalem en uzun sürüyorsa ona en erken başlanmalıdır.
**Uçuculuk sırası** ise kalemin değerine ya da boyutuna değil, yalnız ömrüne bakar.

## Sıra Yanlışsa Kaybedilen Kalem

```js
// adli/olc.mjs — uc siralama ve iki ekip buyuklugu icin kaybedilen kalem sayimi.
import { SINIF, KUME, DIZI, topla } from "./sira.mjs";

const y = (g, ...s) => console.log(s.map((v, i) =>
  (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("").trimEnd());

const ucucu = KUME.filter((k) => k.omur <= 3600);
console.log(`model: ${KUME.length} kanit kalemi, ${Object.keys(SINIF).length} uculuk sinifi, ` +
  `${ucucu.length} kalem ucucu, hepsini toplamak ${KUME.reduce((a, k) => a + k.sure, 0)} sn`);

const A = [-16, 9, 9, 7, 14, 14, 14];
console.log("");
y(A, "sinif", "omur sn", "sure sn", "kalem", "1 kisi/dogru", "1 kisi/konak", "1 kisi/buyuk");
const t = Object.fromEntries(Object.keys(DIZI).map((d) => [d, topla(DIZI[d], 1)]));
for (const s of Object.keys(SINIF)) {
  const n = KUME.filter((k) => k.sinif === s).length;
  y(A, s, SINIF[s][0], SINIF[s][1], n,
    ...Object.keys(DIZI).map((d) => `${t[d].kayip.filter((k) => k.sinif === s).length} kayip`));
}
y(A, "toplam", "-", "-", KUME.length,
  ...Object.keys(DIZI).map((d) => `${t[d].kayip.length} kayip`));

const B = [-16, 7, 9, 8, 14, 11];
console.log("");
y(B, "siralama", "kisi", "alinan", "kayip", "ucucu kayip", "bitis sn");
for (const n of [1, 3, 6])
  for (const d of Object.keys(DIZI)) {
    const s = topla(DIZI[d], n);
    y(B, d, n, s.alinan.length, s.kayip.length,
      s.kayip.filter((k) => k.omur <= 3600).length, s.sure);
  }
```

```
model: 28 kanit kalemi, 10 uculuk sinifi, 18 kalem ucucu, hepsini toplamak 19790 sn

sinif             omur sn  sure sn  kalem  1 kisi/dogru  1 kisi/konak  1 kisi/buyuk
ag-durumu             120       45      4       1 kayip       3 kayip       4 kayip
surec-listesi         240       60      4       2 kayip       3 kayip       4 kayip
acik-tanitici         300       55      2       1 kayip       1 kayip       2 kayip
oturum-durumu         600       70      3       0 kayip       2 kayip       3 kayip
bellek-icerigi        900      420      4       3 kayip       3 kayip       4 kayip
gecici-dosya         3600      180      1       0 kayip       0 kayip       1 kayip
akis-kaydi          86400      240      1       0 kayip       0 kayip       0 kayip
uzak-gunluk       2592000      300      1       0 kayip       0 kayip       0 kayip
disk-imaji         604800     5400      3       0 kayip       0 kayip       0 kayip
yapilandirma       604800       90      5       0 kayip       0 kayip       0 kayip
toplam                  -        -     28       7 kayip      12 kayip      18 kayip

siralama           kisi   alinan   kayip   ucucu kayip   bitis sn
uculuk sirasi         1       21       7             7      18310
konak konak           1       16      12            12      18020
en buyuk once         1       10      18            18      17190
uculuk sirasi         3       28       0             0       6770
konak konak           3       19       9             9       6640
en buyuk once         3       10      18            18       5760
uculuk sirasi         6       28       0             0       5925
konak konak           6       25       3             3       5705
en buyuk once         6       15      13            13       5400
```

İlk tablo dersin çekirdeğidir ve son satırı üç sayı taşır: **7, 12, 18**. Aynı 28 kalem, aynı
süreler, aynı tek toplayıcı; değişen yalnız sıradır. Uçuculuk sırasında yedi kalem kaybolur, konak
konak toplamada on iki, en büyük kalem önce toplamada on sekiz. Son sayı uçucu kalemlerin
tamamıdır: 5.400 saniyelik ilk disk imajı bitene kadar ömrü bir saatin altında olan hiçbir kalem
ayakta kalmaz.

Doğru sıradaki yedi kayıp da ayrıca okunmalıdır. Sıra en iyisi olduğu halde ağ durumunun dördünden
biri, süreç listesinin dördünden ikisi, bellek içeriğinin dördünden üçü kaybolur. Nedeni tek
kişilik ekiptir: ağ durumunu almak 45 saniye sürüyor ve dört konağın dördüncüsüne sıra 135. saniyede
geliyor, ömür ise 120. **Doğru sıra kaybı en aza indirir, sıfırlamaz**; kaybı sıfırlayan şey koşut
kuyruk sayısıdır.

İkinci tablo bu ikisini ayırıyor ve karşılaştırma tek yönlü değildir. Üç kişilik ekip doğru sırayla
çalıştığında kayıp **sıfırdır** — üç kişi bu kurgu kümede yeterlidir. Altı kişilik ekip yanlış
sırayla çalıştığında kayıp **on üçtür**. İki kat insan, yanlış sırayı düzeltmiyor; sıra ekip
büyüklüğünden daha belirleyicidir, çünkü sıra ömrü tüketen şeydir, insan sayısı ise yalnız tüketme
hızını değiştirir.

Son sütun en aldatıcı olanıdır. En hızlı biten toplama, en çok kalem kaybeden toplamadır: tek
kişilik ekipte "en büyük önce" 17.190 saniyede biterken doğru sıra 18.310 saniye sürer. Fark bir
verimlilik değil, bir muhasebe yanılsamasıdır — **kaybolan kalem süre harcamaz.** Bir toplama
işleminin erken bitmesi, ancak alınan kalem sayısıyla birlikte okunduğunda bir şey anlatır.

## Konağa Varış Süresi

```js
// adli/varis.mjs — konaga erisim gecikmesinin dogru siradaki kayba etkisi.
import { KUME, DIZI } from "./sira.mjs";

const y = (g, ...s) => console.log(s.map((v, i) =>
  (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("").trimEnd());
const UZAK = ["sube-ucu-3", "saha-dizustu-14"];     // ekibin yolda oldugu iki saha konagi

// Kalem, konaga varildiktan sonra ve omru dolmadan once baslanmalidir.
function topla(dizi, n, gecikme) {
  const bos = Array(n).fill(0), kayip = [];
  for (const k of dizi) {
    const varis = UZAK.includes(k.konak) ? gecikme : 0;
    const i = bos.indexOf(Math.min(...bos)), bas = Math.max(bos[i], varis);
    if (bas > k.omur) kayip.push(k);
    else bos[i] = bas + k.sure;
  }
  return kayip;
}

const A = [-12, 9, 9, 12, 14];
y(A, "gecikme sn", "kisi", "kayip", "uzak konak", "merkez konak");
for (const g of [0, 600, 1200, 2400])
  for (const n of [3, 6]) {
    const k = topla(DIZI["uculuk sirasi"], n, g);
    y(A, g, n, k.length, k.filter((x) => UZAK.includes(x.konak)).length,
      k.filter((x) => !UZAK.includes(x.konak)).length);
  }
const uzakUcucu = KUME.filter((k) => UZAK.includes(k.konak) && k.omur <= 3600).length;
console.log(`\nuzak iki konaktaki ucucu kalem ${uzakUcucu}; 2400 saniyelik gecikmede ekip ` +
  `buyuklugu kaybi degistirmiyor`);
```

```
gecikme sn       kisi    kayip  uzak konak  merkez konak
0                   3        0           0             0
0                   6        0           0             0
600                 3        6           5             1
600                 6        5           5             0
1200                3        9           9             0
1200                6        9           9             0
2400                3        9           9             0
2400                6        9           9             0

uzak iki konaktaki ucucu kalem 10; 2400 saniyelik gecikmede ekip buyuklugu kaybi degistirmiyor
```

On yedinci varsayım zamanın sıfır noktasını "ekibin konaklara erişim kazandığı an" diye tanımladı ve
bütün konaklar için aynı anı kullandı. İki konak sahadadır; ekip oraya yolda olur. Altı yüz
saniyelik bir yol, doğru sırayla çalışan üç kişilik ekipte kaybı sıfırdan **altıya** çıkarıyor. Bin
iki yüz saniyede kayıp **dokuza** çıkıyor ve orada duruyor: iki saha konağındaki on uçucu kalemin
dokuzu ekip varmadan önce ömrünü dolduruyor, ayakta kalan tek kalem ömrü 3.600 saniye olan geçici
dosyadır.

Bu tablonun iki satırı ayrıca okunmalıdır. Altı yüz saniyede üç kişilik ekip altı, altı kişilik ekip
beş kalem kaybediyor; aradaki tek kalem merkezdedir ve uzak konağı bekleyen bir toplayıcının
kuyruğunda kalmıştır. Bin iki yüz saniyeden sonra ekip büyüklüğü hiçbir şeyi değiştirmiyor, çünkü
kaybedilen kalemler kimse varmadan önce kaybolmuştur. **Gecikme belli bir noktadan sonra ekip
büyüklüğünü ölçüsüz kılar.**

Birinci ders zinciri kısaltmanın beklenen açık kalemi 7,57'den 4,16'ya indirdiğini hesaplamış ve
bunun karşılığının "yetkin kişinin sahaya gitme süresi" olduğunu yazmıştı. Bu tablo o karşılığın
sayısıdır: bin iki yüz saniyelik bir yol, dokuz kalem eder.

## Yalnız Bellekten Yanıtlanan Soru

```js
// adli/kaynak.mjs — hangi soru hangi kaynaktan yanitlaniyor. MODELDIR.
const y = (g, ...s) => console.log(s.map((v, i) =>
  (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("").trimEnd());

// soru -> [bellek dokumu, disk imaji, uzak gunluk]  1: yanitlar, 0: yanitlamaz
const SORU = {
  "hangi surecler calisiyordu": [1, 0, 0],
  "surecin komut satiri neydi": [1, 0, 1],
  "hangi baglantilar etkindi": [1, 0, 1],
  "bellekte cozulmus icerik": [1, 0, 0],
  "etkin oturum belirteci": [1, 0, 0],
  "yuklu cekirdek modulu": [1, 1, 0],
  "yururlukteki yapilandirma": [1, 0, 0],
  "diskteki yapilandirma": [0, 1, 0],
  "dosya ne zaman degisti": [0, 1, 0],
  "silinmis dosyanin icerigi": [0, 1, 0],
  "kim oturum acti": [1, 1, 1],
  "kim hangi kayda eristi": [0, 0, 1],
};
const KAYNAK = ["bellek dokumu", "disk imaji", "uzak gunluk"];

const A = [-27, 15, 12, 13, 10];
y(A, "soru", ...KAYNAK, "kaynak");
for (const [s, v] of Object.entries(SORU))
  y(A, s, ...v.map((x) => (x ? "var" : "-")), v.reduce((a, x) => a + x, 0));

const yalniz = KAYNAK.map((_, i) =>
  Object.values(SORU).filter((v) => v[i] === 1 && v.reduce((a, x) => a + x, 0) === 1).length);
console.log("");
KAYNAK.forEach((k, i) => console.log(`${k}: dokundugu soru ` +
  `${Object.values(SORU).filter((v) => v[i]).length}, yalniz kendisinin yanitladigi ${yalniz[i]}`));
console.log(`iki ya da uc kaynaktan yanitlanan soru: ` +
  `${Object.values(SORU).filter((v) => v.reduce((a, x) => a + x, 0) > 1).length} / ` +
  `${Object.keys(SORU).length}`);
```

```
soru                         bellek dokumu  disk imaji  uzak gunluk    kaynak
hangi surecler calisiyordu             var           -            -         1
surecin komut satiri neydi             var           -          var         2
hangi baglantilar etkindi              var           -          var         2
bellekte cozulmus icerik               var           -            -         1
etkin oturum belirteci                 var           -            -         1
yuklu cekirdek modulu                  var         var            -         2
yururlukteki yapilandirma              var           -            -         1
diskteki yapilandirma                    -         var            -         1
dosya ne zaman degisti                   -         var            -         1
silinmis dosyanin icerigi                -         var            -         1
kim oturum acti                        var         var          var         3
kim hangi kayda eristi                   -           -          var         1

bellek dokumu: dokundugu soru 8, yalniz kendisinin yanitladigi 4
disk imaji: dokundugu soru 5, yalniz kendisinin yanitladigi 3
uzak gunluk: dokundugu soru 4, yalniz kendisinin yanitladigi 1
iki ya da uc kaynaktan yanitlanan soru: 4 / 12
```

On iki sorunun yalnız dördü birden çok kaynaktan yanıtlanıyor. Kalan sekizinde tek bir kaynak
vardır ve o kaynak toplanmamışsa soru **yanıtsız kalır** — başka bir kalemden çıkarım yapılamaz.
Bellek dökümü sekiz soruya değiyor ve dördünü tek başına yanıtlıyor; bu dördü aynı zamanda ömrü 900
saniye olan kalemlerdir.

Tabloda birbirine karıştırılan iki satır var: **yürürlükteki yapılandırma** ile **diskteki
yapılandırma**. İkisi ayrı sorudur ve ayrı kaynaklardan yanıtlanır. Bir sürecin belleğe okuduğu
ayar, diskteki dosya sonradan değiştirilmişse ondan farklıdır; bir olayda hangisinin geçerli olduğu
tam olarak sorulan şeydir. Disk imajı bu soruya yanıt veremez, yalnız ikinci soruya verir. Raporda
"yapılandırma şuydu" diye yazılan bir satır, hangi sorunun yanıtı olduğunu söylemiyorsa ölçülemez
bir iddiadır.

## Özet

- Uçuculuk sırası kalemlerin ömrüne göre artan sıralamasıdır; kurgu kümede 28 kalemin 18'i uçucudur
  ve hepsini toplamak 19.790 saniye tutar.
- Aynı küme üzerinde tek toplayıcıyla doğru sıra 7, konak konak toplama 12, en büyük kalem önce
  toplama 18 kalem kaybettirir; sonuncusu uçucu kalemlerin tamamıdır.
- Doğru sıra kaybı en aza indirir, sıfırlamaz: iki saha konağına 1.200 saniyelik varış gecikmesi,
  doğru sırayla çalışan ekipte kaybı 0'dan 9'a çıkarır ve o noktadan sonra ekip büyüklüğü sonucu
  değiştirmez.
- Üç kişi doğru sırayla 0 kayıp verir, altı kişi yanlış sırayla 13 kayıp verir; sıra ekip
  büyüklüğünden daha belirleyicidir.
- En hızlı biten toplama en çok kalem kaybedenidir, çünkü kaybolan kalem süre harcamaz; bitiş
  süresi ancak alınan kalem sayısıyla birlikte okunur.
- Bellek dökümü 12 sorunun 8'ine değer ve 4'ünü tek başına yanıtlar; sorulardan yalnız 4'ü birden
  çok kaynaktan yanıtlanabilir.

## Sonraki Adım

Bu ders kalemleri **ne zaman** toplandıklarına göre sıraladı. Toplandıktan sonra her kalem kendi
zaman damgalarını taşır: dosya değişim anları, oturum açma anları, akış kaydındaki bağlantı anları.
İncelemenin bir sonraki adımı bu damgaları tek bir çizgi üzerinde birleştirmektir ve orada
sessiz bir varsayım vardır — bütün kaynakların saatinin aynı olduğu.

Sonraki ders o varsayımı sınar. Üç kaynağın olayları tek bir zaman çizelgesinde birleştirilir, her
kaynağın saat kayması ölçülür ve iki sayı çıkarılır: kaç olay yanlış sıraya giriyor ve kayma
düzeltildiğinde kaç olay yer değiştiriyor. Sıralamanın bozulması bir gecikme değil, bir **neden
sonuç** hatasıdır: yanlış sırada okunan iki olay, birbirini doğuran iki olay gibi görünür.
