Your files never leave your device. All processing happens locally in your browser.
How do I inspect a file’s true type, entropy and hidden strings without uploading it?
Use the File Forensics Tool: drop any file and it is read into memory and analysed entirely in your browser. It reports the TRUE file type from the magic-number signature (with a red warning if that disagrees with the extension — e.g. a .jpg that is really an .exe), copyable MD5 / SHA-1 / SHA-256 hashes, the overall Shannon entropy (0–8 bits/byte) plus a per-block heatmap that spots packed or encrypted regions, a paged hex + ASCII dump with the signature highlighted, searchable printable ASCII / UTF-16LE strings that tag URLs, paths, IPs and emails, and image EXIF/GPS metadata with a privacy warning. Nothing is uploaded — it is safe for sensitive or suspicious samples. It is STATIC inspection, not antivirus, so it cannot tell you a file is safe.
True type from magic bytes (file-type, ~400 formats) + extension-mismatch warning
MD5 + SHA-1 (hash-wasm) and SHA-256 (Web Crypto), all copyable
Overall + per-block Shannon entropy to spot encrypted / packed data
Image EXIF / GPS with a location-privacy warning — 100% in your browser
What is
File forensics (static inspection)
Static file inspection is the practice of examining a file’s raw bytes — without executing it — to determine what it really is and how it is built. Core techniques include reading the magic-number signature (the first bytes that identify the format regardless of the file name), computing cryptographic hashes (MD5 / SHA-1 / SHA-256) to fingerprint or look it up, measuring Shannon entropy to detect compression or encryption, dumping the bytes as hex + ASCII, extracting printable strings, and parsing embedded metadata such as EXIF. It is the fast, safe first step of malware triage, upload validation and digital forensics, but because it never runs the file it cannot observe behaviour and cannot confirm a file is safe.
No. The file is read into memory and every step runs locally in your browser; nothing is uploaded, logged or stored on a server.
The File Forensics Tool is 100% client-side. Your file is read with the ArrayBuffer API and everything — magic-byte detection, MD5 / SHA-1 / SHA-256 hashing, Shannon entropy, the hex dump, string extraction and EXIF parsing — runs in JavaScript, WebAssembly (hash-wasm) and the browser’s native Web Crypto API. There is no upload, no server, no CDN and no telemetry in the path, and nothing is persisted, so closing the tab discards it and the tool works offline once cached. That makes it safe for sensitive or suspicious samples in a way an online analyser — which receives your file — never can be. The only optional network use anywhere on the site is consent-gated ads, which never see your file.
Entropy measures randomness from 0 to 8 bits per byte; near 8 suggests encryption or compression, around 4–5 looks like text, and a sudden spike can reveal a packed payload.
Shannon entropy scores how unpredictable a file’s bytes are. Plain text and source code sit around 4–5, dense binary and Base64 climb to 6–7, and compressed archives or encrypted data push past 7.5 toward the 8.0 maximum. The tool shows the overall value and a per-block heatmap: a flat near-8 band across the whole file suggests it is encrypted or compressed, while an isolated spike inside otherwise low-entropy data can expose an embedded packed or encrypted payload — a classic packer / malware indicator. Entropy is only a heuristic, though: compressed media looks identical to encrypted output, and single-byte XOR encoding does not raise entropy at all, so treat it as a clue rather than proof.
No. It is static inspection, not antivirus — it never runs the file and cannot confirm a file is safe or malicious.
This is a triage aid that reads bytes statically; it never executes the file, so it cannot observe what the file would do. Packed or encrypted malware deliberately hides from static analysis, a magic-byte signature can be forged, high entropy is not proof of anything, and a clean strings list means nothing. What the tool does well is answer “what is this file, really?” — catching a disguised extension, fingerprinting the file by hash so you can look it up, and flagging that it looks encrypted or packed. For an actual verdict, use up-to-date antivirus, a hash-reputation lookup, and dedicated malware-analysis tooling in an isolated sandbox — and never open or run a file you do not trust.
The extension is just part of the name and can be wrong or faked; the tool reads the magic bytes, which reflect the real format, and warns you when they disagree.
A file’s extension is a label anyone can change by renaming the file, but the first few bytes (the magic number) are written by the program that created it and identify the true format. The tool detects that signature with the file-type library (~400 formats) plus a curated table, then compares it to the filename extension. When they disagree — say a document named report.pdf whose bytes are actually a Windows executable — it raises a clear mismatch warning, because a disguised extension is a common trick for slipping executables past users and filters. Benign causes exist too (a .jpg that is really a .png, or a .docx which is technically a ZIP), which the tool treats as compatible aliases rather than a mismatch.
Detailed Explanation
📖How It Works
What the File Forensics Tool Does
The File Forensics Tool is a 100% client-side static file inspector. You drop or choose any file; it is read into memory with the ArrayBuffer API and every analysis runs locally in your browser. It reports the TRUE file type from the magic-number signature (independent of the file name), copyable MD5 / SHA-1 / SHA-256 hashes, the overall Shannon entropy plus a per-block entropy heatmap, a paged hex + ASCII dump with the detected signature highlighted, printable ASCII and UTF-16LE strings (each tagged when it looks like a URL, path, IP, email or domain), and image EXIF / GPS metadata. It is STATIC inspection — it never executes the file — so it is safe to point at suspicious samples, but for the same reason it cannot confirm a file is safe.
True type from magic bytes (file-type ~400 formats) + a curated signature table
MD5 + SHA-1 via hash-wasm; SHA-256 via the native Web Crypto API
100% client-side — the file is read locally and never uploaded
⚙️Methodology
How Entropy Detection Works
Shannon entropy is computed as H = −Σ p(x)·log₂ p(x) over the 256 possible byte values, giving a score from 0 (perfectly uniform) to 8 bits per byte (maximally random). The tool reports the overall value and also splits the file into up to 128 equal blocks and scores each one, drawn as a heatmap coloured teal (low) through gold (packed) to coral (near-random). The interpretation follows the standard forensic convention: roughly 0–4 is repetitive or structured binary, 4–5.5 looks like text or source, 6–7.5 is dense / Base64 / compressed or packed, and 7.5–8 strongly suggests encryption or good compression. A flat near-8 band across the whole file points to whole-file encryption or compression, whereas an isolated spike inside otherwise low-entropy data can reveal an embedded packed or encrypted payload — a classic packer indicator.
H = −Σ p(x)·log2 p(x) over byte values, 0–8 bits/byte
Up to 128 per-block scores rendered as a colour heatmap
Text ≈ 4–5, packed ≈ 6–7.5, encrypted/compressed ≥ 7.5
Flat near-8 = encrypted/compressed; a spike = embedded packed payload
A 7.5 guide line marks the high-entropy threshold on the chart
🔧Technical Details
Identity, Hashing, Hex and Strings
True-type detection reads only the header slice and matches it with the file-type library (~400 binary formats) plus an in-house signature/heuristic table that also locates the exact matched byte range so the hex viewer can highlight it; the detected type is then compared with the filename extension to flag a mismatch (a disguised .jpg that is really an executable). Hashing streams the bytes through hash-wasm for MD5 and SHA-1 and through crypto.subtle.digest for SHA-256, with each Uint8Array wrapped in a fresh ArrayBuffer-backed copy so it satisfies the Web Crypto BufferSource type. String extraction makes two passes over the bytes — printable ASCII runs and UTF-16LE runs (a printable byte followed by 0x00) — keeping runs at or above a chosen minimum length and classifying each by regex as a URL, path, IP, email or domain, all searchable. The hex + ASCII dump is paged 512 bytes at a time. A one-click plain-text forensic report bundles the identity, hashes, entropy summary and notable strings.
file-type + signature table locate and highlight the magic bytes
Extension-vs-content mismatch detection with benign-alias handling
MD5/SHA-1 via hash-wasm (WASM), SHA-256 via Web Crypto
ASCII + UTF-16LE string passes, classified and searchable
Paged hex/ASCII dump + a downloadable text report
📋Use Cases
When to Use It
Static file forensics is the fast, safe first step in several workflows. In malware triage it answers “what is this file, really?” — catching a renamed executable, fingerprinting the sample by hash so you can look it up on a reputation service, and flagging that it looks packed or encrypted. For upload validation it confirms that a file’s bytes match its claimed type, defeating simple extension spoofing. For privacy it surfaces EXIF/GPS location baked into a photo before you share it. And for reverse engineering, format research or CTF challenges, the hex view, entropy map and strings quickly reveal structure, embedded links and hidden text. Because everything runs locally, you can inspect confidential documents and untrusted samples alike without sending them to a third party.
Malware triage: identify, hash-fingerprint and spot packed/encrypted files
Upload validation: verify bytes match the claimed type
Privacy: reveal EXIF/GPS before sharing a photo
Reverse engineering / CTF: hex, entropy and strings at a glance
Safe for confidential or untrusted files — nothing leaves the browser
⚠️Limitations
Honest Limitations
This is STATIC inspection, NOT antivirus, sandboxing or malware detonation, and it cannot tell you a file is safe. It never executes the file, so it cannot observe behaviour: packed or encrypted malware hides from static analysis, a magic-byte signature can be forged or crafted, and a clean strings list proves nothing. Entropy is only a heuristic — compressed media is indistinguishable from encrypted output, and single-byte XOR encoding does not raise entropy at all. String extraction and the full read are capped for very large files (strings are scanned in the first several megabytes; files above roughly 150 MB are declined for an in-browser read), so results can be partial. Treat the tool as a fast triage aid: for a real verdict use up-to-date antivirus, a hash-reputation lookup, and dedicated malware-analysis tooling in an isolated sandbox, and never open or run a file you do not trust.
Not antivirus/sandbox — never runs the file, cannot confirm safety
Packing/encryption defeats static analysis; signatures can be spoofed
Entropy is a heuristic; single-byte XOR does not raise it
Strings/read capped on very large files — results may be partial
For a verdict: AV + hash reputation + a real sandbox
🔒Privacy & Security
Private by Design
Everything happens on your device. The file is read with the FileReader / ArrayBuffer API and every step — magic-byte detection, MD5 / SHA-1 / SHA-256 hashing, Shannon entropy, the hex dump, string extraction and EXIF parsing — runs in JavaScript, WebAssembly (hash-wasm) and the browser’s native Web Crypto API. There is no upload, no server, no CDN and no telemetry anywhere in the path, and nothing is persisted — closing the tab discards it, and the tool works offline once cached. Because a suspicious or confidential file never leaves your machine, this is safe in a way an online analyser — which would receive your file — can never be. The only optional network use anywhere on the site is consent-gated ads, which never see your file.
File read locally; no upload, server, CDN or telemetry
Hashing/entropy/hex/strings/EXIF all run in-browser
Nothing persisted — closing the tab erases it; works offline once cached
Safe for confidential or untrusted samples, unlike an online analyser
Only optional network use is consent-gated ads that never see your file
Ways to inspect an unknown file
Approach
What it shows
Trade-off
This tool
This tool (static, in-browser)
True type, hashes, entropy, hex, strings, EXIF
Static only — cannot confirm safety
Yes
Online file analyser / scanner
Type + sometimes a malware verdict
Uploads your file to a third party
No — never uploaded
Desktop CLI (file, sha256sum, strings, binwalk)
The same primitives, scriptable
Requires install + terminal skills
Same primitives, in a browser
Antivirus / sandbox
A behavioural safety verdict
Heavier; may upload; needed for a real verdict
Complements it
Static inspection identifies and fingerprints a file and flags that it looks packed/encrypted or disguised, but it is not a safety verdict. Everything here runs locally in the browser. As of July 2026.