attack_range
A tool that allows you to create vulnerable instrumented local or cloud environments to simulate attacks against and collect the data into Splunk
Top Related Projects
Automated Adversary Emulation Platform
Re-play Security Events
Small and highly portable detection tests based on MITRE's ATT&CK.
Quick Overview
Attack Range is an open-source project by Splunk that provides a detection development platform for simulating and testing security detections. It allows security professionals to create controlled environments for testing and improving their detection capabilities against various attack techniques.
Pros
- Offers a flexible and customizable environment for testing security detections
- Supports multiple deployment options (local, cloud, and remote)
- Integrates with popular security tools and frameworks (e.g., Splunk, Atomic Red Team)
- Provides pre-configured scenarios and attack simulations
Cons
- Requires significant system resources for local deployments
- Setup process can be complex for beginners
- Limited documentation for advanced customization
- May require additional licensing for some features or integrations
Getting Started
To get started with Attack Range, follow these steps:
-
Clone the repository:
git clone https://github.com/splunk/attack_range.git cd attack_range -
Install dependencies:
pip install -r requirements.txt -
Configure the environment:
cp attack_range.conf.template attack_range.conf # Edit attack_range.conf with your desired settings -
Deploy the Attack Range:
python attack_range.py build -
Simulate an attack:
python attack_range.py simulate -t T1003.001 -
Destroy the environment when finished:
python attack_range.py destroy
For more detailed instructions and advanced usage, refer to the project's documentation on GitHub.
Competitor Comparisons
Automated Adversary Emulation Platform
Error generating comparison
Re-play Security Events
Pros of Security-Datasets
- Provides a wide variety of pre-generated security datasets for different scenarios
- Includes datasets from multiple data sources and platforms
- Easier to use for those who don't need a full attack simulation environment
Cons of Security-Datasets
- Limited ability to customize or generate new datasets on-demand
- May not cover all specific use cases or emerging threats
- Lacks the interactive, hands-on experience of a live attack range
Code Comparison
Security-Datasets (JSON example):
{
"metadata": {
"title": "Windows Security Event Log",
"description": "Windows security events collected from a domain controller",
"platform": "Windows",
"log_source": "Security"
},
"events": [
{
"EventID": 4624,
"LogonType": 3,
"TargetUserName": "Administrator",
"IpAddress": "192.168.1.100"
}
]
}
Attack Range (Python example):
from attack_range import AttackRange
attack_range = AttackRange()
attack_range.build()
attack_range.simulate(technique="T1078")
attack_range.destroy()
The code examples illustrate the difference in approach: Security-Datasets provides ready-to-use data, while Attack Range offers a programmable environment for simulating attacks and generating data.
Small and highly portable detection tests based on MITRE's ATT&CK.
Pros of Atomic Red Team
- Extensive library of pre-built tests covering a wide range of MITRE ATT&CK techniques
- Easy to execute tests without complex setup or infrastructure requirements
- Active community and frequent updates to keep tests current with evolving threats
Cons of Atomic Red Team
- Limited built-in logging and telemetry collection capabilities
- Lacks integrated analysis and detection tools for evaluating test results
- May require additional tools or scripts for comprehensive environment setup
Code Comparison
Atomic Red Team test execution:
- name: T1003.001 - OS Credential Dumping: LSASS Memory
auto_generated_guid: 0be2230c-9ab3-4ac2-8826-3199b9a0ebf8
executor:
command: |
mimikatz.exe "privilege::debug" "sekurlsa::logonpasswords" "exit"
name: command_prompt
Attack Range deployment:
- name: Configure Attack Range
hosts: localhost
vars:
attack_range_password: mypassword
tasks:
- name: Deploy Attack Range
command: python attack_range.py --action build
Both repositories offer valuable resources for testing and simulating cyber attacks, but they serve different purposes. Atomic Red Team focuses on individual technique execution, while Attack Range provides a more comprehensive environment for end-to-end attack simulation and detection testing.
Pros of detection-rules
- Focuses specifically on detection rules for Elastic Security
- Provides a comprehensive set of pre-built rules for various threat types
- Includes tools for rule testing and validation
Cons of detection-rules
- Limited to Elastic Security ecosystem
- Requires more manual setup and configuration compared to Attack Range
Code Comparison
detection-rules:
from detection_rules import Rule
rule = Rule.create("my_custom_rule")
rule.query = "process.name:malware.exe"
rule.description = "Detect known malware process"
rule.save()
Attack Range:
from attack_range import AttackRange
range = AttackRange()
range.simulate_attack("T1003")
range.collect_data()
range.destroy()
Summary
detection-rules is tailored for Elastic Security users, offering a rich set of pre-built detection rules and tools for rule management. It's ideal for organizations already using Elastic Stack for security monitoring.
Attack Range, on the other hand, provides a more comprehensive environment for simulating attacks and testing various security tools, including Splunk. It's better suited for organizations looking to test and validate their entire security stack against simulated threats.
The choice between the two depends on your specific security tooling and testing requirements.
Convert
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Splunk Attack Range v5

The Splunk Attack Range builds instrumented cloud environments (AWS, Azure, GCP), simulates attacks, and forwards data into Splunk for detection development and testing.

What it does:
- Build labs â Deploy a small, production-like lab (Splunk, Windows/Linux servers, optional Kali, Zeek, etc.) via Terraform and Ansible.
- Simulate attacks â Run Atomic Red Team (and other) techniques to generate real telemetry.
- Share access â Use WireGuard VPN; generate additional client configs to share the range with others.
Click the picture to watch the demo ð
Getting started
Preferred: Docker Compose
-
Prerequisites: Docker and Docker Compose. Configure your cloud provider (AWS, Azure, or GCP) and mount credentials as below.
-
Clone and start:
git clone <repo-url> cd attack_range_2 docker compose -f docker/docker-compose.yml up -
Use the app or API:
- Web app: open http://localhost:4321 â build/destroy ranges, view status, run simulations, share access.
- API: http://localhost:4000 â REST API; interactive docs at http://localhost:4000/openapi/swagger.
-
Build a range (two steps):
- In the app: pick a template (e.g.
aws/splunk_minimal_aws) and start the build. When status is Waiting for VPN, download the WireGuard config, connect with WireGuard, then continue the build. - Or via API:
POST /attack-range/buildwith{"template": "aws/splunk_minimal_aws"}, pollGET /attack-range/status/<id>, use the returned WireGuard config, connect, thenPOST /attack-range/buildwith{"attack_range_id": "<id>"}.
- In the app: pick a template (e.g.
-
CLI in Docker (optional):
docker compose --profile cli -f docker/docker-compose.yml run --rm attack_range build -t aws/splunk_minimal_awsOther actions:
destroy,simulate,share. See Detailed documentation for CLI usage and flags.
Ways to run
| Method | Use case |
|---|---|
| Docker Compose (recommended) | Run API + web app + optional CLI with one docker compose; no local Python/Ansible/Terraform. |
| Web app | Build, destroy, simulate, and share via the UI at port 4321. |
| REST API | Automate from scripts or CI; full OpenAPI docs at /openapi/swagger. |
| CLI | `attack_range.py build |
Documentation
- Full docs (Read the Docs): https://attack-range.readthedocs.io/
- Chapters: Getting Started, Configuration, Networking, Sharing, Templates, Ansible Roles
Quick reference
- Configs: Each range has a config in
config/<attack_range_id>.yml. Templates live intemplates/{aws,azure,gcp}/. - Credentials: Set up
~/.aws,~/.azure, or~/.config/gcloudand mount them into the containers (seedocker/docker-compose.yml). - Support: GitHub issues and CONTRIBUTING.
Support
Please use the GitHub issue tracker to submit bugs or request features.
If you have questions or need support, you can:
- Join the #security-research room in the Splunk Slack channel
- Post a question to Splunk Answers
- If you are a Splunk Enterprise customer with a valid support entitlement contract and have a Splunk-related question, you can also open a support case on the https://www.splunk.com/ support portal
Contributing
We welcome feedback and contributions from the community! Please see our contribution guidelines for more information on how to get involved.
Author
Contributors
- Bhavin Patel
- Rod Soto
- Russ Nolen
- Phil Royer
- Joseph Zadeh
- Rico Valdez
- Dimitris Lambrou
- Dave Herrald
- Ignacio Bermudez Corrales
- Peter Gael
- Josef Kuepker
- Shannon Davis
- Mauricio Velazco
- Teoderick Contreras
- Lou Stella
- Christian Cloutier
- Eric McGinnis
- Micheal Haag
- Gowthamaraj Rajendran
- Christopher Caldwell
- Zachary Christensen
- JerinSaji0
- Michal Cichorz
Top Related Projects
Automated Adversary Emulation Platform
Re-play Security Events
Small and highly portable detection tests based on MITRE's ATT&CK.
Convert
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot