Turn Windows' certificate cache into leads for an investigation.
Recover cached certificate-validation URLs and candidate hostnames to help triage malware callbacks and investigate past activity. One standalone Rust executable: no Python, no installation, read-only, offline by default.
Read the forensic field guide
for the artefact, cache format, WinINet/WinHTTP behavior, and interpretation limits.
The static site lives in docs/; publish it with GitHub Pages from main → /docs
(no build step required).
Read the current user's cache and look up certificate names:
.\cryptnet-dump.exe --resolveHere, a cached check against ocsp.sectigo.com resolves to certificate names
*.github.com and github.com: a useful lead suggesting GitHub was accessed,
even without browser history. This is the value of resolving certificate serials:
an otherwise opaque revocation endpoint becomes a recognizable investigation pivot.
Confirm access with other evidence: these are serial-only, unverified candidates,
not proof of a GitHub visit, and the timestamp records cache activity, not a visit time.
Long values are shortened with …; up to two names are shown, with a count of
additional names. --json keeps all fields and full values as JSON Lines,
including source paths, issuer hashes, content sizes, ETags, and warnings.
Use these leads to pivot on certificates and domains;
they are not proof of a connection to every listed name or attribution to a process.
# Dump the current user's cache without any network requests
.\cryptnet-dump.exe
# Save full evidence for scripts and further analysis
.\cryptnet-dump.exe --ocsp-only --resolve --json --output leads.jsonl
# Include other user and service profiles (run elevated for protected caches)
.\cryptnet-dump.exe --all-users --ocsp-only --resolve
# Examine a collected cache instead of the live machine
.\cryptnet-dump.exe --path D:\Evidence\CryptnetUrlCache --json --output evidence.jsonl- Table rows and JSON records stream immediately, not after all lookups finish.
--outputsaves the selected format and never overwrites an existing file. Colors are disabled in files/pipes; setNO_COLOR=1for a plain terminal table. - Resolution while scanning cache directories shows an animated progress bar on
stderr. Use
--no-progressto hide it; redirecting stderr hides it automatically. --resolvesends serials to ctlogs.dev first, with crt.sh as fallback. For faster resolution on larger collections, setCTLOG_API_KEYin the resolver machine's environment (see below). No key is required for anonymous use.- Run
--helpfor all options. Records that succeed are kept if another fails; check stderr and the exit code for incomplete collection.
On the target Windows machine, collect full JSON Lines without network lookups:
.\cryptnet-dump.exe --json --output evidence.jsonlAdd --all-users from an elevated shell to include other user/service profiles.
Transfer evidence.jsonl to your forensic machine; the original cache directories
do not need to be present there. Preserve the original evidence file unchanged.
On the forensic machine, feed that JSON back in for resolution:
.\cryptnet-dump.exe --input evidence.jsonl --resolve
# Save full enriched evidence instead of the table
.\cryptnet-dump.exe --input evidence.jsonl --resolve --json --output resolved.jsonl--input reads JSON Lines produced by --json, never opens the recorded source
paths, and cannot be combined with --path or --all-users. Without --resolve,
it can also display previously enriched JSON offline. Resolution replaces existing
candidate names with cached or newly queried results and retains original collection warnings.
Obtain a key from ctlogs.dev and make it available
as the CTLOG_API_KEY environment variable before running --resolve.
A key avoids the anonymous shared-capacity pool and can improve throughput; limits depend on the plan, so it does not guarantee faster responses. Anonymous use allows 100 requests/hour; a free key also has a 100 requests/hour limit plus a monthly allowance. Each search page and certificate-detail fetch is a request. The resolver caps each serial search at ten pages, even with a key, and falls back to crt.sh on errors or no names.
--resolve reuses previously resolved serials across runs, without expiry.
Only non-empty name matches are saved; empty results are kept in memory for the
current run, and errors are never cached. Certificate expiry does not remove
historical matches. Names remain unverified serial-only candidates.
The default cache directory is printed on stderr:
- Windows:
%LOCALAPPDATA%\ocspcryptneturlcache\resolver.cache(falls back to%USERPROFILE%\AppData\LocalifLOCALAPPDATAis unset). - Linux/other non-Windows builds:
$XDG_CACHE_HOME/ocspcryptneturlcache/resolver.cacheor~/.cache/ocspcryptneturlcache/resolver.cachewhen unset.
This is a directory, with an atomically written JSON file per normalized serial, so concurrent runs do not overwrite unrelated cached serials. It contains serials and candidate names, not API keys or source cache files; treat it as sensitive investigation data. Original Windows cache/evidence files stay unchanged.
Use --resolver-cache D:\Analysis\resolver.cache with --resolve to choose a
different directory, or --no-resolver-cache to bypass disk reads and writes and
query CT again. To refresh a stored match, delete its cache file (or the cache
directory) before resolving again. Cache read/write problems produce warnings
but do not discard successful online results. Without --resolve, no resolver
cache is read or created. Save resolved.jsonl and reopen it with
--input resolved.jsonl without --resolve to review saved enrichment offline.
Available as a Rust crate on crates.io as well as prebuilt release archives.
With stable Rust and a native build toolchain installed, run:
cargo install cryptnet-dump --locked
cryptnet-dump --helpThis installs the cryptnet-dump command into Cargo's binary directory
(~/.cargo/bin, or %USERPROFILE%\.cargo\bin on Windows); ensure it is on
your PATH. This is a CLI crate, not a Rust library dependency.
Windows builds require the MSVC toolchain and Visual Studio C++ Build Tools;
Linux builds require a native C compiler/linker. Use a prebuilt archive below
if you do not want to install Rust or build tools.
Windows target: 64-bit Windows 10/11 and Server 2016+; live-tested on Windows 11 x64. No Python, OpenSSL DLLs, or VC++ runtime installation is needed on the target.
Download the latest release
and extract the Windows ZIP for x64 (most PCs) or ARM64 (Windows on ARM),
or the Linux x86_64 archive cryptnet-dump-x86_64-unknown-linux-gnu.tar.gz.
Each archive includes the executable, documentation, and SHA256SUMS;
the release also includes adjacent .sha256 checksums for the archives themselves.
Linux assets are published starting with the next release after v1.0.0;
the existing v1.0.0 release is Windows-only.
Linux requires glibc 2.35+ and libgcc_s.so.1 (Ubuntu 22.04 or compatible).
It is a dynamically linked GNU build, not a static/musl binary for Alpine.
No Python or OpenSSL installation is needed. Use Linux for collected caches or
exported JSON Lines; live Windows profile discovery and --all-users require Windows.
# Run in the directory containing the downloaded archive and its .sha256 file
sha256sum --check cryptnet-dump-x86_64-unknown-linux-gnu.tar.gz.sha256
mkdir cryptnet-dump-linux
tar -xzf cryptnet-dump-x86_64-unknown-linux-gnu.tar.gz -C cryptnet-dump-linux
cd cryptnet-dump-linux
sha256sum --check SHA256SUMS
./cryptnet-dump --path /evidence/CryptnetUrlCache --json
./cryptnet-dump --input /evidence/evidence.jsonl --resolveBuild with stable Rust (MSVC) and Visual Studio C++ Build Tools:
cargo build --release --lockedCopy target\release\cryptnet-dump.exe to the machine being examined. The
release workflow
cross-compiles x64 and ARM64 on Linux, validates them on native Windows runners,
and builds Linux x86_64 natively on Ubuntu 22.04. It publishes Windows ZIPs and
the Linux tar.gz on v* tags only after all three targets pass validation;
ARM64 execution remains untested locally.
See Linux build instructions
to produce the same executables without Visual Studio.
Windows caches certificate-revocation checks in CryptnetUrlCache. The tool reads
that cache directly, extracts certificate serials and issuer hashes from OCSP
URLs and response bodies, and optionally searches Certificate Transparency data
for certificate names. Cache timestamps describe validation activity, not
connection times; lookup names are candidates, not issuer-verified matches.
Read how it works for the technical details, limitations,
and investigation workflow. For cache lifetime specifically, see the
rendered reverse-engineering analysis,
its Markdown source, and the
interactive retention scenarios.
The original Python proof of concept is archived in
old/.

