Usama Arshad. Résumé

DFIR Long read 4 November 2026

Writing

The AI assistant kept a diary.

Local LLM tooling quietly created a new forensic artifact: a plaintext, timestamped, uncensored record of what somebody was trying to build, in their own words, usually including the passphrase. Where it lives, how to collect it, and why it cuts both ways.

DFIRLLM SecurityInsider RiskForensics·4 November 2026

01Forensics used to require inference

Digital forensics is the business of reconstructing intent from residue. Shell history tells you a command ran. Prefetch tells you a binary executed. A jump list tells you a file was opened. None of them tell you what somebody meant, and a good chunk of an examiner's job is arguing that inference convincingly.

Local LLM tooling broke that. When somebody designs a tool by talking to a model on their own machine, the conversation is the design document. It is written in plain language, it is timestamped, it states the objective explicitly, and in most default configurations nothing ever clears it.

The uncomfortable part

Shell history proves a command ran. A prompt history explains why it was written, who it was aimed at, what the author was worried about, and frequently includes the passphrase they chose, because they pasted it in to get help with the encryption call.

02What it looks like when it goes wrong

The cleanest illustration I have come across was a forensics challenge, Whisper, in the BlackHat MEA 2026 qualifiers. The scenario is mundane on purpose: a Linux workstation, an insider who used a local LLM to build an exfiltration tool. No memory corruption, no exotic cryptography. The entire thing is artifact retention.

Three failures compose, and all three are default behaviour rather than mistakes:

One: the prompt log is plaintext and permanent

~/.ollama/history is never cleared. It held a step-by-step statement of intent and the passphrase, typed directly into the chat because that is how you ask a model to help you write an encryption routine.

shell
$ grep -riE 'pass|secret|key|exfil|upload' ~/.ollama/history
...write a python script that zips /data/reports and encrypts it with
   the password Gr33nF0x42!D1amond using pyzipper, then uploads it to...

In an interview that line takes an hour to establish. On disk it took one grep.

Two: "delete after execution" meant "move to Trash"

The tool was supposed to remove itself. It was implemented as a move to the desktop Trash, which is not a delete. The script survived intact, next to a .trashinfo file recording the original path and the deletion timestamp:

shell
$ ls ~/.local/share/Trash/files/
cache_mgr.py

$ cat ~/.local/share/Trash/info/cache_mgr.py.trashinfo
[Trash Info]
Path=/home/dwright/.local/bin/cache_mgr.py
DeletionDate=2026-08-14T23:41:07

That file gave up the key-derivation function and the staging path. Note what the .trashinfo adds on its own: original location and a deletion time, which is a timeline entry you did not have to reconstruct.

Three: the staging directory was a cache nobody cleans

The archive was still sitting there. Cache directories are excluded from backup policies and from tidy-up habits alike, which makes them an excellent place to stage data and a terrible place to hide it.

THE INSIDER DELETED THE SCRIPT

passphrase: Gr33nF0x42!D1amond ~/.OLLAMA/HISTORY

THE MODEL KEPT THE CONVERSATION

The forensic path is almost comically short: grep the prompt history for intent, recover the script from Trash to learn the key derivation, find the archive where the script says it staged it, derive the password, open it. The technique is not the interesting part. The interesting part is that the most incriminating artifact on that disk was created by a productivity tool, silently, as a feature. The full writeup is here.

03Where these artifacts live

If you do incident response, these belong on your collection list. Exact paths move between versions, so treat this as where to start rather than as gospel:

Tool classWhat to collect
Ollama and similar local runtimes~/.ollama/: prompt history, model manifests, pulled-model inventory (which model, and when)
Editor AI assistantsWorkspace-scoped chat transcripts and index caches in the editor profile directory
Shell AI wrappersSuggested-command logs, usually beside normal shell history
Desktop LLM clientsLocal SQLite conversation stores plus attachment caches
Agent frameworksRun traces, tool-call logs, intermediate scratch files

A triage pass worth running early on a Linux host:

shell
# 1. local model tooling present at all?
ls -la ~/.ollama/ ~/.cache/lm-studio/ ~/.config/*copilot* 2>/dev/null
ls -la ~/.ollama/models/manifests/ 2>/dev/null   # which models, pulled when

# 2. the prompt history itself
grep -rilE 'password|passphrase|secret|api[_-]?key|token|exfil|upload' \
     ~/.ollama/ 2>/dev/null

# 3. SQLite conversation stores used by desktop clients
find ~ -maxdepth 6 -name '*.sqlite' -path '*hat*' 2>/dev/null
find ~ -maxdepth 6 -name '*.db' -newermt '-30 days' -path '*ai*' 2>/dev/null

# 4. the deletes that were not deletes
ls -la ~/.local/share/Trash/files/ ~/.local/share/Trash/info/ 2>/dev/null

# 5. staging directories nobody tidies
find ~/.cache -type f -size +1M -newermt '-14 days' 2>/dev/null | head -50

Two properties make this material unusually valuable. It is narrative, so it describes intent directly instead of requiring you to argue for it. And it is pre-redaction: people paste real credentials, real hostnames and real customer data into a model they believe is private because it is local.

04The same thing, from the other side

Flip it, because this cuts both ways and the second edge is sharper than people expect.

If you defend an environment

A local model is not a private one in any sense that matters forensically. It does not phone home, which is the fear everyone actually has, and it writes an unusually candid record to local disk, which is the risk nobody budgeted for. If your data-classification policy covers documents and chat messages but not prompt histories, it has a hole in it the size of your engineering team.

Concretely: prompt histories should be in scope for disk encryption, for endpoint backup exclusions, and for offboarding wipes. Most of the time they are in none of the three.

If you run an insider-risk programme

This is the highest-signal artifact you are currently not collecting. It is also exactly the kind of monitoring that needs written policy and legal review before you touch it, because the same file that proves exfiltration also contains somebody's half-finished questions about a medical diagnosis, a divorce, or a job application. Collect it deliberately, with notice and a retention limit, or do not collect it at all. There is no defensible middle.

If you just use these tools

Assume the transcript is permanent and discoverable. Do not paste production credentials into a local model to save thirty seconds; rotate anything you already have. If your workflow genuinely requires sensitive context, find out whether your tooling supports disabling history, and verify the setting rather than trusting it:

shell
# verify, do not assume
ls -la ~/.ollama/history 2>/dev/null && echo "history is being written"
stat -c '%y %n' ~/.ollama/history 2>/dev/null

Investigators spent two decades learning to reconstruct intent from fragments. The tooling now writes it down in full sentences. Whether that is a gift or a liability depends entirely on which side of the disk image you are standing on.