Create Generator.py

Generator.py

@@ -0,0 +1,820 @@
+"""
+Turns PE binaries into 6-channel 3D tensors for a CNN.
+
+Each channel encodes a different semantic signal so the model isn't just
+memorizing raw byte patterns:
+    0 - raw byte values (normalized)
+    1 - local entropy (high = encrypted/compressed/packed)
+    2 - executable section mask (where the actual code lives)
+    3 - import density (proximity to import tables, behavioral signal)
+    4 - string density (ASCII-heavy regions = function names, strings, etc.)
+    5 - data presence mask (1 where we have real bytes, 0 where it's padding)
+
+Bytes get folded into 3D via a Morton/Z-order curve so spatially nearby
+bytes stay nearby in the volume. This preserves locality better than
+naive reshape.
+
+Usage:
+    python malware_3d_multichannel.py -i ./samples -o ./tensors_5ch
+"""
+
+import os
+import argparse
+import numpy as np
+import matplotlib.pyplot as plt
+from pathlib import Path
+from tqdm import tqdm
+import json
+import struct
+import math
+from collections import defaultdict
+
+
+class PEParserExtended:
+    """
+    Rips apart PE headers and sections to get the bytes we actually care about,
+    plus metadata about what lives where (code vs imports vs data).
+    
+    We skip resource/reloc/debug sections since they're mostly noise for
+    malware classification. .text, .rdata, .idata, .data are what matter.
+    """
+
+    RELEVANT_SECTIONS = {
+        b'.text', b'.code', b'CODE', b'.TEXT',
+        b'.rdata', b'.rodata', b'.idata',
+        b'.data', b'.DATA',
+        b'.edata',
+    }
+
+    SKIP_SECTIONS = {
+        b'.rsrc', b'.reloc', b'.pdata', b'.tls',
+        b'.debug', b'.didat', b'.sxdata',
+    }
+
+    CODE_SECTIONS = {b'.text', b'.code', b'CODE', b'.TEXT'}
+
+    IMAGE_DIRECTORY_ENTRY_EXPORT = 0
+    IMAGE_DIRECTORY_ENTRY_IMPORT = 1
+    IMAGE_DIRECTORY_ENTRY_IAT = 12
+
+    def __init__(self, filepath: str):
+        self.filepath = filepath
+        self.valid = False
+        self.headers = b''
+        self.sections = {}
+        self.section_info = []
+        self.data_directories = []
+        self.import_ranges = []
+        self._parse()
+
+    def _parse(self):
+        try:
+            with open(self.filepath, 'rb') as f:
+                if not self._validate_pe(f):
+                    return
+
+                self._parse_data_directories(f)
+                self._find_import_ranges(f)
+
+                f.seek(0)
+                self.headers = f.read(self.pe_header_end)
+                self._parse_sections(f)
+                self.valid = True
+
+        except (IOError, OSError, struct.error):
+            self.valid = False
+
+    def _validate_pe(self, f) -> bool:
+        f.seek(0, 2)
+        self.file_size = f.tell()
+        if self.file_size < 64:
+            return False
+
+        f.seek(0)
+        if f.read(2) != b'MZ':
+            return False
+
+        f.seek(0x3C)
+        pe_offset = struct.unpack('<I', f.read(4))[0]
+
+        if pe_offset + 4 > self.file_size:
+            return False
+
+        f.seek(pe_offset)
+        if f.read(4) != b'PE\x00\x00':
+            return False
+
+        self.pe_offset = pe_offset
+
+        self.machine = struct.unpack('<H', f.read(2))[0]
+        self.num_sections = struct.unpack('<H', f.read(2))[0]
+        f.read(12)  # skip timestamp, symbol table ptr, symbol count
+        self.optional_header_size = struct.unpack('<H', f.read(2))[0]
+        self.characteristics = struct.unpack('<H', f.read(2))[0]
+
+        self.optional_header_offset = pe_offset + 24
+        self.section_table_offset = pe_offset + 24 + self.optional_header_size
+        self.pe_header_end = self.section_table_offset + (self.num_sections * 40)
+
+        return True
+
+    def _parse_data_directories(self, f):
+        """Grab the data directory entries so we can find import/export tables."""
+        f.seek(self.optional_header_offset)
+        magic = struct.unpack('<H', f.read(2))[0]
+
+        # PE32 vs PE32+ have the data dirs at different offsets
+        if magic == 0x10b:
+            f.seek(self.optional_header_offset + 92)
+        elif magic == 0x20b:
+            f.seek(self.optional_header_offset + 108)
+        else:
+            return
+
+        num_data_dirs = struct.unpack('<I', f.read(4))[0]
+        num_data_dirs = min(num_data_dirs, 16)
+
+        for i in range(num_data_dirs):
+            rva = struct.unpack('<I', f.read(4))[0]
+            size = struct.unpack('<I', f.read(4))[0]
+            self.data_directories.append((rva, size))
+
+    def _rva_to_file_offset(self, rva, f):
+        """Walk the section table to figure out where an RVA lands on disk."""
+        f.seek(self.section_table_offset)
+
+        for i in range(self.num_sections):
+            section_header = f.read(40)
+            if len(section_header) < 40:
+                break
+
+            virtual_size = struct.unpack('<I', section_header[8:12])[0]
+            virtual_addr = struct.unpack('<I', section_header[12:16])[0]
+            raw_size = struct.unpack('<I', section_header[16:20])[0]
+            raw_offset = struct.unpack('<I', section_header[20:24])[0]
+
+            if virtual_addr <= rva < virtual_addr + max(virtual_size, raw_size):
+                return raw_offset + (rva - virtual_addr)
+
+        return None
+
+    def _find_import_ranges(self, f):
+        """Use the actual data directory entries to locate import data on disk."""
+        self.import_ranges = []
+
+        if len(self.data_directories) > self.IMAGE_DIRECTORY_ENTRY_IMPORT:
+            rva, size = self.data_directories[self.IMAGE_DIRECTORY_ENTRY_IMPORT]
+            if rva > 0 and size > 0:
+                offset = self._rva_to_file_offset(rva, f)
+                if offset is not None:
+                    self.import_ranges.append((offset, size))
+                    self._parse_import_descriptors(f, offset, rva)
+
+        # IAT is separate from the import directory
+        if len(self.data_directories) > self.IMAGE_DIRECTORY_ENTRY_IAT:
+            rva, size = self.data_directories[self.IMAGE_DIRECTORY_ENTRY_IAT]
+            if rva > 0 and size > 0:
+                offset = self._rva_to_file_offset(rva, f)
+                if offset is not None:
+                    self.import_ranges.append((offset, size))
+
+    def _parse_import_descriptors(self, f, import_dir_offset, import_dir_rva):
+        """
+        Chase the import descriptors to find DLL name strings and thunk arrays.
+        These are the regions that tell us what APIs the binary calls.
+        """
+        try:
+            f.seek(import_dir_offset)
+            max_descriptors = 1000  # way beyond any legit PE, just a safety net
+
+            for _ in range(max_descriptors):
+                desc = f.read(20)
+                if len(desc) < 20:
+                    break
+
+                original_first_thunk = struct.unpack('<I', desc[0:4])[0]
+                name_rva = struct.unpack('<I', desc[12:16])[0]
+                first_thunk = struct.unpack('<I', desc[16:20])[0]
+
+                # null terminator = end of import descriptors
+                if name_rva == 0 and first_thunk == 0 and original_first_thunk == 0:
+                    break
+
+                if name_rva > self.file_size or first_thunk > self.file_size:
+                    break
+
+                # grab the DLL name string region
+                if name_rva > 0 and len(self.import_ranges) < 500:
+                    name_offset = self._rva_to_file_offset(name_rva, f)
+                    if name_offset is not None and name_offset < self.file_size:
+                        self.import_ranges.append((name_offset, min(256, self.file_size - name_offset)))
+
+                # grab the thunk array (function name hints / ordinals)
+                thunk_rva = original_first_thunk if original_first_thunk else first_thunk
+                if thunk_rva > 0 and len(self.import_ranges) < 500:
+                    thunk_offset = self._rva_to_file_offset(thunk_rva, f)
+                    if thunk_offset is not None and thunk_offset < self.file_size:
+                        self.import_ranges.append((thunk_offset, min(512, self.file_size - thunk_offset)))
+
+        except:
+            pass  # malware loves corrupt import tables, just bail
+
+    def _parse_sections(self, f):
+        f.seek(self.section_table_offset)
+        current_offset = len(self.headers)
+
+        for i in range(self.num_sections):
+            section_header = f.read(40)
+            if len(section_header) < 40:
+                break
+
+            name = section_header[0:8].rstrip(b'\x00')
+            virtual_size = struct.unpack('<I', section_header[8:12])[0]
+            virtual_addr = struct.unpack('<I', section_header[12:16])[0]
+            raw_size = struct.unpack('<I', section_header[16:20])[0]
+            raw_offset = struct.unpack('<I', section_header[20:24])[0]
+            characteristics = struct.unpack('<I', section_header[36:40])[0]
+
+            is_code = (characteristics & 0x20000000) != 0  # IMAGE_SCN_MEM_EXECUTE
+
+            info = {
+                'name': name,
+                'name_str': name.decode('utf-8', errors='replace'),
+                'virtual_size': virtual_size,
+                'virtual_addr': virtual_addr,
+                'raw_size': raw_size,
+                'raw_offset': raw_offset,
+                'characteristics': characteristics,
+                'is_code': is_code or name in self.CODE_SECTIONS,
+                'extracted': False,
+                'output_start': None,
+                'output_end': None,
+            }
+
+            is_relevant = name in self.RELEVANT_SECTIONS
+            is_skip = name in self.SKIP_SECTIONS
+
+            if (is_relevant or is_code) and not is_skip:
+                if raw_size > 0 and raw_offset + raw_size <= self.file_size:
+                    current_pos = f.tell()
+                    f.seek(raw_offset)
+                    section_data = f.read(raw_size)
+                    f.seek(current_pos)
+
+                    self.sections[name] = section_data
+                    info['extracted'] = True
+                    info['output_start'] = current_offset
+                    info['output_end'] = current_offset + len(section_data)
+                    current_offset += len(section_data)
+
+            self.section_info.append(info)
+
+    def get_relevant_bytes(self) -> bytes:
+        if not self.valid:
+            return b''
+
+        result = bytearray(self.headers)
+
+        # deterministic ordering: code first, then read-only data, then writable
+        section_order = [
+            b'.text', b'.code', b'CODE', b'.TEXT',
+            b'.rdata', b'.rodata',
+            b'.idata',
+            b'.data', b'.DATA',
+            b'.edata',
+        ]
+
+        for name in section_order:
+            if name in self.sections:
+                result.extend(self.sections[name])
+
+        # anything we didn't explicitly order goes at the end
+        for name, data in self.sections.items():
+            if name not in section_order:
+                result.extend(data)
+
+        return bytes(result)
+
+    def get_section_masks(self, total_length: int) -> dict:
+        """
+        Build per-byte masks that say "this byte is code" or "this byte is
+        import-related". We need these as channels for the CNN.
+
+        Uses range-based mapping instead of a byte-by-byte dict because
+        that was absurdly slow on large binaries.
+        """
+        code_mask = np.zeros(total_length, dtype=np.float32)
+        import_mask = np.zeros(total_length, dtype=np.float32)
+
+        header_len = len(self.headers)
+
+        section_order = [
+            b'.text', b'.code', b'CODE', b'.TEXT',
+            b'.rdata', b'.rodata',
+            b'.idata',
+            b'.data', b'.DATA',
+            b'.edata',
+        ]
+
+        # we need to track the mapping from original file offsets to our
+        # rearranged output offsets so we can place import ranges correctly
+        offset_mappings = []
+        offset_mappings.append((0, 0, min(header_len, total_length)))
+
+        output_offset = header_len
+
+        for name in section_order:
+            if name in self.sections and output_offset < total_length:
+                section_len = len(self.sections[name])
+
+                for info in self.section_info:
+                    if info['name'] == name and info['extracted']:
+                        file_offset = info['raw_offset']
+                        usable_len = min(section_len, total_length - output_offset)
+                        offset_mappings.append((file_offset, output_offset, usable_len))
+
+                        if info['is_code']:
+                            end = min(output_offset + section_len, total_length)
+                            code_mask[output_offset:end] = 1.0
+
+                        break
+
+                output_offset += section_len
+
+        for name, data in self.sections.items():
+            if name not in section_order and output_offset < total_length:
+                section_len = len(data)
+
+                for info in self.section_info:
+                    if info['name'] == name and info['extracted']:
+                        file_offset = info['raw_offset']
+                        usable_len = min(section_len, total_length - output_offset)
+                        offset_mappings.append((file_offset, output_offset, usable_len))
+
+                        if info['is_code']:
+                            end = min(output_offset + section_len, total_length)
+                            code_mask[output_offset:end] = 1.0
+
+                        break
+
+                output_offset += section_len
+
+        # now project the import ranges (which are in original file coords)
+        # into our rearranged output coords
+        for import_file_offset, import_size in self.import_ranges:
+            for file_start, out_start, length in offset_mappings:
+                file_end = file_start + length
+
+                if import_file_offset < file_end and import_file_offset + import_size > file_start:
+                    overlap_start = max(import_file_offset, file_start)
+                    overlap_end = min(import_file_offset + import_size, file_end)
+
+                    out_overlap_start = out_start + (overlap_start - file_start)
+                    out_overlap_end = out_start + (overlap_end - file_start)
+
+                    out_overlap_start = max(0, min(out_overlap_start, total_length))
+                    out_overlap_end = max(0, min(out_overlap_end, total_length))
+
+                    if out_overlap_end > out_overlap_start:
+                        import_mask[out_overlap_start:out_overlap_end] = 1.0
+
+        return {
+            'code': code_mask,
+            'import': import_mask
+        }
+
+    def get_stats(self) -> dict:
+        extracted_size = len(self.headers) + sum(len(d) for d in self.sections.values())
+
+        return {
+            'file_size': self.file_size,
+            'extracted_size': extracted_size,
+            'compression_ratio': extracted_size / self.file_size if self.file_size > 0 else 0,
+            'num_sections': self.num_sections,
+            'extracted_sections': [s['name_str'] for s in self.section_info if s['extracted']],
+            'skipped_sections': [s['name_str'] for s in self.section_info if not s['extracted']],
+            'import_ranges_found': len(self.import_ranges),
+        }
+
+
+# --- Feature extraction ---
+# Each of these produces a 1D float32 array the same length as the input,
+# which later gets folded into the 3D volume as a separate channel.
+
+def compute_block_entropy(data: np.ndarray, block_size: int = 256) -> np.ndarray:
+    """
+    Shannon entropy per fixed-size block, upsampled back to full resolution.
+    Using blocks instead of a sliding window keeps this O(n) and avoids
+    the weird edge artifacts you get with windowed approaches.
+    """
+    n = len(data)
+    if n == 0:
+        return np.zeros(0, dtype=np.float32)
+
+    n_blocks = max(1, (n + block_size - 1) // block_size)
+    block_entropies = np.zeros(n_blocks, dtype=np.float32)
+
+    for i in range(n_blocks):
+        start = i * block_size
+        end = min(start + block_size, n)
+        block = data[start:end]
+
+        if len(block) == 0:
+            continue
+
+        counts = np.bincount(block, minlength=256)
+        probs = counts[counts > 0] / len(block)
+        block_entropies[i] = -np.sum(probs * np.log2(probs)) / 8.0  # normalize to [0,1]
+
+    entropy = np.repeat(block_entropies, block_size)[:n]
+    return entropy.astype(np.float32)
+
+
+def compute_string_density(data: np.ndarray, window_size: int = 64) -> np.ndarray:
+    """
+    Sliding window ratio of printable ASCII bytes. Regions with high density
+    are likely string tables, function names, debug info. stuff that's
+    semantically meaningful even if it's not code.
+    """
+    n = len(data)
+    if n == 0:
+        return np.zeros(n, dtype=np.float32)
+
+    is_printable = ((data >= 32) & (data <= 126)).astype(np.float32)
+    kernel = np.ones(window_size) / window_size
+    density = np.convolve(is_printable, kernel, mode='same').astype(np.float32)
+    return density
+
+
+def compute_import_density(data: np.ndarray, import_mask: np.ndarray,
+                           window_size: int = 128) -> np.ndarray:
+    """
+    Spread the binary import mask with a gaussian kernel so nearby bytes
+    also get some import signal. The idea is that the bytes surrounding
+    import tables are contextually related even if they're not literally
+    inside the directory entry.
+    """
+    n = len(data)
+    if n == 0:
+        return np.zeros(n, dtype=np.float32)
+
+    kernel = np.exp(-np.linspace(-2, 2, window_size)**2)
+    kernel = kernel / kernel.sum()
+
+    density = np.convolve(import_mask, kernel, mode='same').astype(np.float32)
+
+    if density.max() > 0:
+        density = density / density.max()
+
+    return density
+
+
+# --- Space-filling curve ---
+
+class SpaceFillingCurve:
+    """
+    Morton / Z-order curve: maps a linear byte index to (x, y, z) coords
+    by interleaving bits. This keeps bytes that are close in the file close
+    in 3D space, which matters for conv filters.
+    """
+
+    def __init__(self, order: int):
+        self.order = order
+        self.size = 2 ** order
+        self.total_points = self.size ** 3
+        self._build_lookup_table()
+
+    def _build_lookup_table(self):
+        print(f"Building space-filling curve lookup table ({self.size}³ = {self.total_points:,} points)...")
+        self.lookup = np.zeros((self.total_points, 3), dtype=np.int32)
+
+        for d in tqdm(range(self.total_points), desc="Building lookup", leave=False):
+            x = y = z = 0
+            for i in range(self.order):
+                x |= ((d >> (3 * i)) & 1) << i
+                y |= ((d >> (3 * i + 1)) & 1) << i
+                z |= ((d >> (3 * i + 2)) & 1) << i
+            self.lookup[d] = (x, y, z)
+
+    def get_all_coords(self) -> np.ndarray:
+        return self.lookup
+
+
+# --- Core conversion: PE file -> 6-channel 3D tensor ---
+
+def pe_to_multichannel_3d(
+    filepath: str,
+    order: int = 6,
+    curve: SpaceFillingCurve = None,
+    entropy_block_size: int = 256,
+    string_window: int = 64,
+    import_window: int = 128,
+) -> tuple:
+    """
+    The main pipeline. Parses the PE, extracts relevant sections, computes
+    all the per-byte features, then folds everything into a 3D volume via
+    the Morton curve.
+
+    Returns (tensor [6, D, H, W], stats_dict).
+    """
+    if curve is None:
+        curve = SpaceFillingCurve(order)
+
+    pe = PEParserExtended(filepath)
+
+    if not pe.valid:
+        raise ValueError(f"Invalid PE file: {filepath}")
+
+    relevant_bytes = pe.get_relevant_bytes()
+    stats = pe.get_stats()
+
+    # truncate to what fits in the volume (or pad with zeros implicitly)
+    max_bytes = curve.total_points
+    bytes_array = np.frombuffer(relevant_bytes[:max_bytes], dtype=np.uint8)
+    num_bytes = len(bytes_array)
+
+    masks = pe.get_section_masks(num_bytes)
+
+    # compute all 1D feature channels
+    raw_normalized = bytes_array.astype(np.float32) / 255.0
+    entropy = compute_block_entropy(bytes_array, block_size=entropy_block_size)
+    code_mask = masks['code']
+    import_density = compute_import_density(bytes_array, masks['import'], window_size=import_window)
+    string_density = compute_string_density(bytes_array, window_size=string_window)
+
+    # scatter 1D features into the 3D volume along the curve
+    tensor = np.zeros((6, curve.size, curve.size, curve.size), dtype=np.float32)
+    coords = curve.get_all_coords()[:num_bytes]
+
+    tensor[0, coords[:, 0], coords[:, 1], coords[:, 2]] = raw_normalized
+    tensor[1, coords[:, 0], coords[:, 1], coords[:, 2]] = entropy
+    tensor[2, coords[:, 0], coords[:, 1], coords[:, 2]] = code_mask
+    tensor[3, coords[:, 0], coords[:, 1], coords[:, 2]] = import_density
+    tensor[4, coords[:, 0], coords[:, 1], coords[:, 2]] = string_density
+    tensor[5, coords[:, 0], coords[:, 1], coords[:, 2]] = 1.0  # data presence mask
+
+    fill_ratio = num_bytes / curve.total_points
+
+    stats['bytes_mapped'] = num_bytes
+    stats['fill_ratio'] = fill_ratio
+    stats['channels'] = ['raw_bytes', 'entropy', 'code_mask', 'import_density', 'string_density', 'data_mask']
+    stats['channel_stats'] = {
+        'raw_bytes_mean': float(np.mean(raw_normalized)),
+        'entropy_mean': float(np.mean(entropy)),
+        'code_fraction': float(np.mean(code_mask)),
+        'import_fraction': float(np.mean(masks['import'])),
+        'string_density_mean': float(np.mean(string_density)),
+    }
+
+    return tensor, stats
+
+
+# --- File discovery and batch processing ---
+
+def is_valid_pe(filepath: str) -> bool:
+    """Quick sniff test: MZ magic + valid PE offset + PE signature."""
+    try:
+        with open(filepath, 'rb') as f:
+            f.seek(0, 2)
+            if f.tell() < 64:
+                return False
+
+            f.seek(0)
+            if f.read(2) != b'MZ':
+                return False
+
+            f.seek(0x3C)
+            pe_offset = struct.unpack('<I', f.read(4))[0]
+
+            f.seek(0, 2)
+            if pe_offset + 4 > f.tell():
+                return False
+
+            f.seek(pe_offset)
+            if f.read(4) != b'PE\x00\x00':
+                return False
+
+            return True
+    except:
+        return False
+
+
+def find_pe_files(input_dir: str, min_size: int = 10*1024, max_size: int = 50*1024*1024) -> list:
+    input_path = Path(input_dir)
+
+    if not input_path.exists():
+        raise ValueError(f"Input directory does not exist: {input_dir}")
+
+    pe_files = []
+    all_files = list(input_path.rglob('*'))
+
+    skipped_small = 0
+    skipped_large = 0
+    skipped_invalid = 0
+
+    print(f"Scanning {len(all_files)} items for valid PE files...")
+    print(f"Size filter: {min_size/1024:.1f}KB - {max_size/1024/1024:.1f}MB")
+
+    for filepath in tqdm(all_files, desc="Validating PE files"):
+        if not filepath.is_file():
+            continue
+
+        try:
+            file_size = filepath.stat().st_size
+        except OSError:
+            continue
+
+        if file_size < min_size:
+            skipped_small += 1
+            continue
+
+        if file_size > max_size:
+            skipped_large += 1
+            continue
+
+        if is_valid_pe(str(filepath)):
+            pe_files.append(filepath)
+        else:
+            skipped_invalid += 1
+
+    print(f"\nFiltering results:")
+    print(f"  Valid PE files: {len(pe_files)}")
+    print(f"  Too small (<{min_size/1024:.0f}KB): {skipped_small}")
+    print(f"  Too large (>{max_size/1024/1024:.0f}MB): {skipped_large}")
+    print(f"  Invalid PE: {skipped_invalid}")
+
+    return pe_files
+
+
+def process_pe_files(pe_files: list, output_dir: str, order: int = 6) -> dict:
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    curve = SpaceFillingCurve(order)
+
+    metadata = {
+        'order': order,
+        'grid_size': curve.size,
+        'max_bytes': curve.total_points,
+        'channels': 6,
+        'channel_names': ['raw_bytes', 'entropy', 'code_mask', 'import_density', 'string_density', 'data_mask'],
+        'extraction_mode': 'multichannel_semantic',
+        'files': {}
+    }
+
+    print(f"\nProcessing {len(pe_files)} PE files...")
+    print(f"Grid size: {curve.size}³ = {curve.total_points:,} voxels")
+    print(f"Output channels: 6 (raw, entropy, code, import, strings, data_mask)\n")
+
+    for filepath in tqdm(pe_files, desc="Converting to 6ch 3D tensors"):
+        try:
+            tensor, stats = pe_to_multichannel_3d(str(filepath), order, curve)
+
+            safe_name = "".join(c if c.isalnum() or c in '._-' else '_' for c in filepath.name)
+            output_name = f"{safe_name}.npy"
+            output_file = output_path / output_name
+
+            # handle filename collisions
+            counter = 1
+            base_safe_name = safe_name
+            while output_file.exists():
+                safe_name = f"{base_safe_name}_{counter}"
+                output_name = f"{safe_name}.npy"
+                output_file = output_path / output_name
+                counter += 1
+
+            np.save(output_file, tensor)
+
+            metadata['files'][str(filepath)] = {
+                'output': str(output_file.name),
+                'original_size': stats['file_size'],
+                'extracted_size': stats['extracted_size'],
+                'compression_ratio': stats['compression_ratio'],
+                'bytes_mapped': stats['bytes_mapped'],
+                'fill_ratio': stats['fill_ratio'],
+                'extracted_sections': stats['extracted_sections'],
+                'skipped_sections': stats['skipped_sections'],
+                'import_ranges_found': stats.get('import_ranges_found', 0),
+            }
+
+        except Exception as e:
+            tqdm.write(f"Error processing {filepath.name}: {e}")
+            metadata['files'][str(filepath)] = {'error': str(e)}
+
+    metadata_file = output_path / 'metadata.json'
+    with open(metadata_file, 'w') as f:
+        json.dump(metadata, f, indent=2)
+
+    return metadata
+
+
+def print_dataset_stats(metadata: dict):
+    """Dump fill ratio distribution. important to check before training
+    since fill ratio can be a spurious feature if it correlates with labels."""
+    files_data = [v for v in metadata['files'].values() if 'error' not in v]
+
+    if not files_data:
+        print("No successfully processed files!")
+        return
+
+    fill_ratios = [f['fill_ratio'] for f in files_data]
+
+    print("\n" + "=" * 60)
+    print("DATASET STATISTICS")
+    print("=" * 60)
+    print(f"Files processed: {len(files_data)}")
+    print(f"Grid size: {metadata['grid_size']}³")
+    print(f"Channels: {metadata['channels']} ({', '.join(metadata['channel_names'])})")
+
+    print(f"\nFILL RATIO DISTRIBUTION:")
+    print(f"  Min:    {min(fill_ratios):.4f} ({min(fill_ratios)*100:.1f}%)")
+    print(f"  Max:    {max(fill_ratios):.4f} ({max(fill_ratios)*100:.1f}%)")
+    print(f"  Mean:   {np.mean(fill_ratios):.4f} ({np.mean(fill_ratios)*100:.1f}%)")
+    print(f"  Std:    {np.std(fill_ratios):.4f}")
+    print(f"  Median: {np.median(fill_ratios):.4f}")
+
+    buckets = [0, 0.1, 0.25, 0.5, 0.75, 1.0]
+    print(f"\n  Distribution:")
+    for i in range(len(buckets)-1):
+        count = sum(1 for r in fill_ratios if buckets[i] <= r < buckets[i+1])
+        pct = count / len(fill_ratios) * 100
+        bar = "█" * int(pct / 5)
+        print(f"    {buckets[i]:.2f}-{buckets[i+1]:.2f}: {count:4d} ({pct:5.1f}%) {bar}")
+
+    full_count = sum(1 for r in fill_ratios if r >= 0.99)
+    print(f"\n  Tensors at 100% fill: {full_count} ({full_count/len(fill_ratios)*100:.1f}%)")
+    if full_count < len(fill_ratios) * 0.5:
+        print("  WARNING: Fill ratio varies significantly!")
+        print("     Check correlation with labels before training, this can be a confound.")
+
+
+def save_fill_ratio_report(metadata: dict, output_path: Path):
+    files_data = [(k, v) for k, v in metadata['files'].items() if 'error' not in v]
+
+    report = {
+        'total_files': len(files_data),
+        'fill_ratios': {k: v['fill_ratio'] for k, v in files_data},
+        'statistics': {
+            'min': min(v['fill_ratio'] for _, v in files_data),
+            'max': max(v['fill_ratio'] for _, v in files_data),
+            'mean': float(np.mean([v['fill_ratio'] for _, v in files_data])),
+            'std': float(np.std([v['fill_ratio'] for _, v in files_data])),
+            'median': float(np.median([v['fill_ratio'] for _, v in files_data])),
+        }
+    }
+
+    with open(output_path / 'fill_ratio_report.json', 'w') as f:
+        json.dump(report, f, indent=2)
+
+    print(f"Fill ratio report saved to {output_path / 'fill_ratio_report.json'}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Convert PE files to 6-channel 3D tensors with semantic features'
+    )
+    parser.add_argument('--input_dir', '-i', type=str, required=True,
+                        help='Input directory containing PE files')
+    parser.add_argument('--output_dir', '-o', type=str, required=True,
+                        help='Output directory for tensor files')
+    parser.add_argument('--order', type=int, default=6, choices=[4, 5, 6, 7],
+                        help='Curve order. Grid = 2^order. 6=64³. Default: 6')
+    parser.add_argument('--min_size', type=int, default=10,
+                        help='Minimum file size in KB (default: 10)')
+    parser.add_argument('--max_size', type=int, default=50,
+                        help='Maximum file size in MB (default: 50)')
+
+    args = parser.parse_args()
+
+    print("=" * 60)
+    print("PE -> 6-CHANNEL 3D TENSOR CONVERTER")
+    print("=" * 60)
+    print("Channels: raw bytes | entropy | code mask | import density | string density | data mask")
+    print("=" * 60)
+
+    min_bytes = args.min_size * 1024
+    max_bytes = args.max_size * 1024 * 1024
+    pe_files = find_pe_files(args.input_dir, min_size=min_bytes, max_size=max_bytes)
+
+    if not pe_files:
+        print("\nNo valid PE files found.")
+        return
+
+    print(f"\nFound {len(pe_files)} valid PE files")
+
+    metadata = process_pe_files(pe_files, args.output_dir, order=args.order)
+
+    successful = sum(1 for v in metadata['files'].values() if 'error' not in v)
+    failed = len(metadata['files']) - successful
+
+    print(f"\nDone. {successful}/{len(pe_files)} succeeded.")
+    if failed > 0:
+        print(f"  Failed: {failed}")
+    print(f"  Output: {args.output_dir}")
+
+    print_dataset_stats(metadata)
+    save_fill_ratio_report(metadata, Path(args.output_dir))
+
+
+if __name__ == '__main__':
+    main()