README.md

---
license: cc-by-4.0
task_categories:
- other
tags:
- binary-analysis
- malware-detection
- executable-analysis
- binary-tokenization
- cybersecurity
- reverse-engineering
- program-analysis
- cross-platform
size_categories:
- 10K<n<100K
pretty_name: 'Binary-30K: A Large-Scale Multi-Platform Binary Dataset'
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-*
dataset_info:
  features:
  - name: file_id
    dtype: string
  - name: file_path
    dtype: string
  - name: file_name
    dtype: string
  - name: sha256
    dtype: string
  - name: md5
    dtype: string
  - name: file_size
    dtype: int64
  - name: platform
    dtype: string
  - name: os_family
    dtype: string
  - name: os_version
    dtype: string
  - name: distribution
    dtype: string
  - name: is_malware
    dtype: bool
  - name: file_format
    dtype: string
  - name: architecture
    dtype: string
  - name: binary_type
    dtype: string
  - name: is_stripped
    dtype: bool
  - name: is_packed
    dtype: bool
  - name: is_signed
    dtype: bool
  - name: sections
    struct:
    - name: name
      list: string
    - name: size
      list: int64
    - name: entropy
      list: float32
  - name: num_sections
    dtype: int32
  - name: code_size
    dtype: int64
  - name: data_size
    dtype: int64
  - name: imports
    list: string
  - name: num_imports
    dtype: int32
  - name: exports
    list: string
  - name: num_exports
    dtype: int32
  - name: entropy
    dtype: float32
  - name: token_count
    dtype: int32
  - name: compression_ratio
    dtype: float32
  - name: unique_tokens
    dtype: int32
  - name: parse_status
    dtype: string
  - name: parse_warnings
    list: string
  - name: has_tokens
    dtype: bool
  - name: tokens
    list: int32
  splits:
  - name: train
    num_bytes: 23974366226
    num_examples: 29793
  download_size: 10799229566
  dataset_size: 23974366226
---

# Dataset Card for Binary-30K

## Table of Contents
- [Dataset Description](#dataset-description)
  - [Dataset Summary](#dataset-summary)
  - [Supported Tasks](#supported-tasks)
  - [Languages](#languages)
- [Dataset Structure](#dataset-structure)
  - [Data Instances](#data-instances)
  - [Data Fields](#data-fields)
  - [Data Splits](#data-splits)
- [Dataset Creation](#dataset-creation)
  - [Curation Rationale](#curation-rationale)
  - [Source Data](#source-data)
- [Considerations for Using the Data](#considerations-for-using-the-data)
  - [Social Impact of Dataset](#social-impact-of-dataset)
  - [Discussion of Biases](#discussion-of-biases)
- [Additional Information](#additional-information)
  - [Dataset Curators](#dataset-curators)
  - [Licensing Information](#licensing-information)
  - [Citation Information](#citation-information)

## Dataset Description

- **Homepage:** [https://michaelbommarito.com/](https://michaelbommarito.com/)
- **Repository:** [https://github.com/mjbommar/binary-bpe-paper](https://github.com/mjbommar/binary-bpe-paper)
- **Paper:** [arXiv:XXXX.XXXXX](https://arxiv.org/abs/XXXX.XXXXX) (to be updated)
- **Point of Contact:** michael.bommarito@gmail.com

### 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 **38,467 records** representing **~30,000 unique binary executables** totaling **~33.41 GB**, collected from diverse sources including Linux distributions, Windows operating systems, SOREL-20M malware dataset, and Malware Bazaar collection.

**Note on Duplicates:** The dataset includes 38,467 total records representing ~30,000 unique SHA256 hashes. Among the benign binaries, there are approximately 8,467 duplicate records 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. The malware samples from SOREL-20M and Malware Bazaar are deduplicated and contribute unique binaries to the dataset.

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** (47.2%): Alpine 3.18/3.19, Debian 11 (Bullseye)/12 (Bookworm), Ubuntu 20.04/22.04/24.04, BusyBox 1.37.0, plus Linux malware from Malware Bazaar
- **Windows binaries** (44.5%): Windows 8 Pro, Windows 10, Windows 11, Windows Update Catalog, plus Windows malware from Malware Bazaar
- **macOS binaries** (1.5%): macOS malware from Malware Bazaar (x86-64, ARM64, Universal binaries)
- **Android binaries** (0.6%): Android malware APKs from Malware Bazaar
- **Other/Diverse formats** (6.2%): Scripts, archives, and diverse formats from SOREL-20M and Malware Bazaar

**Malware Representation**: The dataset includes 8,089 malware samples (21.0% of dataset) from SOREL-20M (367 samples) and Malware Bazaar (7,722 samples), providing strong class balance for malware detection research across Linux, Windows, macOS, and Android platforms.

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

### Supported Tasks

**Binary Malware Detection**
- Task: Binary classification (benign vs malicious) and cross-platform malware detection
- Metrics: Accuracy, Precision, Recall, F1-score, AUC-ROC
- Suggested Models: Transformer-based sequence models, CNN-based models
- Use Case: Detect malicious executables across Linux, Windows, macOS, and Android platforms using token sequences and metadata features. Strong class balance (21% malware) enables effective training.

**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:

```python
{
  # 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):**
```python
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: ~18,165 (47.2%)
- Windows binaries: ~17,125 (44.5%)
- macOS binaries: ~568 (1.5%)
- Android binaries: ~242 (0.6%)
- Other/Diverse: ~2,367 (6.2%)

**Malware Representation:**
- Total malware samples: ~8,089 (21.0%)
- Sources: SOREL-20M (367) + Malware Bazaar (7,722)
- Cross-platform: Linux, Windows, macOS, Android

## 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 across Linux, Windows, macOS, and Android
- Architecture-agnostic binary analysis including exotic architectures (MIPS, RISC-V, ARCompact, m68k)
- Transfer learning between platforms and architectures
- Tokenization-based binary understanding
- Large-scale binary similarity analysis
- Mobile malware detection (Android APKs)
- IoT and embedded systems malware analysis

Binary-30K is one of the few publicly available datasets with comprehensive cross-platform malware coverage at scale, including mobile platforms and exotic architectures, with strong class balance (21% malware) suitable for effective malware detection research.

### Source Data

#### Initial Data Collection and Normalization

**Linux Binaries (47.2% 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 (44.5% 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 (21% of dataset)**

Drawn from two sources - SOREL-20M and Malware Bazaar:

**SOREL-20M subset (367 samples)**:
- **SOREL-20M**: Sophos-ReversingLabs 20 million sample malware dataset
  - Source: [https://github.com/sophos/SOREL-20M](https://github.com/sophos/SOREL-20M)
  - License: [SOREL-20M License Agreement](https://github.com/sophos/SOREL-20M/blob/main/LICENSE)
  - 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.

**Malware Bazaar Samples (20% of dataset)**

Strategically sampled from Malware Bazaar collection using Platform-First Stratified Sampling:
- **Source**: [https://bazaar.abuse.ch/](https://bazaar.abuse.ch/)
- **Sampling strategy**: Platform-First Stratified Sampling approach
  - ALL macOS samples (568): Fills critical platform gap, includes x86-64, ARM64 (Apple Silicon), and Universal binaries
  - ALL Android samples (242): Enables mobile malware research, APK format with ARM/ARM64 native libraries
  - Windows samples (2,356): Stratified by file size for diversity (small scripts, medium tools, large packed binaries)
  - Linux samples (2,556): Stratified by architecture, includes exotic architectures (MIPS, RISC-V, ARCompact, m68k, SH, PowerPC)
  - Other formats (2,000): Diverse file types including scripts, archives, and obfuscated payloads
- **Total**: 7,722 samples selected from 20,499 available (37.7% sampling rate)
- **Selection criteria**: Maximize platform and architecture diversity to reach 30,000 unique binaries
- **License**: Research use only, proper attribution required
- **Sampling methodology**: Detailed documentation available at [SAMPLING_METHODOLOGY.md](https://github.com/mjbommar/binary-bpe-paper/blob/master/paper/dataset-paper/SAMPLING_METHODOLOGY.md)

The Malware Bazaar samples provide:
1. **Cross-platform malware detection**: Supports Linux, Windows, macOS, and Android malware analysis
2. **Mobile malware research**: 242 Android APKs with ARM/ARM64 architectures
3. **macOS malware analysis**: 568 samples including x86-64, ARM64 (Apple Silicon), and Universal binaries
4. **Exotic architecture coverage**: 1,000+ samples with MIPS, RISC-V, ARCompact, m68k, SH, PowerPC enabling IoT/embedded malware research
5. **Platform and architecture diversity**: Stratified sampling ensures representation across malware types, platforms, and architectures

#### 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 (47.2%) and Windows (44.5%) are the dominant platforms
- **macOS represented** (1.5%, 568 samples) including x86-64 and ARM64 (Apple Silicon) binaries
- **Android represented** (0.6%, 242 samples) enabling mobile malware research
- iOS not represented (future work)
- Embedded systems represented via exotic Linux architectures (MIPS, RISC-V, ARCompact, m68k, SH, PowerPC)

**Architecture Bias:**
- x86-64 is dominant but dataset includes diverse architectures:
  - **ARM64**: macOS (Apple Silicon) and Android (64-bit) samples included
  - **ARM**: Android (32-bit) samples included
  - **Exotic architectures**: MIPS, RISC-V, ARCompact, m68k, SH, PowerPC from Malware Bazaar Linux samples (~1,000 samples)
- Suitable for cross-architecture research across common and exotic architectures
- IoT/embedded device architectures represented, enabling specialized malware detection research

**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 represent 21% of dataset (strong class balance for classification tasks)
- **Cross-platform malware** representation: Linux, Windows, macOS, Android
- Malware from two sources:
  - SOREL-20M (2020): 367 Windows PE samples
  - Malware Bazaar (2020-2025): 7,722 samples spanning multiple years, platforms, and malware families
- **Platform-stratified sampling** ensures diverse malware families and attack vectors across all major platforms
- Geographic/language bias may exist due to collection sources
- **Exotic architecture malware** (MIPS, RISC-V, ARCompact, m68k, SH, PowerPC) enables IoT/embedded malware detection research

**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: michael.bommarito@gmail.com
- Website: [https://michaelbommarito.com/](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. **SOREL-20M Malware Samples**: From SOREL-20M dataset (Sophos-ReversingLabs)
   - Source: [SOREL-20M GitHub Repository](https://github.com/sophos/SOREL-20M)
   - License: [SOREL-20M License Agreement](https://github.com/sophos/SOREL-20M/blob/main/LICENSE)
   - 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

4. **Malware Bazaar Samples**: From Malware Bazaar (abuse.ch)
   - Source: [https://bazaar.abuse.ch/](https://bazaar.abuse.ch/)
   - License: Research use only, proper attribution required
   - 7,722 samples strategically selected via Platform-First Stratified Sampling
   - Users must comply with Malware Bazaar's terms of use
   - No copyright claimed on malware samples themselves
   - Malware samples should only be used in secure, isolated research environments
   - Attribution: Must acknowledge Malware Bazaar (abuse.ch) as source
   - See [SAMPLING_METHODOLOGY.md](https://github.com/mjbommar/binary-bpe-paper/blob/master/paper/dataset-paper/SAMPLING_METHODOLOGY.md) for sampling details

**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:

```bibtex
@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:

```bibtex
@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:**
```python
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: michael.bommarito@gmail.com

---

**Last Updated:** October 28, 2025