Skip to content
Skillpedia
Analysis & spreadsheets35k · #5502

analyzing-windows-amcache-artifacts

Lets your agent analyze Windows registry files to find evidence of programs run and installed. It helps reconstruct what happened on the system.

What it does

This tool analyzes a special Windows file called Amcache.hve. It helps discover which programs were installed or run on a computer, even if they were deleted. It also checks the 'identification codes' (SHA-1 hashes) of these programs to see if they are known as malicious.

When to use it

  • ✓Investigating which programs were used on a computer after a security incident.
  • ✓Checking if an unknown or malicious program was present on the system.
  • ✓Reconstructing a timeline of when programs were installed or used.

Example of what to ask your AI

“What programs were installed or run on this computer, and is there any malicious software?”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/analyzing-windows-amcache-artifacts/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/analyzing-windows-amcache-artifacts/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The tool uses a program called AmcacheParser to read the Amcache.hve file. It extracts information like program names, dates, and identification codes (SHA-1 hashes). These codes can be compared against lists of known malicious programs.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill analyzing-windows-amcache-artifacts

Or download just the file:

curl -L https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/main/skills/analyzing-windows-amcache-artifacts/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Analyzing Windows Amcache Artifacts

When to Use

  • Determining which programs have existed or executed on a Windows system during incident response
  • Correlating SHA-1 hashes from Amcache against known malware databases (VirusTotal, CIRCL, MISP)
  • Building an application installation and execution timeline for forensic investigations
  • Identifying deleted executables that leave traces in Amcache even after file removal
  • Investigating insider threats by documenting which portable or unauthorized applications were present
  • Analyzing driver loading history to detect rootkits or malicious kernel modules

Do not use as sole proof of program execution. Amcache proves file existence and metadata registration, but ShimCache (AppCompatCache) and Prefetch provide stronger execution evidence. Use all three artifacts together for conclusive analysis.

Prerequisites

  • A forensic image or live triage copy of C:\Windows\appcompat\Programs\Amcache.hve (and associated .LOG1, .LOG2 transaction logs)
  • Eric Zimmerman's AmcacheParser (AmcacheParser.exe) downloaded from https://ericzimmerman.github.io/
  • Eric Zimmerman's Timeline Explorer for viewing parsed CSV output
  • Optionally: Registry Explorer for manual hive inspection
  • A SHA-1 whitelist of known-good executables (e.g., NSRL hashset) for filtering
  • .NET 6+ runtime installed (required by current EZ tools)
  • Write access to an output directory for CSV results

Workflow

Step 1: Acquire the Amcache.hve File

Extract the Amcache hive from a forensic image or live system:

# From a live system (requires elevated privileges and raw copy tool)
# Amcache.hve is locked by the system; use a raw disk copy tool
# Option A: FTK Imager - mount image and navigate to:
# C:\Windows\appcompat\Programs\Amcache.hve
# Also collect: Amcache.hve.LOG1, Amcache.hve.LOG2

# Option B: Using KAPE for automated triage collection
kape.exe --tsource C: --tdest D:\Evidence\%m --target Amcache

# Option C: From a mounted forensic image (E: = mounted image)
copy "E:\Windows\appcompat\Programs\Amcache.hve" D:\Evidence\
copy "E:\Windows\appcompat\Programs\Amcache.hve.LOG1" D:\Evidence\
copy "E:\Windows\appcompat\Programs\Amcache.hve.LOG2" D:\Evidence\

Always collect the transaction log files (.LOG1, .LOG2) alongside the hive. AmcacheParser replays uncommitted transactions from these logs to recover the most complete data.

Step 2: Parse Amcache with AmcacheParser

Run AmcacheParser against the acquired hive:

# Basic parsing with CSV output
AmcacheParser.exe -f "D:\Evidence\Amcache.hve" --csv "D:\Evidence\Output"

# Parse with a SHA-1 whitelist to exclude known-good entries (NSRL)
AmcacheParser.exe -f "D:\Evidence\Amcache.hve" -w "D:\Whitelists\nsrl_sha1.txt" --csv "D:\Evidence\Output"

# Parse with a SHA-1 inclusion list (only show matches against known-bad hashes)
AmcacheParser.exe -f "D:\Evidence\Amcache.hve" -b "D:\IOCs\malware_sha1.txt" --csv "D:\Evidence\Output"

# Include deleted entries with high-precision timestamps
AmcacheParser.exe -f "D:\Evidence\Amcache.hve" --csv "D:\Evidence\Output" -i --mp

AmcacheParser produces multiple CSV files in the output directory:

Output File Contents
Amcache_AssociatedFileEntries.csv File entries with SHA-1 hashes, paths, sizes, and timestamps
Amcache_UnassociatedFileEntries.csv Orphaned file entries from older Amcache format
Amcache_ProgramEntries.csv Installed program metadata (name, publisher, version, install date)
Amcache_DeviceContainers.csv USB and device connection history
Amcache_DevicePnps.csv Plug-and-Play device driver information
Amcache_DriverBinaries.csv Loaded driver binaries with paths and hashes

Step 3: Analyze File Entries for Suspicious Programs

Open the AssociatedFileEntries.csv in Timeline Explorer and examine key columns:

Key columns to review:
- ProgramId          : Links file to its parent program entry
- SHA1               : Hash for threat intel lookups
- FullPath           : Original file location on disk
- FileSize           : Size of the executable
- FileKeyLastWriteTimestamp : When the Amcache entry was last updated
- Name               : File name
- Publisher           : Code signing publisher (blank = unsigned)
- BinProductVersion  : Version string from the PE header
- LinkDate           : PE compilation timestamp (useful for detecting timestomping)

…

FAQ

What is the Amcache.hve file?

It's a Windows file that stores information about programs that have been run or installed. It helps the system know which applications are allowed to run.

Why use SHA-1 hashes?

A SHA-1 hash is like a unique fingerprint for a file. If a program's hash is found on lists of known malware, it's a strong indicator that it's dangerous.

Does this tool prove a program was executed?

It shows that the program existed and was registered in Amcache. To be absolutely sure it was executed, it's best to use other tools like ShimCache or Prefetch alongside this one.

Details

Original description by the author

Parses the Windows Amcache.hve registry hive with Eric Zimmerman''s AmcacheParser and Timeline Explorer to extract evidence of program execution, application installation, and driver loading, including SHA-1 hash correlation with threat intel and timeline reconstruction. Use for Amcache forensics, program execution evidence gathering, or application compatibility cache investigations in DFIR work.

repo: mukul975/Anthropic-Cybersecurity-Skills

Popularity

GitHub stars
35k
Ranking position
#5502
License
Apache-2.0
Updated
8/31/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills