performing-purple-team-atomic-testing

Executes Atomic Red Team tests mapped to MITRE ATT&CK via Invoke-AtomicRedTeam PowerShell, generates ATT&CK Navigator coverage heatmaps, correlates results against Sigma rules, and runs detection validation loops to measure blue team visibility. Use for purple team exercises, atomic test execution, ATT&CK coverage assessment, or detection engineering validation.

Ir para a instalação

Repositório: mukul975/Anthropic-Cybersecurity-Skills
Última atividade na origem: 2 de agosto de 2026 às 16:32
Idioma detectado do SKILL.md: inglês
Estrelas: 27.732
Forks: 3.366

Opções de instalação

Por padrão, está selecionado o prompt que primeiro revisa a origem. Você pode mudar para um comando direto ou baixar uma cópia local.

Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.

Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.

npx skills add https://github.com/mukul975/Anthropic-Cybersecurity-Skills --skill performing-purple-team-atomic-testing

O comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.

Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.

Revise os arquivos de origem

Leia o SKILL.md e os arquivos complementares exibidos pelo SkillsMP antes de decidir se vai instalar.

Explorador de arquivos

4 arquivos

SKILL.md

Instruções da origem · Visualização somente leitura

Voltar à pesquisa Voltar à instalação

Performing Purple Team Atomic Testing

When to Use

Validating detection coverage against specific MITRE ATT&CK techniques
Running purple team exercises using Atomic Red Team test library
Performing ATT&CK coverage gap analysis to identify blind spots in SIEM/EDR
Building a detection validation loop: execute atomic test, check SIEM, tune rule, retest
Generating ATT&CK Navigator heatmap layers for executive reporting
Automating continuous atomic testing in CI/CD or scheduled pipelines
Mapping threat intelligence reports to executable atomic tests

Do not use for full-scope red team engagements requiring custom implants or live adversary simulation beyond atomic tests; use Caldera, SCYTHE, or Cobalt Strike for advanced adversary emulation.

DISCLAIMER: Atomic Red Team tests execute real attack techniques. Run only on systems you own or have explicit written authorization to test. Many tests modify system state, create artifacts, or trigger security alerts. Always execute cleanup commands after testing. Never run atomic tests in production without risk acceptance from stakeholders.

Prerequisites

Windows host with PowerShell 5.1+ or PowerShell Core 7+ (Linux/macOS supported for cross-platform atomics)
Invoke-AtomicRedTeam PowerShell module installed from PSGallery
Atomic Red Team atomics repository cloned locally
SIEM/EDR with log ingestion from test endpoints (Splunk, Elastic, Microsoft Sentinel, CrowdStrike)
MITRE ATT&CK Navigator (web-based or local instance) for layer visualization
Python 3.9+ with mitreattack-python, pyyaml, and requests for automation scripts
Sigma rules repository for detection correlation
Administrative/root access on test endpoints
Isolated test environment (lab, sandbox, or dedicated test range)

Workflow

Step 1: Install and Configure Invoke-AtomicRedTeam

Set up the execution framework and download the atomics library:

# Install the PowerShell execution module
Install-Module -Name invoke-atomicredteam -Scope CurrentUser -Force
Install-Module -Name powershell-yaml -Scope CurrentUser -Force

# Import the module
Import-Module invoke-atomicredteam

# Install atomics to default location (C:\AtomicRedTeam\atomics)
IEX (IEX (New-Object System.Net.WebClient).DownloadString(
    'https://raw.githubusercontent.com/redcanaryco/invoke-atomicredteam/master/install-atomicredteam.ps1'
)); Install-AtomicRedTeam -getAtomics -Force

# Verify installation - list available techniques
$atomicsPath = "C:\AtomicRedTeam\atomics"
$techniques = Get-ChildItem $atomicsPath -Directory | Where-Object { $_.Name -match '^T\d{4}' }
Write-Host "Available techniques: $($techniques.Count)"

# Configure execution logging
$env:ARTLOG = "C:\AtomicRedTeam\logs"
if (-not (Test-Path $env:ARTLOG)) { New-Item -Path $env:ARTLOG -ItemType Directory }

Step 2: Enumerate and Select Atomic Tests

Inventory available tests and select targets based on threat intelligence or gap analysis:

# List all tests for a specific technique
Invoke-AtomicTest T1059.001 -ShowDetailsBrief

# Show full details including attack commands and cleanup
Invoke-AtomicTest T1059.001 -ShowDetails

# List tests for a tactic (e.g., Persistence)
$persistenceTechniques = @(
    "T1547.001",  # Boot or Logon Autostart - Registry Run Keys
    "T1053.005",  # Scheduled Task
    "T1136.001",  # Create Account - Local Account
    "T1543.003",  # Create or Modify System Process - Windows Service
    "T1546.001",  # Event Triggered Execution - Change Default File Association
    "T1574.001",  # Hijack Execution Flow - DLL Search Order Hijacking
    "T1197"       # BITS Jobs
)

foreach ($tech in $persistenceTechniques) {
    Write-Host "`n=== $tech ===" -ForegroundColor Cyan
    try {
        Invoke-AtomicTest $tech -ShowDetailsBrief
    } catch {
        Write-Host "  No tests available" -ForegroundColor Yellow
    }
}

# Get all atomic techniques from YAML files programmatically
$allAtomics = Get-ChildItem "$atomicsPath\T*\T*.yaml" -Recurse |
    ForEach-Object {
        $yaml = Get-Content $_.FullName -Raw | ConvertFrom-Yaml
        [PSCustomObject]@{
            TechniqueId   = $yaml.attack_technique
            TechniqueName = $yaml.display_name
            TestCount     = $yaml.atomic_tests.Count
            Platforms     = ($yaml.atomic_tests.supported_platforms | Sort-Object -Unique) -join ", "
        }
    }

$allAtomics | Sort-Object TechniqueId | Format-Table -AutoSize
Write-Host "Total techniques with tests: $($allAtomics.Count)"
Write-Host "Total individual tests: $(($allAtomics | Measure-Object -Property TestCount -Sum).Sum)"

Step 3: Execute Atomic Tests with Logging

Run tests with pre/post logging for detection validation:

# Execute a single test by technique ID (runs all tests for that technique)
Invoke-AtomicTest T1059.001

# Execute a specific test by number
Invoke-AtomicTest T1059.001 -TestNumbers 1

# Execute by test name
Invoke-AtomicTest T1059.001 -TestNames "Mimikatz - Cradled Invoke Expression"

# Execute by GUID
Invoke-AtomicTest T1059.001 -TestGuids "2e803f96-4e33-4c2c-b0c8-1c10cbb3945f"

# Execute with prerequisite check and installation
Invoke-AtomicTest T1059.001 -TestNumbers 1 -CheckPrereqs
Invoke-AtomicTest T1059.001 -TestNumbers 1 -GetPrereqs
Invoke-AtomicTest T1059.001 -TestNumbers 1

# Execute with timeout (seconds)
Invoke-AtomicTest T1003.001 -TimeoutSeconds 120

# Cleanup after testing
Invoke-AtomicTest T1059.001 -TestNumbers 1 -Cleanup

# Execute with full logging wrapper
function Invoke-AtomicWithLogging {
    param(
        [string]$TechniqueId,
        [int[]]$TestNumbers,
        [string]$LogPath = "C:\AtomicRedTeam\logs"
    )

    $timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
    $logFile = Join-Path $LogPath "${TechniqueId}_${timestamp}.json"

    $result = @{
        technique_id  = $TechniqueId
        test_numbers  = $TestNumbers
        start_time    = (Get-Date).ToString("o")
        hostname      = $env:COMPUTERNAME
        username      = $env:USERNAME
        results       = @()
    }

    foreach ($testNum in $TestNumbers) {
        $testResult = @{
            test_number = $testNum
            status      = "unknown"
            start_time  = (Get-Date).ToString("o")
        }

        try {
            # Show what will execute
            $details = Invoke-AtomicTest $TechniqueId -TestNumbers $testNum -ShowDetails 2>&1
            $testResult["details"] = $details | Out-String

            # Execute the test
            Invoke-AtomicTest $TechniqueId -TestNumbers $testNum -Confirm:$false
            $testResult["status"] = "executed"
        } catch {
            $testResult["status"] = "failed"
            $testResult["error"] = $_.Exception.Message
        }

        $testResult["end_time"] = (Get-Date).ToString("o")
        $result.results += $testResult

        # Wait for SIEM ingestion
        Start-Sleep -Seconds 30
    }

    $result["end_time"] = (Get-Date).ToString("o")
    $result | ConvertTo-Json -Depth 10 | Set-Content $logFile
    Write-Host "Log written to: $logFile" -ForegroundColor Green
    return $result
}

# Usage
Invoke-AtomicWithLogging -TechniqueId "T1059.001" -TestNumbers @(1, 2, 3)

Step 4: Validate Detections in SIEM

Query your SIEM to confirm whether atomic tests generated alerts:

Splunk SPL Queries for Detection Validation:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

-- T1059.001: PowerShell Execution
index=windows sourcetype="WinEventLog:Microsoft-Windows-PowerShell/Operational"
  EventCode=4104
  | eval script_block=ScriptBlockText
  | where len(script_block) > 500
  | stats count by host, script_block
  | sort -count

-- T1003.001: LSASS Memory Credential Dumping
index=windows sourcetype="WinEventLog:Security" EventCode=4663
  ObjectName="*lsass*"
  | stats count by host, SubjectUserName, ProcessName
  | where count > 0

-- T1547.001: Registry Run Key Persistence
index=windows sourcetype="WinEventLog:Microsoft-Windows-Sysmon/Operational"
  EventCode=13
  TargetObject="*\\CurrentVersion\\Run*"
  | stats count by host, Image, TargetObject, Details

-- T1053.005: Scheduled Task Creation
index=windows sourcetype="WinEventLog:Security" EventCode=4698
  | stats count by host, SubjectUserName, TaskName, TaskContent
  | sort -count

-- Generic: Hunt for Atomic Red Team artifacts
index=windows (sourcetype="WinEventLog:Microsoft-Windows-Sysmon/Operational"
  OR sourcetype="WinEventLog:Security")
  | search "*AtomicRedTeam*" OR "*atomic*" OR "*Invoke-AtomicTest*"
  | stats count by sourcetype, EventCode, host

Elastic / KQL Queries:
━━━━━━━━━━━━━━━━━━━━━

-- PowerShell script block logging
event.code: "4104" and powershell.file.script_block_text: *

-- Sysmon process creation from AtomicRedTeam paths
event.code: "1" and process.executable: *AtomicRedTeam*

-- Registry modification (persistence)
event.code: "13" and registry.path: *CurrentVersion\\Run*

-- Credential access indicators
event.code: "10" and winlog.event_data.TargetImage: *lsass.exe*

Step 5: ATT&CK Coverage Gap Analysis

Generate a coverage matrix comparing tested vs. detected techniques:

#!/usr/bin/env python3
"""ATT&CK coverage gap analysis - compares atomic test results against SIEM detections."""

import json
import os
import yaml
from pathlib import Path
from datetime import datetime


def load_atomics_inventory(atomics_path):
    """Parse all atomic test YAML files to build technique inventory."""
    inventory = {}
    atomics_dir = Path(atomics_path)

    for yaml_file in atomics_dir.glob("T*/T*.yaml"):
        try:
            with open(yaml_file, "r", encoding="utf-8") as f:
                data = yaml.safe_load(f)

            tech_id = data.get("attack_technique", "")
            if not tech_id:
                continue

            tests = data.get("atomic_tests", [])
            inventory[tech_id] = {
                "name": data.get("display_name", "Unknown"),
                "test_count": len(tests),
                "platforms": list(set(
                    p for t in tests
                    for p in t.get("supported_platforms", [])
                )),
                "tests": [
                    {
                        "name": t.get(, ),
                        : t.get(, ),
                        : t.get(, []),
                        : t.get(, {}).get(, ),
                    }
                     t  tests
                ],
            }
         Exception  e:
            ()

     inventory


 ():
    
    executed = {}
    log_path = Path(log_dir)

      log_path.exists():
         executed

     log_file  log_path.glob():
        :
             (log_file, )  f:
                data = json.load(f)
            tech_id = data.get(, )
             tech_id:
                 tech_id   executed:
                    executed[tech_id] = {
                        : [],
                        : data.get(, ),
                    }
                executed[tech_id][].append({
                    : data.get(, ),
                    : data.get(, []),
                })
         Exception  e:
            ()

     executed


 ():
    
      os.path.exists(detection_file):
         {}

     (detection_file, )  f:
        data = json.load(f)

    detections = {}
     entry  data:
        tech_id = entry.get(, )
         tech_id:
            detections[tech_id] = {
                : entry.get(, ),
                : entry.get(, ),
                : entry.get(, ),
                : entry.get(, ),
                : entry.get(, []),
            }

     detections



TACTIC_ORDER = [
    , , ,
    , , ,
    , , ,
    , , ,
    , ,
]


TACTIC_TECHNIQUE_MAP = {
    : [
        , , , , ,
        , , , , ,
        , , , ,
    ],
    : [
        , , , ,
        , , , , ,
        , , , , ,
        , , ,
    ],
    : [
        , , , ,
        , , ,
        , , ,
        , , , ,
        , ,
    ],
    : [
        , , ,
        , , , ,
        , ,
        , , , ,
        , ,
    ],
    : [
        , , , , ,
        , , , , ,
        , , ,
    ],
    : [
        , , , ,
        , , ,
    ],
    : [
        , , ,
        , , , ,
        , ,
    ],
    : [
        , , , ,
    ],
    : [
        , , , , ,
    ],
}


 ():
    
    report = {
        : datetime.utcnow().isoformat() + ,
        : {},
        : {},
        : [],
        : [],
    }

    total_available = (atomics_inventory)
    total_executed = (execution_logs)
    total_detected = (  d  detection_results.values()  d.get())

    report[] = {
        : total_available,
        : total_executed,
        : total_detected,
        : (
            (total_executed / total_available * )  total_available  , 
        ),
        : (
            (total_detected / total_executed * )  total_executed  , 
        ),
    }

    
     tactic, technique_ids  TACTIC_TECHNIQUE_MAP.items():
        tactic_data = {
            : ,
            : ,
            : ,
            : [],
        }

         tech_id  technique_ids:
             tech_id  atomics_inventory:
                tactic_data[] += 

                executed = tech_id  execution_logs
                detected = detection_results.get(tech_id, {}).get(, )

                 executed:
                    tactic_data[] += 
                 detected:
                    tactic_data[] += 

                 executed   detected:
                    gap = {
                        : tech_id,
                        : atomics_inventory[tech_id][],
                        : tactic,
                        : ,
                        : ,
                    }
                    tactic_data[].append(gap)
                    report[].append(gap)
                  executed  tech_id  atomics_inventory:
                    gap = {
                        : tech_id,
                        : atomics_inventory[tech_id][],
                        : tactic,
                        : ,
                        : ,
                    }
                    tactic_data[].append(gap)

        avail = tactic_data[]
        tactic_data[] = (
            (tactic_data[] / avail * )  avail  , 
        )
        report[][tactic] = tactic_data

    
    blind_spots = [g  g  report[]  g[] == ]
     blind_spots:
        report[].append({
            : ,
            : ,
            : [g[]  g  blind_spots],
        })

    low_coverage_tactics = [
        t  t, d  report[].items()  d[] < 
    ]
     low_coverage_tactics:
        report[].append({
            : ,
            : ,
            : ,
        })

     report


 ():
    
    layer = {
        : layer_name,
        : {
            : ,
            : ,
            : ,
        },
        : ,
        : ,
        : {: [, , ]},
        : ,
        : {
            : ,
            : ,
            : ,
            : ,
        },
        : ,
        : [],
        : {
            : [, , ],
            : ,
            : ,
        },
        : [
            {: , : },
            {: , : },
            {: , : },
            {: , : },
        ],
        : [],
        : [],
        : ,
        : ,
        : ,
        : ,
    }

     tech_id, tech_data  atomics_inventory.items():
        executed = tech_id  execution_logs
        detection = detection_results.get(tech_id, {})
        detected = detection.get(, )
        confidence = detection.get(, )

         detected  confidence  (, ):
            score = 
            color =   
            comment = 
         detected:
            score = 
            color =   
            comment = 
         executed:
            score = 
            color =   
            comment = 
        :
            score = 
            color =   
            comment = 

        technique_entry = {
            : tech_id,
            : ,
            : color,
            : comment,
            : score,
            : ,
            : [
                {: , : (tech_data[])},
                {: , : (executed)},
                {: , : (detected)},
            ],
            : [],
            : ,
        }
        layer[].append(technique_entry)

     layer


 ():
    
    ( * )
    ()
    ( * )
    ()
    ()

    s = report[]
    ()
    ( * )
    ()
    ()
    ()
    ()
    ()
    ()

    ()
    ( * )
    ()
    ( * )
     tactic  TACTIC_ORDER:
         tactic  report[]:
            t = report[][tactic]
            bar =  * (t[] / ) +  * ( - (t[] / ))
            (
                
                
                
            )
    ()

    blind_spots = [g  g  report[]  g[] == ]
     blind_spots:
        ()
        ( * )
         gap  blind_spots:
            ()
            ()
        ()

     report[]:
        ()
        ( * )
         rec  report[]:
            ()
               rec:
                ()
               rec:
                ()
        ()


 __name__ == :
     argparse

    parser = argparse.ArgumentParser(description=)
    parser.add_argument(, default=,
                        =)
    parser.add_argument(, default=,
                        =)
    parser.add_argument(, default=,
                        =)
    parser.add_argument(, default=,
                        =)
    parser.add_argument(, default=,
                        =)
    args = parser.parse_args()

    ()
    inventory = load_atomics_inventory(args.atomics_path)
    ()

    ()
    exec_logs = load_execution_logs(args.log_dir)
    ()

    ()
    det_results = load_detection_results(args.detections_file)
    ()

    ()
    report = generate_coverage_report(inventory, exec_logs, det_results)
    print_coverage_report(report)

    
     (args.output_report, )  f:
        json.dump(report, f, indent=)
    ()

    
    ()
    layer = generate_navigator_layer(inventory, exec_logs, det_results)
     (args.output_layer, )  f:
        json.dump(layer, f, indent=)
    ()
    ()

Step 6: Run Continuous Atomic Testing Pipeline

Schedule recurring tests against priority techniques:

# Continuous Atomic Testing - scheduled execution with validation
# Run as a scheduled task or via CI/CD pipeline

$PriorityTechniques = @(
    # Top MITRE ATT&CK techniques by prevalence (Red Canary Threat Detection Report)
    @{ Id = "T1059.001"; Name = "PowerShell" },
    @{ Id = "T1059.003"; Name = "Windows Command Shell" },
    @{ Id = "T1547.001"; Name = "Registry Run Keys" },
    @{ Id = "T1053.005"; Name = "Scheduled Task" },
    @{ Id = "T1003.001"; Name = "LSASS Memory" },
    @{ Id = "T1003.003"; Name = "NTDS" },
    @{ Id = "T1070.004"; Name = "File Deletion" },
    @{ Id = "T1218.011"; Name = "Rundll32" },
    @{ Id = "T1082";     Name = "System Information Discovery" },
    @{ Id = "T1105";     Name = "Ingress Tool Transfer" }
)

$ResultsLog = @()
$RunTimestamp = Get-Date -Format "yyyyMMdd_HHmmss"

foreach ($technique in $PriorityTechniques) {
    Write-Host "`n[*] Testing $($technique.Id) - $($technique.Name)" -ForegroundColor Cyan

    # Check prerequisites
    try {
        $prereqs = Invoke-AtomicTest $technique.Id -TestNumbers 1 -CheckPrereqs 2>&1
        $prereqsMet = $prereqs -notmatch "not met"
    } catch {
        $prereqsMet = $false
    }

    if (-not $prereqsMet) {
        Write-Host "    [!] Prerequisites not met, attempting install..." -ForegroundColor Yellow
        try {
            Invoke-AtomicTest $technique.Id -TestNumbers 1 -GetPrereqs 2>&1 | Out-Null
        } catch {
            Write-Host "    [!] Prereq install failed, skipping" -ForegroundColor Red
            $ResultsLog += [PSCustomObject]@{
                TechniqueId = $technique.Id
                Name        = $technique.Name
                Status      = "PREREQS_FAILED"
                Timestamp   = (Get-Date).ToString("o")
            }
            continue
        }
    }

    # Execute the test
    try {
        $startTime = Get-Date
        Invoke-AtomicTest $technique.Id -TestNumbers 1 -Confirm:$false
        $endTime = Get-Date
        $duration = ($endTime - $startTime).TotalSeconds

        Write-Host "    [+] Executed successfully (${duration}s)" -ForegroundColor Green

        $ResultsLog += [PSCustomObject]@{
            TechniqueId = $technique.Id
            Name        = $technique.Name
            Status      = "EXECUTED"
            Duration    = $duration
            Timestamp   = $startTime.ToString("o")
        }
    } catch {
        Write-Host "    [-] Execution failed: $($_.Exception.Message)" -ForegroundColor Red
        $ResultsLog += [PSCustomObject]@{
            TechniqueId = $technique.Id
            Name        = $technique.Name
            Status      = "FAILED"
            Error       = $_.Exception.Message
            Timestamp   = (Get-Date).ToString("o")
        }
    }

    # Cleanup
    try {
        Invoke-AtomicTest $technique.Id -TestNumbers 1 -Cleanup 2>&1 | Out-Null
        Write-Host "    [+] Cleanup completed" -ForegroundColor DarkGray
    } catch {
        Write-Host "    [!] Cleanup failed" -ForegroundColor Yellow
    }

    # Brief pause between tests for log ingestion
    Start-Sleep -Seconds 10
}

# Export results
$ResultsLog | Export-Csv "C:\AtomicRedTeam\logs\continuous_test_$RunTimestamp.csv" -NoTypeInformation
$ResultsLog | Format-Table -AutoSize

# Summary
$executed = ($ResultsLog | Where-Object Status -eq "EXECUTED").Count
$failed = ($ResultsLog | Where-Object Status -ne "EXECUTED").Count
Write-Host "`n=== CONTINUOUS TEST SUMMARY ===" -ForegroundColor Cyan
Write-Host "  Executed: $executed / $($PriorityTechniques.Count)" -ForegroundColor Green
Write-Host "  Failed:   $failed / $($PriorityTechniques.Count)" -ForegroundColor Red

Step 7: Detection Validation Loop

Close the purple team loop by correlating tests with detections and iterating:

Detection Validation Loop Workflow:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ┌──────────────────┐
  │ 1. SELECT        │  Choose technique from threat intel or gap report
  │    TECHNIQUE     │  Map to Atomic Red Team test ID
  └───────┬──────────┘
          │
  ┌───────▼──────────┐
  │ 2. EXECUTE       │  Run Invoke-AtomicTest with logging
  │    ATOMIC TEST   │  Record timestamp, hostname, test details
  └───────┬──────────┘
          │
  ┌───────▼──────────┐
  │ 3. WAIT FOR      │  Allow 30-60 seconds for log ingestion
  │    INGESTION     │  Ensure Sysmon, WinEventLog, EDR agents forward data
  └───────┬──────────┘
          │
  ┌───────▼──────────┐
  │ 4. QUERY SIEM    │  Search for correlated alerts matching technique
  │    FOR ALERTS    │  Check: Did our detection rules fire?
  └───────┬──────────┘
          │
     ┌────┴────┐
     │DETECTED?│
     └────┬────┘
    YES   │   NO
  ┌───────▼──────────┐   ┌──────────────────┐
  │ 5a. MARK GREEN   │   │ 5b. WRITE NEW    │
  │  Update Navigator│   │  Sigma/SIEM Rule │
  │  layer, log pass │   │  for technique   │
  └───────┬──────────┘   └───────┬──────────┘
          │                       │
          │               ┌───────▼──────────┐
          │               │ 5c. DEPLOY RULE  │
          │               │  Push to SIEM    │
          │               └───────┬──────────┘
          │                       │
          │               ┌───────▼──────────┐
          │               │ 5d. RE-EXECUTE   │
          │               │  Re-run atomic   │
          │               │  test, validate  │
          │               └───────┬──────────┘
          │                       │
  ┌───────▼───────────────────────▼──┐
  │ 6. CLEANUP                       │
  │    Run Invoke-AtomicTest -Cleanup│
  │    Document results              │
  └───────┬──────────────────────────┘
          │
  ┌───────▼──────────┐
  │ 7. NEXT          │  Select next technique
  │    TECHNIQUE     │  Repeat from step 1
  └──────────────────┘

Key Concepts

Term	Definition
Atomic Red Team	Open-source library by Red Canary containing small, focused tests mapped to MITRE ATT&CK techniques for validating detection capabilities
Invoke-AtomicRedTeam	PowerShell execution framework for running atomic tests locally or remotely, with prereq checking and cleanup
ATT&CK Navigator	Web-based tool for annotating and visualizing MITRE ATT&CK matrices as layered heatmaps showing detection coverage
Navigator Layer	JSON file defining colors, scores, and comments for each ATT&CK technique; used to generate coverage heatmaps
Detection Validation Loop	Iterative purple team process: execute attack, check for detection, write/tune rule if missed, re-execute to confirm
Coverage Gap	ATT&CK technique where no detection rule exists or where the rule fails to fire when the technique is executed
Blind Spot	Technique that was tested via atomic execution but produced zero SIEM alerts, indicating a critical detection failure
Sigma Rule	Vendor-agnostic detection rule format that can be converted to Splunk SPL, Elastic KQL, Microsoft KQL, and other SIEM queries
Purple Team	Collaborative security exercise where red team executes known techniques and blue team validates and improves detections in real time
Continuous Atomic Testing	Scheduled, automated execution of atomic tests to validate that detection rules remain functional as environments change

Tools & Systems

Invoke-AtomicRedTeam: PowerShell module for executing Atomic Red Team tests with prereq management and cleanup
Atomic Red Team Atomics: Library of 700+ tests across 200+ MITRE ATT&CK techniques, organized by technique ID
ATT&CK Navigator: Web tool at mitre-attack.github.io/attack-navigator for creating technique coverage heatmaps
VECTR: Purple team reporting platform by SCYTHE for tracking test campaigns, results, and coverage over time
Sigma: Generic signature format for SIEM systems; convert with sigmac or pySigma to target SIEM platforms
Splunk / Elastic / Microsoft Sentinel: SIEM platforms for querying detection results after atomic test execution
Sysmon: Windows system monitoring driver providing detailed process, network, registry, and file telemetry
Caldera: MITRE-developed adversary emulation platform for automated, multi-step attack chains beyond single atomic tests

Common Scenarios

Scenario: Validating Credential Access Detections After EDR Deployment

Context: The organization deployed a new EDR agent and needs to verify it detects credential dumping techniques (LSASS access, NTDS extraction, SAM dump). The purple team must confirm detections are working before closing the deployment ticket.

Approach:

Install Invoke-AtomicRedTeam on a test endpoint enrolled in the new EDR
Execute credential access atomics: T1003.001 (LSASS Memory), T1003.002 (SAM), T1003.003 (NTDS)
Wait 60 seconds, then query EDR console and SIEM for alerts on the test hostname
For each technique: mark as DETECTED (green) or BLIND SPOT (red) in the Navigator layer
For blind spots, create Sigma rules targeting Sysmon EventCode 10 (ProcessAccess to lsass.exe) and EventCode 1 (known dumping tools)
Deploy rules, re-run atomics, confirm detection
Export Navigator layer and coverage report for the deployment ticket

Pitfalls:

Running credential dumping atomics without local admin privileges (tests will fail silently)
Forgetting to enable Sysmon ProcessAccess logging (EventCode 10) which is disabled by default
Not running cleanup, leaving test artifacts (created accounts, registry keys, scheduled tasks)
Testing only one sub-technique of T1003 and assuming all credential access is covered
Not accounting for EDR agent exclusions that may whitelist PowerShell or the AtomicRedTeam directory

Scenario: Building Monthly ATT&CK Coverage Reporting for Leadership

Context: The CISO requires monthly metrics on detection coverage mapped to MITRE ATT&CK. The security team needs to run recurring tests, track improvements, and produce a visual heatmap showing coverage growth over time.