mjbommar/binary-30k-tokenized

Dataset Card for Binary-30K

Dataset Summary

Binary-30K is a comprehensive, multi-platform binary executable dataset designed for machine learning research in binary analysis, malware detection, and program understanding. The dataset contains 30,745 records representing 22,278 unique binary executables totaling 12.90 GB, collected from diverse sources including Linux distributions, Windows operating systems, and the SOREL-20M malware dataset.

Note on Duplicates: The dataset includes 30,745 total records but 22,278 unique SHA256 hashes. The duplicates (8,467 records) are primarily due to:

• BusyBox binaries (~1,827 records): Single multi-call binary with different command names (e.g., ls, cp, mv are hardlinks to the same BusyBox binary)
• Hardlinked system utilities: Multiple names pointing to identical binaries across different Linux distributions

This structure reflects real-world binary collections where utilities share implementations, and is valuable for studying binary deduplication and identifying multi-purpose executables.

Each binary in the dataset has been pre-processed with:

• Pre-computed BPE tokenization using the mjbommar/glaurung-binary-tokenizer-001 tokenizer
• Comprehensive metadata extraction including file format, architecture, sections, imports/exports
• Entropy analysis for complexity measurement
• Platform and OS detection from file paths
• Binary analysis via LIEF library (ELF/PE parsing)

The dataset is stratified across:

• Linux binaries (50.8%): Alpine 3.18/3.19, Debian 11 (Bullseye)/12 (Bookworm), Ubuntu 20.04/22.04/24.04, BusyBox 1.37.0
• Windows binaries (48.0%): Windows 8 Pro, Windows 10, Windows 11, Windows Update Catalog
• Malware samples (1.2%): From SOREL-20M dataset

This dataset enables research in malware detection, architecture recognition, function boundary detection, compiler identification, binary similarity analysis, and cross-platform binary understanding.

Supported Tasks

Binary Malware Detection

• Task: Binary classification (benign vs malicious)
• Metrics: Accuracy, Precision, Recall, F1-score, AUC-ROC
• Suggested Models: Transformer-based sequence models, CNN-based models
• Use Case: Detect malicious executables using token sequences and metadata features

Architecture Recognition

• Task: Multi-class classification (x86, x86-64, ARM, ARM64, etc.)
• Metrics: Top-1 accuracy, confusion matrix
• Suggested Models: CNN, Transformer encoder
• Use Case: Identify target architecture from binary content

Platform/OS Detection

• Task: Multi-class classification (Linux/Windows/malware, OS versions)
• Metrics: Hierarchical accuracy (platform, OS family, version)
• Suggested Models: Hierarchical classifiers, multi-task learning
• Use Case: Determine origin platform and OS version

Function Boundary Detection

• Task: Sequence labeling (token-level classification)
• Metrics: Precision/Recall at function boundaries, Intersection over Union
• Suggested Models: BiLSTM-CRF, Transformer with token classification head
• Use Case: Identify function boundaries in stripped binaries

Compiler Identification

• Task: Multi-class classification
• Metrics: Per-compiler accuracy
• Suggested Models: Feature-based classifiers, attention-based models
• Use Case: Determine compiler and optimization level

Binary Similarity Search

• Task: Embedding learning, similarity ranking
• Metrics: Mean Average Precision (MAP), Recall@K
• Suggested Models: Siamese networks, contrastive learning
• Use Case: Find similar binaries for library identification or code reuse detection

Languages

This dataset contains compiled binary executables (machine code), not natural language text. The binaries were compiled from source code originally written in various programming languages (C, C++, Rust, Go, etc.), but the dataset itself consists of binary executable formats (ELF and PE).

Dataset Structure

Data Instances

Each instance represents one binary executable with comprehensive metadata and pre-computed tokenization:

{
  # File Identification (6 fields)
  'file_id': 'alpine3.18_linux-amd64_busybox_1.36.1-r0_busybox',
  'file_path': 'alpine3.18/linux-amd64/busybox_1.36.1-r0/busybox',
  'file_name': 'busybox',
  'sha256': 'a1b2c3d4e5f6...',
  'md5': 'f1e2d3c4b5a6...',
  'file_size': 1048576,

  # Platform Detection (4 fields)
  'platform': 'linux',
  'os_family': 'alpine',
  'os_version': '3.18',
  'distribution': 'alpine3.18',

  # Binary Characteristics (6 fields)
  'file_format': 'ELF64',
  'architecture': 'x86-64',
  'binary_type': 'executable',
  'is_stripped': True,
  'is_packed': False,
  'is_signed': False,

  # Structural Analysis (4 fields + sections)
  'sections': [
    {'name': '.text', 'size': 524288, 'entropy': 7.892},
    {'name': '.data', 'size': 65536, 'entropy': 3.245},
    ...
  ],
  'num_sections': 12,
  'code_size': 524288,
  'data_size': 131072,

  # Dependencies (4 fields + imports/exports)
  'imports': ['printf', 'malloc', 'free', ...],
  'num_imports': 245,
  'exports': ['main', 'init_function', ...],
  'num_exports': 18,

  # Complexity Metrics (1 field)
  'entropy': 7.234,

  # Tokenization (4 fields)
  'tokens': [1234, 5678, 9012, ...],  # BPE token IDs
  'token_count': 8192,
  'compression_ratio': 2.45,  # bytes per token
  'unique_tokens': 1523
}

Data Fields

The dataset contains 29 metadata fields organized into 7 categories:

File Identification

• file_id (string): Unique identifier constructed from path components
• file_path (string): Relative path from dataset root
• file_name (string): Binary filename
• sha256 (string): SHA-256 hash of file contents
• md5 (string): MD5 hash of file contents
• file_size (int64): File size in bytes

Platform Information

• platform (string): Platform category: 'linux', 'windows', or 'malware'
• os_family (string): OS family (alpine, debian, ubuntu, busybox, windows, sorel-20m)
• os_version (string): OS version string (e.g., '3.18', '11', '20.04', '10')
• distribution (string): Full distribution identifier

Binary Characteristics

• file_format (string): Binary format (ELF32, ELF64, PE32, PE32+, or 'unknown')
• architecture (string): Target architecture (x86, x86-64, ARM, ARM64, MIPS, etc.)
• binary_type (string): Binary type (executable, library, driver, object, or 'unknown')
• is_stripped (bool): Whether debug symbols are stripped
• is_packed (bool): Whether binary appears packed/compressed
• is_signed (bool): Whether binary has code signature

Structural Analysis

• sections (list of dicts): List of binary sections with:
  • name (string): Section name (.text, .data, .rodata, etc.)
  • size (int64): Section size in bytes
  • entropy (float32): Shannon entropy of section contents
• num_sections (int32): Total number of sections
• code_size (int64): Total size of executable code sections
• data_size (int64): Total size of data sections

Dependencies

• imports (list of strings): Imported function names
• num_imports (int32): Count of imported functions
• exports (list of strings): Exported function names
• num_exports (int32): Count of exported functions

Complexity Metrics

• entropy (float32): Shannon entropy of entire binary (0.0 to 8.0)

Pre-computed Tokenization

• tokens (list of int32): BPE token IDs from mjbommar/glaurung-binary-tokenizer-001
• token_count (int32): Total number of tokens
• compression_ratio (float32): Bytes per token (file_size / token_count)
• unique_tokens (int32): Count of unique token IDs in sequence

Data Splits

The dataset is provided as a single collection of 30,841 binaries. Users should create their own train/validation/test splits based on their research needs. We recommend stratified splitting to maintain platform distribution:

Recommended Split (70/15/15):

from datasets import load_dataset

dataset = load_dataset("mjbommar/binary-30k-tokenized")

# Stratified split maintaining platform balance
train_test = dataset['train'].train_test_split(test_size=0.3, seed=42, stratify_by_column='platform')
train_val = train_test['train'].train_test_split(test_size=0.214, seed=42, stratify_by_column='platform')

train = train_val['train']      # ~21,588 samples (70%)
val = train_val['test']          # ~4,626 samples (15%)
test = train_test['test']        # ~4,627 samples (15%)

Distribution Statistics:

• Linux binaries: ~15,659 (51%)
• Windows binaries: ~14,815 (48%)
• Malware samples: ~367 (1%)

Dataset Creation

Curation Rationale

Binary-30K was created to address the lack of large-scale, multi-platform binary datasets for machine learning research. Existing binary analysis datasets often suffer from:

• Limited platform coverage (single OS)
• Small scale (hundreds or thousands of samples)
• Lack of metadata and pre-processing
• Closed/proprietary access

This dataset provides:

1. Cross-platform representation: Both Linux and Windows binaries from multiple distributions
2. Diverse architectures: x86, x86-64, ARM, ARM64 coverage
3. Rich metadata: 29 fields per binary for fine-grained analysis
4. Pre-computed tokenization: Ready for transformer-based models
5. Open access: CC-BY-4.0 license with public availability

The dataset enables research in:

• Cross-platform malware detection
• Architecture-agnostic binary analysis
• Transfer learning between platforms
• Tokenization-based binary understanding
• Large-scale binary similarity analysis

Source Data

Initial Data Collection and Normalization

Linux Binaries (51% of dataset)

Collected from official package repositories:

• Alpine Linux 3.18 and 3.19: Lightweight distribution, musl libc-based static binaries
• Debian 11 (Bullseye) and Debian 12 (Bookworm): Stable releases with glibc
• Ubuntu 20.04 LTS, 22.04 LTS, and 24.04 LTS: Long-term support releases
• BusyBox 1.37.0 (glibc): Embedded systems multi-call binary

Binaries extracted from .deb packages and Alpine APK packages using standard package management tools.

Windows Binaries (48% of dataset)

Collected from multiple Windows versions to capture compiler evolution:

• Windows 8 Pro (x64): System binaries and common applications
• Windows 10 (x64): Multiple builds covering several years
• Windows 11 (x64): Latest OS release
• Windows Update Catalog: System updates and drivers

Binaries extracted from official Microsoft sources using update catalog and system file extraction.

Malware Samples (1% of dataset)

Drawn from SOREL-20M dataset:

• SOREL-20M: Sophos-ReversingLabs 20 million sample malware dataset
  • Source: https://github.com/sophos/SOREL-20M
  • License: SOREL-20M License Agreement
  • Citation: Harang, R. & Rudd, E. M. (2020). SOREL-20M: A Large Scale Benchmark Dataset for Malicious PE Detection
• Subset selection: Representative samples across malware families
• Deduplication: SHA-256 based to avoid duplicates

All samples handled in isolated environment following malware analysis best practices.

Source Language Producers

The binaries were originally compiled from source code written by:

• Open source developers: Linux distribution maintainers and package maintainers
• Microsoft engineers: Windows operating system and system tool developers
• Malware authors: For malicious samples in SOREL-20M subset

The source code languages include C, C++, Rust, Go, Assembly, and others, though the dataset contains only the compiled binary forms.

Annotations

Annotation Process

The dataset includes two types of metadata:

Automatic Metadata Extraction:

• Platform/OS detection: Inferred from directory structure and file paths
• Binary format analysis: Extracted using LIEF library
• Architecture detection: From binary headers (ELF/PE)
• Section analysis: Parsed from binary structure
• Import/export extraction: From symbol tables and import tables
• Entropy calculation: Shannon entropy computed on raw bytes
• Tokenization: Pre-computed using BPE tokenizer

Manual Curation:

• Dataset organization: Files organized by platform, OS, and distribution
• Quality control: Verification of parseable formats
• Deduplication: SHA-256 based duplicate removal

No human annotations for labels (malware/benign, function boundaries, etc.) are included. The platform field provides ground truth for Linux/Windows/malware categories based on source.

Who are the Annotators?

The automatic metadata was extracted programmatically using:

• LIEF library (v0.14.0+): Binary parsing and analysis
• Custom extraction scripts: Platform detection, entropy calculation
• HuggingFace tokenizers (v0.15.0+): BPE tokenization with mjbommar/glaurung-binary-tokenizer-001

Dataset curation and organization performed by the dataset authors.

Personal and Sensitive Information

The dataset contains compiled binary executables. Potential sensitive information:

System Paths:

• Some binaries may contain embedded paths from build systems
• Debug information (if not stripped) may include developer usernames/paths
• These are typical artifacts of compilation and not considered sensitive

Function Names:

• Exported function names are included in metadata
• These are standard API/system calls, not sensitive

Malware Samples:

• Malware binaries included are from public SOREL-20M dataset
• No personal victim data included
• Samples are widely analyzed in security research community

No User Data:

• No user-generated content or personal documents
• No login credentials, API keys, or secrets
• No personally identifiable information (PII)

Considerations for Using the Data

Social Impact of Dataset

Positive Impacts:

1. Defensive Security: Enables development of better malware detection systems
2. Binary Analysis Research: Accelerates research in program analysis and reverse engineering
3. Cross-platform Understanding: Facilitates development of platform-agnostic analysis tools
4. Open Science: Provides open dataset where previously proprietary/closed datasets dominated
5. Educational Value: Supports teaching of binary analysis, cybersecurity, and ML applications

Potential Concerns:

1. Dual-Use Nature: Techniques developed could potentially be used by malicious actors

   • Mitigation: Dataset focuses on detection/analysis, not creation of malware

2. Malware Inclusion: Contains real malware samples

   • Mitigation: Small subset (1%), from public SOREL-20M, no execution required for ML use
   • Users should handle malware samples with appropriate security precautions

3. Adversarial Learning: Could be used to develop evasion techniques

   • Mitigation: Open datasets enable defensive research to stay ahead of attacks

Discussion of Biases

Platform Bias:

• Linux (51%) and Windows (48%) are balanced, but represent only two major platforms
• MacOS, mobile platforms (iOS/Android), and embedded systems not represented
• This may limit generalization to other platforms

Architecture Bias:

• Dominated by x86-64 architecture
• Limited ARM samples despite ARM's growing importance (mobile, IoT, Apple Silicon)
• Other architectures (MIPS, RISC-V) minimally represented

Temporal Bias:

• Windows samples span Windows 8-11 (2012-2023)
• Linux samples from 2020-2024 distributions
• May not represent historical (pre-2010) or future compilation patterns

Distribution Bias:

• Linux samples from Debian-based distributions (Debian, Ubuntu) and Alpine
• Other distributions (RedHat, Arch, Gentoo) not represented
• May not capture distribution-specific toolchain differences

Malware Bias:

• Malware samples only 1% of dataset (class imbalance)
• Malware from SOREL-20M (2020 collection) may not represent current threats
• Geographic/language bias in malware samples from original SOREL-20M

Size Bias:

• File sizes vary widely; very large binaries may be underrepresented
• Very large binaries (>10MB) may result in long token sequences requiring more computational resources

Researchers should:

• Be aware of these biases when drawing conclusions
• Validate findings on additional out-of-distribution datasets
• Consider stratified sampling based on platform/architecture for balanced experiments

Other Known Limitations

Technical Limitations:

1. Static Analysis Only: Dataset contains binaries without runtime behavior

   • No dynamic analysis features (API calls, network activity, file operations)

2. Parsing Failures: Some binaries cannot be parsed by LIEF

   • Corrupted files, unusual formats, or packers may result in missing metadata

3. Architecture Detection: Based on headers, may be incorrect for obfuscated binaries

4. Stripped Binaries: Many binaries have debug symbols removed

   • Limits metadata extraction (fewer function names, no source line info)

5. Token Sequence Length: Very large binaries (>10MB) produce long token sequences

   • May require memory-efficient processing techniques or chunking strategies
   • Full binary content is preserved in tokenization without truncation

Usage Limitations:

1. Malware Handling: Users must follow security best practices

   • Isolated environments, no execution required for dataset use

2. Legal Considerations: Windows binaries subject to Microsoft licensing

   • Research/educational use should be covered under fair use
   • Users should verify compliance with local laws

3. Computational Requirements: Full dataset requires significant resources

   • 12.90 GB raw data + tokenized dataset with complete metadata
   • Token sequences vary from hundreds to hundreds of thousands of tokens (no truncation applied)
   • Large binaries may require substantial memory for processing full token sequences

4. Not a Benchmark: No standardized train/test splits or evaluation protocol

   • Users should define splits and protocols appropriate for their research

Additional Information

Dataset Curators

This dataset was curated by:

Michael J. Bommarito II

• Email: [email protected]
• Website: https://michaelbommarito.com/

All dataset curation, organization, metadata extraction, and documentation by Michael J. Bommarito II.

Licensing Information

This dataset compilation is released under Creative Commons Attribution 4.0 International (CC-BY-4.0) license by Michael J. Bommarito II.

Dataset Compilation License (CC-BY-4.0):

• ✅ Share: Copy and redistribute in any medium or format
• ✅ Adapt: Remix, transform, and build upon the material for any purpose
• ✅ Commercial use allowed
• ⚠️ Attribution required: Must give appropriate credit and indicate if changes were made

Important: Component-Specific Licenses and Legal Considerations

This dataset contains binary executables from multiple sources, each subject to their own licenses and legal frameworks. Users are responsible for ensuring their use complies with applicable laws and licenses in their jurisdiction.

1. Linux Binaries: Various open source licenses (GPL, LGPL, MIT, BSD, Apache, etc.)

   • Original software licenses remain in effect for the binaries themselves
   • Dataset compilation, organization, and metadata under CC-BY-4.0
   • Users should review individual package licenses as needed

2. Windows Binaries: Microsoft software licenses

   • These binaries are subject to Microsoft's software license terms
   • Research and educational use may be covered under fair use/fair dealing doctrines depending on jurisdiction
   • Commercial use may require additional licensing from Microsoft
   • Users are responsible for compliance with Microsoft terms and applicable laws in their jurisdiction
   • Consider consulting legal counsel for commercial applications

3. Malware Samples: From SOREL-20M dataset (Sophos-ReversingLabs)

   • Source: SOREL-20M GitHub Repository
   • License: SOREL-20M License Agreement
   • Users must comply with SOREL-20M's terms of use
   • No copyright claimed on malware samples themselves
   • Malware samples should only be used in secure, isolated research environments

Recommendations for Users:

• Academic/Research Use: Generally covered under fair use/fair dealing in most jurisdictions, but verify compliance with institutional policies
• Commercial Use: Consult legal counsel regarding Microsoft binary licenses and other proprietary software
• International Use: Fair use laws vary by jurisdiction; ensure compliance with local regulations
• Malware Handling: Follow cybersecurity best practices and institutional review board requirements

Attribution: When using this dataset, please cite the associated paper (see Citation Information below) and acknowledge Michael J. Bommarito II as the dataset curator.

Citation Information

If you use this dataset in your research, please cite:

@article{bommarito2025binary30k,
  title={Binary-30K: A Large-Scale Multi-Platform Binary Dataset for Machine Learning Research},
  author={Bommarito, Michael J., II},
  journal={arXiv preprint},
  year={2025},
  url={https://github.com/mjbommar/binary-bpe-paper}
}

Related Publications:

For information about the BPE tokenizer used for pre-processing:

@article{bommarito2025binarybpe,
  title={Byte Pair Encoding for Binary Executables: A Large-Scale Analysis},
  author={Bommarito, Michael J., II},
  journal={arXiv preprint},
  year={2025},
  url={https://github.com/mjbommar/binary-bpe-paper}
}

Dataset Access

HuggingFace Hub:

from datasets import load_dataset
dataset = load_dataset("mjbommar/binary-30k-tokenized")

Direct Download:

• HTTPS: https://s3.amazonaws.com/michaelbommarito.com/resources/glaurung/data/glaurung-model-binaries-20251028.tar.gz
• S3 URI: s3://michaelbommarito.com/resources/glaurung/data/glaurung-model-binaries-20251028.tar.gz
• Size: 12.90 GB (compressed)

Contributions

Thanks to the open source community, Linux distribution maintainers, and the SOREL-20M team for making their data available for research.

Special thanks to:

• HuggingFace for datasets and tokenizers libraries
• LIEF project for binary parsing tools
• The binary analysis and malware research communities

Contributing:

• Report issues or suggest improvements via GitHub: https://github.com/mjbommar/binary-bpe-paper
• Contact: [email protected]

---

Last Updated: October 28, 2025