Listen to this Post
Introduction:
AI coding assistants like GitHub Copilot, Codeium, and Cursor have rapidly become integral to modern development workflows. While they boost productivity, they also silently generate a trail of forensic artifacts—prompt histories, cached responses, and extension logs—that can be critical in incident response. Understanding where these artifacts reside and how to extract them allows DFIR professionals to uncover evidence of malicious payload generation, insider threats, or unintentional data leaks, turning these AI tools into a potential investigative goldmine.
Learning Objectives:
- Identify and locate AI assistant artifacts generated within Visual Studio Code.
- Extract and analyze prompt history, cached responses, and session data using native OS commands and specialized tools.
- Leverage PromptTrace and Nova Framework to automate artifact collection and detect harmful prompts.
- Apply cross-platform forensic techniques for Windows, Linux, and macOS.
- Implement best practices to monitor and mitigate risks associated with AI coding assistants.
1. Understanding AI Assistant Artifacts in VS Code
AI coding assistants integrated into IDEs leave behind various traces that are often overlooked in traditional forensics. These artifacts include:
- Prompt History: The actual questions or commands sent to the AI, which may contain sensitive context or malicious intent.
- Cached AI Responses: Generated code snippets, explanations, or suggestions stored locally to reduce latency.
- Extension Logs: Debug logs from the AI extension that record interactions and errors.
- Session Data: Files like `emptyWindowChatSessions` inside VS Code’s local storage, which capture ongoing or past chat sessions.
From a DFIR perspective, these artifacts can reveal if an attacker used the assistant to generate obfuscated scripts, phishing templates, or exploit code. They also help reconstruct an insider’s actions before, during, or after an incident.
2. Key Storage Locations for AI Artifacts
VS Code stores user data and extension files in predictable paths. Below are the primary locations to examine:
Windows
– `%APPDATA%\Code\User\globalStorage\` – Contains workspace storage and extension-specific data (e.g., SQLite databases, JSON files).
– `%USERPROFILE%\.vscode\extensions\` – Houses installed extensions, including AI assistants, with their own logs and caches.
Linux / macOS
– `~/.config/Code/User/globalStorage/`
– `~/.vscode/extensions/`
Commands to explore:
Windows (PowerShell):
dir "$env:APPDATA\Code\User\globalStorage" dir "$env:USERPROFILE.vscode\extensions"
Linux/macOS (Bash):
ls -la ~/.config/Code/User/globalStorage/ ls -la ~/.vscode/extensions/
Look for recently modified files or directories named after AI extensions (e.g., github.copilot, codeium.codeium). Pay attention to SQLite databases like state.vscdb, which often store session data.
3. Deep Dive: Examining globalStorage for AI Sessions
Within globalStorage, each extension may create its own folder or use a shared database. For GitHub Copilot, the file `state.vscdb` (a SQLite database) frequently contains tables such as cursorHistory, prompts, or chatSessions.
Using SQLite to query artifacts:
Install `sqlite3` if not already present. Then:
sqlite3 ~/.config/Code/User/globalStorage/state.vscdb
Inside the SQLite prompt, list tables:
.tables
Look for tables related to AI interactions. For example, Copilot might have a table named `completions` or conversations. Query sample data:
SELECT FROM conversations LIMIT 5;
On Windows, use the same approach with the full path:
sqlite3 "$env:APPDATA\Code\User\globalStorage\state.vscdb" "SELECT FROM conversations;"
Artifacts like `emptyWindowChatSessions` may appear as JSON blobs within these tables. Extract and parse them with tools like `jq` or Python.
4. Using PromptTrace: Automated Artifact Extraction
Paritosh Bhatt developed PromptTrace, a DFIR tool specifically designed to extract AI interaction artifacts from VS Code storage. It automates the hunting process and outputs structured data.
Step-by-Step Guide:
1. Clone the repository:
git clone https://github.com/pbsecforge-lab/PromptTrace.git cd PromptTrace
2. Install dependencies (if any – check `requirements.txt`):
pip install -r requirements.txt
3. Run the script:
python prompttrace.py --path ~/.config/Code/User/globalStorage/
On Windows, adjust the path:
python prompttrace.py --path "$env:APPDATA\Code\User\globalStorage"
- Analyze output: PromptTrace will scan for known artifact patterns and output a report listing prompts, timestamps, and associated extensions. This saves hours of manual digging.
Example output snippet:
[+] Found Copilot conversation: 2025-03-15 10:23:45 "Generate a PowerShell reverse shell" Response: (base64 encoded payload...) [+] Codeium cache entry: 2025-03-15 10:25:12 "Write a macro for phishing doc"
- Correlating with Nova Framework for Malicious Prompt Detection
The Nova Framework (by Thomas Roccia) provides YARA-like rules to identify harmful prompts and AI-generated content. Integrating Nova with extracted artifacts enables automated threat detection.
Setup and Usage:
1. Clone Nova:
git clone https://github.com/Nova-Hunting/nova-framework.git cd nova-framework
- Prepare your artifact data: Export PromptTrace output to a text file (e.g.,
prompts.txt).
3. Run Nova rules against the prompts:
python nova.py -f prompts.txt -r rules/
Nova will flag prompts matching malicious patterns (e.g., requests for exploits, phishing, obfuscation).
- Customize rules: You can write your own Nova rules to catch specific IOCs or TTPs relevant to your investigation.
Example rule snippet (YAML):
rule: ReverseShellPrompt description: Detects prompts asking for reverse shell code strings: - $rev = "reverse shell" - $payload = "PowerShell" condition: any of them
6. Cross-Platform Forensic Analysis: Linux and macOS Considerations
While the core locations are similar, file paths and tool availability differ slightly. Ensure your forensic workstation has the necessary utilities.
Linux Example:
Check extension folders for recent activity
find ~/.vscode/extensions -type f -mtime -7 -name ".log" -exec ls -lh {} \;
Extract from SQLite directly
sqlite3 ~/.config/Code/User/globalStorage/state.vscdb "SELECT datetime(timestamp,'unixepoch'), prompt FROM prompts;" > linux_artifacts.txt
macOS Example:
globalStorage path same as Linux ls -la ~/Library/Application\ Support/Code/User/globalStorage/ Note: macOS may use `~/Library/Application Support` for some apps, but VS Code follows Linux convention.
Use `file` command to identify unknown files, and `strings` to extract readable text from binary caches.
7. Mitigation and Best Practices for Organizations
Given the forensic value and potential risk, organizations should implement controls:
- Enable Logging: Configure AI extensions to retain verbose logs (if supported). Document retention policies.
- Monitor Storage: Use EDR to watch for unusual access to `globalStorage` or extension directories.
- DLP Integration: Scan extracted artifacts for sensitive data or malicious content using Nova-like rules.
- User Training: Educate developers on the permanence of AI prompts and the importance of not sharing sensitive information.
- Incident Response Playbooks: Update playbooks to include AI artifact collection and analysis steps.
What Undercode Say
- Key Takeaway 1: AI coding assistants introduce a previously overlooked forensic artifact set—prompt histories, caches, and session data—that can reveal attacker or insider actions during an incident. These artifacts are stored locally and persist even after browser-based AI sessions are cleared.
-
Key Takeaway 2: Dedicated tools like PromptTrace and Nova Framework transform manual artifact hunting into automated, scalable analysis. They enable investigators to quickly extract prompts and detect malicious intent, reducing mean time to response.
-
Analysis: The rise of IDE-integrated AI shifts the forensic landscape: investigators must now treat development environments as rich sources of evidence. However, the lack of standardized logging across AI extensions means that proactive collection and correlation are essential. As adversaries adopt AI to generate attack code, defenders must equally leverage these artifacts to track and block threats. The combination of open-source tools and forensic know-how will be crucial in staying ahead. Organizations that ignore this new data source risk missing critical evidence in future breaches.
Prediction
Within the next two years, AI coding assistant artifacts will become a standard component of digital forensic investigations. As more attackers leverage AI to generate polymorphic malware and social engineering lures, the prompts and cached responses left behind will be pivotal in attribution and threat intelligence. We will likely see the emergence of enterprise-grade monitoring solutions that specifically capture and analyze AI interactions within IDEs, possibly integrated into SIEM platforms. Furthermore, legal and compliance frameworks may begin to mandate retention of AI-generated code trails, especially in regulated industries. The cat-and-mouse game between AI-assisted offense and AI-aware defense has only just begun.
▶️ Related Video (72% Match):
🎯Let’s Practice For Free:
IT/Security Reporter URL:
Reported By: Paritosh Bhatt – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
