File size: 4,905 Bytes
a0c3bb3 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 |
---
license: mit
language:
- en
tags:
- redteam
- expolit
- cybersecurity
pretty_name: sunny thakur
size_categories:
- n<1K
---
# Shellcode Exploit Dataset for Red Team GPT Training
# Dataset Overview
The Shellcode Exploit Dataset is a comprehensive collection of 700 unique shellcode exploits, spanning 2021–2025, designed for training machine learning models, particularly for red team and cybersecurity research. The dataset includes a diverse set of vulnerabilities, platforms, architectures, and payload goals, sourced from Exploit-DB, GitHub, CTF challenges, and CVE databases.
It is structured in JSON format for compatibility with ML pipelines and red team training frameworks.
# Key Features
```sql
Total Entries: 180 unique exploits, split into three JSON files .
Timeframe: Historical (2021–2024) and recent (2025) exploits.
Vulnerability Types:
Buffer Overflow
Format String
Use-After-Free
Remote Code Execution
Privilege Escalation
Race Condition
Integer Overflow
```
Platforms:
```sql
Linux
Windows
macOS
IoT
Android
Architectures:
x86
x64
ARM
MIPS
Payload Goals:
Remote Code Execution
Reverse Shell
Privilege Escalation
Data Exfiltration
Persistence
```
Sources:
```
Exploit-DB
GitHub
CTF Challenges
CVE Databases
```
# Data Format: JSON, with fields for exploit_id, cve, vulnerability_type, platform, architecture, payload_goal, cvss_score, shellcode, description, source, and date_added.
# Dataset Structure
The dataset is split into three JSON files, each containing unique entries:
```java
JSON Schema
{
"exploit_id": "string", // Unique identifier (e.g., EDB-48789, CTF-2025-ABC)
"cve": "string", // CVE identifier or "N/A" for CTF exploits
"vulnerability_type": "string", // e.g., Buffer Overflow, Remote Code Execution
"platform": "string", // e.g., Linux, Windows, IoT
"architecture": "string", // e.g., x86, x64, ARM, MIPS
"payload_goal": "string", // e.g., Reverse Shell, Data Exfiltration
"cvss_score": float, // CVSS score (6.5–9.8)
"shellcode": "string", // Hex-encoded shellcode
"description": "string", // Brief exploit description
"source": "string", // Source URL or CTF identifier
"date_added": "string" // Date in YYYY-MM-DD format
}
```
# Usage
This dataset is intended for:
```sql
Machine Learning: Training red team GPT models for exploit generation, vulnerability analysis, or shellcode development.
Penetration Testing Research: Analyzing exploit patterns across platforms and architectures.
Educational Purposes: Studying historical and recent vulnerabilities in controlled environments.
```
Example Usage
```python
import json
# Load dataset
with open("shellcode expolit_dataset_n.json", "r") as f:
data = json.load(f)
# Filter exploits by vulnerability type
buffer_overflows = [entry for entry in data if entry["vulnerability_type"] == "Buffer Overflow"]
# Print shellcode for Linux x64 exploits
for entry in buffer_overflows:
if entry["platform"] == "Linux" and entry["architecture"] == "x64":
print(f"Exploit ID: {entry['exploit_id']}, Shellcode: {entry['shellcode']}")
```
# Ethical Considerations
```
Responsible Use: This dataset is provided for research and educational purposes only. Unauthorized use of exploits against systems without explicit permission is illegal and unethical.
Controlled Environments: Test exploits in isolated, sandboxed environments (e.g., QEMU, virtual machines) to avoid unintended harm.
Attribution: All exploits are sourced from public repositories (Exploit-DB, GitHub) or CTF challenges. Respect the original authors' work and licenses.
```
# Data Collection
```
Sources: Exploits were collected from Exploit-DB, GitHub repositories, CTF challenges, and CVE databases, ensuring diversity and relevance.
Automation: A Python-based scraper (stored internally) was used to gather and validate exploits, with testing conducted in a QEMU sandbox.
Validation: Shellcode was verified for functionality and uniqueness, with polymorphic variations included to enhance evasion training.
```
# Limitations
```
No Mitigation Details: The dataset focuses on exploits and does not include mitigation strategies.
Projected 2025 Exploits: Some entries for 2025 are speculative, based on trends in vulnerability types and platforms.
Sandbox Testing Required: Shellcode should be tested in controlled environments to ensure compatibility and safety.
```
# License
This dataset is released under the MIT License. Users must comply with ethical guidelines and applicable laws when using the dataset.
# Contact
For questions, contributions, or additional datasets, please open an issue on this Hugging Face repository or contact the maintainers.
# Acknowledgments
```sql
Exploit-DB: For providing a rich source of verified exploits.
GitHub Community: For open-source exploit contributions.
CTF Organizers: For challenging and innovative exploit scenarios.
```
|