Mengintegrasikan sistem modern dengan sistem legacy sering kali melibatkan kendala hilangnya dokumentasi skema data. Ketika sistem lawas hanya mengekspor artefak biner mentah—seperti pada game BBS klasik era MS-DOS seperti Solar Realms Elite atau protokol industri lawas—engineer harus merekonstruksi tata letak memori asli secara manual agar dapat diubah ke format standar seperti JSON.
1. Analisis Awal: Hexdump dan Magic Bytes
Langkah awal merekonstruksi kontrak biner adalah memeriksa pola byte mentah menggunakan tool seperti hexdump atau xxd. Identifikasi dimulai dari header file:
$ xxd -g 1 -l 48 planet_data.bin
00000000: 53 52 45 31 01 00 00 00 45 61 72 74 68 00 00 00 SRE1....Earth...
00000010: 00 00 00 00 00 00 00 00 80 1a 06 00 00 00 00 00 ................
00000020: 00 40 9f 40 01 00 00 00 14 00 00 00 02 00 00 00 .@.@............Dua observasi kritis dari cuplikan biner di atas:
- Magic Bytes: Empat byte pertama bernilai ASCII
SRE1(0x53 0x52 0x45 0x31), berfungsi sebagai penanda format file dan versi skema. - Ukuran Record & Padding: String nama planet berjarak tepat 16 byte dengan terminasi null byte (
0x00). Nilai angka setelahnya tersimpan dalam format Little-Endian (standar arsitektur x86).
2. Deduksi Tipe Data dan Endianness
Sistem era C/Pascal pada platform x86 menyelaraskan variabel sesuai ukuran byte tipe primitif:
- Integer 16-bit: 2 byte (misal:
0x14 0x00= 20 decimal). - Integer 32-bit: 4 byte (misal:
0x80 0x1a 0x06 0x00=0x00061A80= 400.000). - Floating Point (IEEE 754 Single Precision): 4 byte (misal:
0x00 0x40 0x9f 0x40= 4.9765625).
Tantangan utama adalah struct alignment padding. Kompiler C sering menyisipkan padding 1-3 byte agar alokasi field berada pada kelipatan offset 4 byte.
3. Implementasi Safe Binary Parser
Parser biner modern harus memvalidasi batas buffer untuk mencegah buffer over-read atau alokasi memori tak terbatas akibat input corrupt.
import struct
from typing import Dict, Any, Optional
class CorruptedPayloadError(Exception):
pass
class SafeBinaryParser:
MAGIC_V1 = b"SRE1"
MAGIC_V2 = b"SRE2"
# Header: 4s (magic), I (version), 16s (name), Q (pop), f (tax_rate), I (ships)
SCHEMA_V1 = struct.Struct("<4sI16sQfI")
def __init__(self, data: bytes):
self.buffer = memoryview(data)
self.cursor = 0
self.total_size = len(data)
def read_exact(self, size: int) -> memoryview:
if self.cursor + size > self.total_size:
raise CorruptedPayloadError(
f"Out-of-bounds: butuh {size} byte di offset {self.cursor}, sisa buffer {self.total_size - self.cursor}"
)
chunk = self.buffer[self.cursor:self.cursor + size]
self.cursor += size
return chunk
def parse_record(self) -> Dict[str, Any]:
raw_bytes = self.read_exact(self.SCHEMA_V1.size)
magic, version, raw_name, population, tax_rate, ships = self.SCHEMA_V1.unpack(raw_bytes)
if magic != self.MAGIC_V1:
raise CorruptedPayloadError(f"Magic byte mismatch: expected {self.MAGIC_V1}, got {magic}")
name = raw_name.split(b"\x00", 1)[0].decode("ascii", errors="replace").strip()
return {
"schema_version": version,
"name": name,
"population": population,
"tax_rate": round(tax_rate, 4),
"ships": ships
}
def parse_with_fallback(self) -> Dict[str, Any]:
"""Skema fallback jika panjang payload tidak sesuai standar v1."""
start_offset = self.cursor
try:
return self.parse_record()
except CorruptedPayloadError:
# Reset pointer dan coba ekstraksi parsial (v2 dynamic string format)
self.cursor = start_offset
return self._parse_heuristic_fallback()
def _parse_heuristic_fallback(self) -> Dict[str, Any]:
if self.total_size < 8:
raise CorruptedPayloadError("Buffer terlalu kecil untuk fallback parser.")
magic = self.read_exact(4).tobytes()
version = struct.unpack("<I", self.read_exact(4))[0]
return {
"schema_version": version,
"magic": magic.decode("latin1"),
"status": "partial_recovery",
"raw_remaining_bytes": self.read_exact(self.total_size - self.cursor).tobytes().hex()
}4. Pengujian dan Validasi Boundary
Jalankan verifikasi sederhana untuk memastikan alur normal dan perlindungan out-of-bounds berjalan tepat:
def test_parser():
# Contoh record valid: 4s (SRE1) + I (1) + 16s (Earth) + Q (400000) + f (4.97) + I (20)
valid_blob = struct.pack("<4sI16sQfI", b"SRE1", 1, b"Earth\x00", 400000, 4.9765625, 20)
parser = SafeBinaryParser(valid_blob)
result = parser.parse_record()
assert result["name"] == "Earth"
assert result["population"] == 400000
# Uji deteksi payload terpotong (truncated payload)
truncated_blob = valid_blob[:12]
fallback_parser = SafeBinaryParser(truncated_blob)
recovered = fallback_parser.parse_with_fallback()
assert recovered["status"] == "partial_recovery"
test_parser()5. Mitigasi Risiko dan Best Practices
- Zero-copy Slicing: Gunakan
memoryviewalih-alih slicingbyteslangsung untuk menghindari alokasi memori berulang pada payload berukuran besar. - Validasi Input Strict: Selalu periksa nilai field numerik terhadap ambang batas logis (misal:
tax_ratetidak boleh bernilai negatif atau NaN). - Logging Deserialisasi: Buat audit log terpisah yang mencatat offset byte saat parser menemukan data yang memerlukan fallback parsing.
Komentar
0 komentar
Masuk ke akun kamu untuk ikut berkomentar.
Belum ada komentar
Jadilah yang pertama ikut berdiskusi!