Kurtardığınız dosya bir hayalet olabilir: yalnızca baytlardan bütünlük kontrolü
Bir sürücü üzerinde kurtarma aracı çalıştırıyorsunuz. İyi haber gibi görünen bir sayıyla bitiyor — 3.148 dosya bulundu. Sonra açmaya başlıyorsunuz. Belki yarısı çalışmıyor. Bazıları açılıyor ve gri bir dikdörtgen gösteriyor. Bazıları görüntüleyici tarafından kabul ediliyor ama yanlış resmi gösteriyor. Bazıları diskte 4 MB yer kaplıyor ama içinde hiçbir şey yok.
Kurtarma yazılımı size yalan söylemiyor. Dizin girdisini buldu: ad, boyut, dosyanın işgal ettiği konum. Bilamadığı şey, o girdinin arkasındaki kümelerin hâlâ ona ait kümeler olup olmadığıdır.
Dosya silmek onu silmez. NTFS'de girdi işaretlenir ve alan boş olarak işaretlenir; baytlar, üzerine başka bir şey yazılana kadar orada durur. Yani bağımsız üç farklı şey ters gidebilir ve kurtarma araçları üçünü de "bulundu" olarak raporlar.
Veri üzerine yazılmış. Ad geri gelmiştir; içerik artık başkasınındır.
Veri kısmen üzerine yazılmış. İlk N küme geri gelmiş, gerisi gitmiştir. İşin çetin olan budur — dosya makul bir boyuta ve doğru bir başlığa sahiptir, bazı görüntüleyicilerde açılırken çöp görüntüler.
Veri, elinize geçen dosyada hiç var olmadı. Araç dosyanın 4 MB olması gerektiğini biliyordu; o yüzden size 4 MB yazdı. İlk iki bayt ile son iki bayt biçimden gelir; aralarındaki her şey dolgudur.
Dosya sistemine hangi durumda olduğunuzu soramazsınız. Ama baytlara sorabilirsiniz.
Adım 1: baş ve son
Çoğu biçim başlangıca sabit bir imza ve sona bir bitiş bilgisi koyar. Hangisi eksikse dosya kesiktir.
| Biçim | Şununla başlamalı | Şununla bitmeli |
|---|---|---|
| JPEG | FF D8 FF | FF D9 (EOI) |
| PNG | 89 50 4E 47 0D 0A 1A 0A | IEND + CRC (49 45 4E 44 AE 42 60 82) |
%PDF- | son birkaç KB içinde %%EOF | |
| DOCX / XLSX / ZIP | PK | merkez dizin sonu 50 4B 05 06 |
| MP4 / MOV | bir ftyp kutusu | her iki uçtan birinde bir moov indeksi |
Asimetriye dikkat edin; çünkü bunu yanlış yapmak sağlam dosyaları bozuk işaretler. JPEG'in EOI'si gerçekten son iki bayttır; 2 baytlık bir pencereye bakarsınız. ZIP'in EOCD'si son 64 KB + 22 bayt içinde bir yerdedir; çünkü ardından bir arşiv yorumu gelebilir. PDF'in %%EOF'u sondaki 2 KB'nin herhangi bir yerinde olabilir — dosya artımlı güncellendiyse birden fazla da olabilir. Tüm biçimler için "son N baytı kontrol et" diye sabit kodlarsanız, bütün öğleden sonra yanlış alarm üretirsiniz.
Sonra MP4 vardır; orada bitiş bilgisi hiç sona denk gelmez. moov, mdat'ten önce ya da sonra durabilen üst düzey bir kutudur; kuyruk penceresi onu bulamaz. Bunun yerine kutu ağacında yürürsünüz — her kutu 4 baytlık bir boyut ve 4 baytlık bir türden oluşur; birinden diğerine atlayabilirsiniz:
async function hasMoov(blob) {
let off = 0;
for (let i = 0; i < 64; i++) {
const h = await range(blob, off, 16);
if (h.length < 8) return false;
if (String.fromCharCode(h[4], h[5], h[6], h[7]) === 'moov') return true;
let sz = h[0] * 2 ** 24 + h[1] * 2 ** 16 + h[2] * 256 + h[3];
if (sz === 1) { sz = 0; for (let k = 8; k < 16; k++) sz = sz * 256 + h[k]; }
if (sz === 0 || sz < 8) return false; // 0 means "extends to end of file"
off += sz;
if (off >= blob.size) return false;
}
return false;
}
Döngünün üst sınırı süs değildir. Kesik bir dosya size veri sonunu aşan bir kutu boyutu verir; sınırsız bir yürüyüş bunu sonsuza dek kovalamaktan çekinmez.
Adım 2: ortadaki delik
Her "geçerli mi" kontrolünü yenen durum şudur: doğru başlık, doğru bitiş bilgisi ve aralarında hiçbir şey.
Kurtarma araçları dosyayı bildirilen boyutuna düzenli olarak yeniden kurar. Ortayı tutan kümeler gitmişse araç dolgu yazar. Elinize ilk iki ve son iki baytı mükemmel, içeriği dolgu olan bir 4 MB JPEG geçer. Yalnızca başa ve sona bakan bir kontrol onu sağlam raporlar.
Bu yüzden ortadan örnek alırsınız. Ve bunun en bariz yolu — sıfır bayt saymak — içinden bir kurtarma işinin geçebileceği bir delik taşır.
Her araç sıfırla dolgu yapmaz. Bazıları 0xFF ile yapar. Bazıları kısa bir örüntüyü tekrar eder. Dedektörünüz if (zeroRatio > 0.98) ise, 0xFF ile doldurulmuş bir dosya düpedüz içinden geçer; ve bu dosyalar nadir değildir.
Çözüm, belirli bir değeri aramayı bırakıp çeşitlilik yokluğuna bakmaktır. Gerçek sıkıştırılmış verinin 8 KB'lık bir parçası fiilen 256 bayt değerinin hepsini kullanır. Dolgu parçası bir, belki dört değer kullanır. Bu ayrım her dolgu stilini aynı anda yakalar:
function analyze(u8) {
const seen = new Uint8Array(256);
let zero = 0;
for (let i = 0; i < u8.length; i++) { const b = u8[i]; if (b === 0) zero++; seen[b] = 1; }
let distinct = 0;
for (let i = 0; i < 256; i++) if (seen[i]) distinct++;
return { zeroRatio: +(zero / u8.length).toFixed(3), distinct };
}
const isHole = (a) => a.zeroRatio > 0.98 || (a.distinct > 0 && a.distinct <= 4);
Sıfır testini de tutun — yerini hak eder: birkaç baytın hayatta kaldığı %99 sıfır bir parça hâlâ bir deliktir ve %99 sıfır, diyelim ki, 30 farklı değer olarak görünür.
Adım 3: orantılı örnekleme
Eşit aralıklı üç nokta bitişik bir deliği yakalar; üzerine yazma genellikle bunu üretir. Ama 2 GB'lık bir videodaki üç nokta, 6 MB'lık bir boşluğu kaçırır — ve 6 MB, kayıp video olarak çoktur.
Bu yüzden sayıyı boyutla ölçekleyin ve sınırlandırın; çünkü örneklemenin tüm anlamı dosyayı okumamaktır:
function sampleOffsets(size) {
if (size < 128 * 1024) return [];
const n = Math.min(32, Math.max(3, Math.ceil(size / (4 * 1024 * 1024))));
const step = size / (n + 1);
const pts = [];
for (let i = 1; i <= n; i++) pts.push(Math.floor(i * step));
return pts;
}
Küçük dosyalar bilerek boş döner. Yaklaşık 128 KB'nin altında dosya tamamen kenardan ibarettir; ortası yoktur. Örneklemek sinyal değil gürültü üretir; küçük bir JPEG, sıradan bir içeriği olduğu için işaretlenebilirdi.
Bilinçli olarak nerede duruyor
Sıkıştırılmamış biçimler muaf. Gerçek bir siyah BMP gerçekten, doğru biçimde neredeyse tamamen sıfırdır. WAV'da bir dakikalık dijital sessizlik de öyle. Bunların üzerinden delik dedektörü çalıştırırsanız kusursuz sağlam dosyaları mahkûm edersiniz; önce biçime bakın ve sıkıştırılmamışsa örnekleme yapmayın. İçeriği yargılamadan önce türü bilmenin önemli olduğu tek yer burasıdır.
Yapı, içerik değildir. SOI'si, EOI'si olan ve deliği olmayan bir JPEG yine de yanlış fotoğrafı içerebilir; çünkü yeniden kurulduğu kümeler, tesadüfen yakında duran başka bir dosyaya aitti. Bunu hiçbir bayt düzeyi kontrol saptayamaz. Yalnızca açan bir insan saptayabilir.
Hasarlı, değersiz demek değildir. Kısmi dediğimiz dosya, hayatta kalan kesri taşır. Özellikle foto kurtarmada: kuyruğu eksik bir JPEG çoğu zaman görüntünün çoğunu hâlâ gösterir ve bir fotoğrafın tek kopyasıysa, "görüntünün çoğu" çok iyi bir sonuçtur. Bir kontrol aracının sizi bir şeyi silmeye ikna etmesine izin vermeyin.
Ve bir dosya sistemi notu; çünkü işe başlamadan şansınızı değiştirir: ext4, silmede blok işaretçilerini temizler; NTFS çoğunlukla bırakır. ext4'teki dosya adları genellikle tamamen kaybolur; bu yüzden Linux kurtarması, verinin kendisi hayatta kalmış olsa bile Windows kurtarmasından zordur. ext4 biriminde çalışıyorsanız canlı USB'den yapın — asla kurulu sistemden değil; o, kurtarmaya çalıştığınız diskin ta kendisine yazan sistemdir.
Bütün halinde, yapıştırmaya hazır
Birleştirildi. Bir File (ya da Blob) alır, yalnızca ihtiyaç duyulan pencereleri Blob.slice() üzerinden okur — tembeldir; baytları isteyene kadar hiçbir şey okunmaz — ve arkasındaki kanıtlarla birlikte bir hüküm döndürür.
DevTools konsoluna yapıştırın; sonra elinizdeki bir dosya tanıtıcısıyla çağırın ya da bir bırakma hedefi kurup bir klasörü içeri sürükleyin:
document.addEventListener('dragover', (e) => e.preventDefault());
document.addEventListener('drop', async (e) => {
e.preventDefault();
console.table(await ghostCheck.bulk(e.dataTransfer.files));
});
const ghostCheck = (() => {
const KB = 1024, MB = 1024 * 1024;
const CHUNK = 8 * KB;
const MIN_SAMPLABLE = 128 * KB;
// Blob.slice() is lazy: nothing is read until you ask for the bytes.
async function range(blob, start, len) {
const s = Math.max(0, Math.round(start));
const e = Math.min(blob.size, s + len);
if (e <= s) return new Uint8Array(0);
return new Uint8Array(await blob.slice(s, e).arrayBuffer());
}
function startsWith(u8, sig) {
if (u8.length < sig.length) return false;
for (let i = 0; i < sig.length; i++) if (u8[i] !== sig[i]) return false;
return true;
}
function indexOf(u8, sig) {
outer: for (let i = 0; i + sig.length <= u8.length; i++) {
for (let j = 0; j < sig.length; j++) if (u8[i + j] !== sig[j]) continue outer;
return i;
}
return -1;
}
const ascii = (s) => [...s].map((c) => c.charCodeAt(0));
function analyze(u8) {
const seen = new Uint8Array(256);
let zero = 0;
for (let i = 0; i < u8.length; i++) { const b = u8[i]; if (b === 0) zero++; seen[b] = 1; }
let distinct = 0;
for (let i = 0; i < 256; i++) if (seen[i]) distinct++;
return { zeroRatio: +(zero / u8.length).toFixed(3), distinct };
}
// A hole is not always zeros. Recovery tools pad with 0x00, sometimes 0xFF,
// sometimes a short repeating pattern. Both look the same from here:
// a chunk of real compressed data uses ~256 distinct byte values; padding uses ~1.
const isHole = (a) => a.zeroRatio > 0.98 || (a.distinct > 0 && a.distinct <= 4);
function sampleOffsets(size) {
if (size < MIN_SAMPLABLE) return [];
const n = Math.min(32, Math.max(3, Math.ceil(size / (4 * MB))));
const step = size / (n + 1);
const pts = [];
for (let i = 1; i <= n; i++) pts.push(Math.floor(i * step));
return pts;
}
const FORMATS = [
{ id: 'jpeg', label: 'JPEG', head: [0xff, 0xd8, 0xff], tail: [0xff, 0xd9], tailWindow: 2, compressed: true },
{ id: 'png', label: 'PNG', head: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a], tail: [0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82], tailWindow: 16, compressed: true },
{ id: 'zip', label: 'ZIP / Office', head: [0x50, 0x4b], tail: [0x50, 0x4b, 0x05, 0x06], tailWindow: 65557, compressed: true },
{ id: 'pdf', label: 'PDF', head: ascii('%PDF-'), tailText: '%%EOF', tailWindow: 2048, compressed: true },
{ id: 'bmp', label: 'BMP', head: ascii('BM'), compressed: false },
{ id: 'wav', label: 'WAV', head: ascii('RIFF'), compressed: false },
];
const FTYP = ascii('ftyp');
// Walk top-level ISO-BMFF boxes looking for `moov`. Capped: a truncated file
// can point the offset past the end, and stopping beats looping.
async function hasMoov(blob) {
let off = 0;
for (let i = 0; i < 64; i++) {
const h = await range(blob, off, 16);
if (h.length < 8) return false;
if (String.fromCharCode(h[4], h[5], h[6], h[7]) === 'moov') return true;
let sz = h[0] * 2 ** 24 + h[1] * 2 ** 16 + h[2] * 256 + h[3];
if (sz === 1) { // 64-bit extended size
sz = 0;
for (let k = 8; k < 16; k++) sz = sz * 256 + h[k];
}
if (sz === 0 || sz < 8) return false; // 0 means "to end of file"
off += sz;
if (off >= blob.size) return false;
}
return false;
}
async function check(blob) {
const size = blob.size;
let bytesRead = 0;
const headBytes = await range(blob, 0, 16); bytesRead += headBytes.length;
const fmt = FORMATS.find((f) => startsWith(headBytes, f.head)) || null;
let type = fmt ? fmt.label : 'unknown';
const compressed = fmt ? fmt.compressed : true;
if (!fmt && startsWith(headBytes.subarray(4, 8), FTYP)) type = 'MP4 / MOV';
let tail = null; // null = this format has no terminator worth checking
if (type === 'MP4 / MOV') {
tail = await hasMoov(blob);
} else if (fmt && (fmt.tail || fmt.tailText)) {
const sig = fmt.tail || ascii(fmt.tailText);
const win = await range(blob, size - fmt.tailWindow, fmt.tailWindow);
bytesRead += win.length;
tail = indexOf(win, sig) >= 0;
}
const holes = [];
let minDistinct = null;
if (compressed) {
for (const at of sampleOffsets(size)) {
const c = await range(blob, at, CHUNK); bytesRead += c.length;
if (c.length < 512) continue;
const a = analyze(c);
if (minDistinct === null || a.distinct < minDistinct) minDistinct = a.distinct;
if (isHole(a)) holes.push({ at, ...a });
}
}
const cut = tail === false;
const holey = holes.length > 0;
let verdict;
if (type === 'unknown') verdict = 'UNRECOGNISED';
else if (!cut && !holey) verdict = tail === null ? 'PLAUSIBLE (no terminator)' : 'INTACT';
else if (!cut && holey) verdict = 'GHOST';
else if (cut && holey) verdict = 'GHOST + PARTIAL';
else verdict = 'PARTIAL';
return {
type, size, tail: tail === null ? '—' : tail, holes: holes.length,
minDistinct: minDistinct === null ? '—' : minDistinct,
kbRead: +(bytesRead / 1024).toFixed(2), verdict,
};
}
check.bulk = async (files) => Promise.all(
[...files].map(async (f) => ({ file: f.name, ...(await check(f)) }))
);
return check;
})();
Sentetik dosyalara karşı — EOI'sinden önce kesilmiş tam bir JPEG, tam bir PNG, EOCD'siz bir DOCX, tek delikli bir JPEG, dolgulu bir JPEG, aynısının sıfır yerine 0xFF ile doldurulmuşu, meşru bir siyah BMP, tam ve kesik bir MP4 ve 40 KB'lık bir küçük resim:
┌─────────┬──────────────────────┬────────────────┬───────┬───────┬─────────────┬────────┬─────────────────────────────┐
│ (index) │ file │ type │ tail │ holes │ minDistinct │ kbRead │ verdict │
├─────────┼──────────────────────┼────────────────┼───────┼───────┼─────────────┼────────┼─────────────────────────────┤
│ 0 │ 'photo-complete.jpg' │ 'JPEG' │ true │ 0 │ 256 │ 24.02 │ 'INTACT' │
│ 1 │ 'photo-cut.jpg' │ 'JPEG' │ false │ 0 │ 256 │ 24.02 │ 'PARTIAL' │
│ 2 │ 'scan.png' │ 'PNG' │ true │ 0 │ 256 │ 24.03 │ 'INTACT' │
│ 3 │ 'report.docx' │ 'ZIP / Office' │ false │ 0 │ 256 │ 88.04 │ 'PARTIAL' │
│ 4 │ 'photo-hole.jpg' │ 'JPEG' │ true │ 2 │ 1 │ 24.02 │ 'GHOST' │
│ 5 │ 'photo-ghost.jpg' │ 'JPEG' │ true │ 3 │ 1 │ 24.02 │ 'GHOST' │
│ 6 │ 'photo-ghost-ff.jpg' │ 'JPEG' │ true │ 3 │ 1 │ 24.02 │ 'GHOST' │
│ 7 │ 'black.bmp' │ 'BMP' │ '—' │ 0 │ '—' │ 0.02 │ 'PLAUSIBLE (no terminator)' │
│ 8 │ 'clip.mp4' │ 'MP4 / MOV' │ true │ 0 │ 256 │ 24.02 │ 'INTACT' │
│ 9 │ 'clip-truncated.mp4' │ 'MP4 / MOV' │ false │ 0 │ 256 │ 24.02 │ 'PARTIAL' │
│ 10 │ 'thumb-small.jpg' │ 'JPEG' │ true │ 0 │ '—' │ 0.02 │ 'INTACT' │
└─────────┴──────────────────────┴────────────────┴───────┴───────┴─────────────┴────────┴─────────────────────────────┘
Oradaki üç satır, çabanın karşılığını veren satırlardır.
6. satır 0xFF ile doldurulmuş dosyadır. Baş sağlam, son sağlam, içinde tek bir sıfır bayt yok. Sıfır sayan bir dedektör onu tertemiz puanlar.
7. satır gerçek bir siyah BMP'dir; sıkıştırılmamış olduğu için delik tespitinden muaftır. Neredeyse tamamen sıfırdır ve kusursuz sağlam bir dosyadır.
3. satır 500 KB'lık bir dosyaya hükmetmek için 88 KB okudu; çünkü ZIP'in merkez dizin sonu, son 64 KB'nin herhangi bir yerinde saklanabilir. Biçim başına pencerelerin bedeli budur — ve yine de dosyanın beşte biridir, bütününden iyidir.
Uygulama notları
Bunu kurtarılan dosyaları açmadan önce çalıştırın, sonra değil. Hasarlı bir dosyayı açmak genellikle zararsızdır; ama onu yazan bir uygulamayla açmak — küçük resim üreten bir fotoğraf editörü, kilit dosyası oluşturan bir veritabanı — kurtardığınız sürücünün ta kendisine yazar.
Kurtarma aracının bildirdiği boyutu gerçekte aldığınız boyutla karşılaştırın. Araç 4 MB dedi ve diskteki dosya 900 KB ise, yukarıdakilerin hiçbirine ihtiyacınız yok.
Her şeyden önce hükme göre sıralayın ve sağlamları önce kopyalayın. Aktif olarak bozulan bir sürücüde, seçtiğiniz araçtan çok, hangi sırayla çalıştığınız değerlidir.
Bu yazı nasıl yazıldı
Önce ifşa: bu yazının taslağı, seçtiğim bir sorundan ve tek bir daimi talimattan yola çıkan bir yapay zekâ ajanı tarafından yazıldı — hiçbir iddia çalıştırılmadan yazıya geçmez. Yukarıdaki tablodaki on bir test durumu bayt dizileri olarak kuruldu, fonksiyona verildi ve çıktıları buraya yapıştırıldı. Hiçbiri temsili değil.
Ne kazandırdığını söyleyeceğim; çünkü bu sürecin okumaya değer tek yanı orası.
Asıl plan, oyuk bir dosyayı en bariz yolla saptamaktı: ortadaki sıfır baytları say ve "boş" de. Sonra 0x00 yerine 0xFF ile doldurulmuş sahte bir JPEG kurdum — baş sağlam, son sağlam, iki megabyte boşluk ve hiçbir yerde tek bir sıfır bayt yok. Naif kontrol onu sağlıklı dosya olarak raporladı. Bulabildiğim her "kurtarılan dosyalarınızı doğrulayın" kod parçası da öyle; çünkü hepsi tek bir soru soruyordu ve soru yanlıştı.
Bu, yazıdaki gerçek kuralı üretti: dosyanın bir parçasının çeşitliliği olup olmadığını sorun, sıfırı olup olmadığını değil. Gerçek sıkıştırılmış veri 8 KB'lık bir örnekte 256 bayt değerinin hepsine dokunur. Dolgu birine. Yeniden çerçevelenen soru, aynı üç satırla sıfır dolguyu, 0xFF dolgusunu ve kısa tekrarlı örüntüleri yakalar.
Ki bu, genel bir şeyin küçük ve özgül bir halidir: testler yazmaktan daha değerliydi. Bir model, her iki yaklaşım hakkında da aynı saniyelerde kendinden emin bir paragraf yazar. Hangisinin yanlış olduğunu yalnızca çalıştırma söyler.