← ALL POSTS
Product notes·6 min read

A .tvak file is a ZIP, on purpose

Why a TVAK evidence package is an ordinary ZIP, how the format marker and the manifest version themselves, and how to inspect one with standard tools.

Researched and drafted with AI assistance · reviewed by Prince

If you rename a .tvak file to .zip, it opens. That is not an accident or a loophole. It is the design: a TVAK evidence package is a plain ZIP archive, and .tvak is only a file name that tells people what is inside. This post explains why we made that choice, what the package contains, and how you can inspect and check one without any TVAK software at all.

Why a ZIP

Evidence is meant to outlive the tools that collected it. A case can be reopened years later, handed to another team, or reviewed by someone who has never heard of the product that produced the files. A container that only one program can open ties that evidence to that program.

So we did not invent a container. A package is a ZIP file in the same way that a .docx, an .xlsx or a .jar is a ZIP file under a different extension. Any tool that reads ZIP by its content rather than by its file extension opens it the same way. Our documentation lists 7-Zip, WinRAR, Python’s zipfile, unzip on Linux and .NET’s System.IO.Compression.ZipFile as tools that work.

We do not claim that this makes the evidence tamper-proof, because it does not. It makes the evidence readable, which is the property we wanted.

.zip or .tvak

TVAK Collector can write either extension. They are the same bytes in the same container, and choosing one changes nothing about what is collected or how it is packaged. The default is .zip. To get the branded extension, choose it in the GUI selector or the wizard prompt, or pass a flag on the command line:

BAT
TvakCollector.exe --output C:\Evidence --extension tvak

By default the command-line collector names the package after the host, for example <hostname>.zip. Any value other than zip or tvak falls back to zip.

What is inside

TEXT
<name>.zip  (or .tvak)
├── tvak_format.json     format identity marker, written first
├── manifest.json        per-file SHA-256, collector run status, host and collector provenance
├── metadata.json        case-level context, empty by default
├── collection.log       full run log
└── artifacts/
    ├── System/
    ├── Processes/
    └── ...              one subfolder per module that produced output

Evidence lives under artifacts/, with one subfolder for every module that produced output. collection.log is the run log. metadata.json holds case-level context such as a case identifier, a case name, an investigator, a collection reason and tags. It is empty by default, and it is kept separate from the manifest on purpose, so that filling in a case name never touches the evidence-integrity data.

The marker comes first

The first entry in every package is tvak_format.json:

JSON
{ "Format": "TVAK-Evidence-Package", "FormatVersion": 1, "CreatedBy": "tvak Collector 0.1.0.0" }

It is written before any evidence content. That ordering is deliberate. A tool, or a person, can confirm what it is holding by reading one small file, without trusting the file extension and without parsing a manifest that may list thousands of files. The CreatedBy field records which collector build wrote the package.

The idea is the same one that lets .docx, .xlsx and .jar files identify themselves inside a plain ZIP container. Here the marker is a short, human-readable JSON file, so you can read it without a specification.

Two versions, independent on purpose

A TVAK package carries two version numbers, and they mean different things.

  • FormatVersion, in tvak_format.json, is the version of the container format: what a package is and how it identifies itself. Today it is 1.
  • ManifestVersion, in manifest.json, is the version of the manifest’s own schema: which fields the manifest has. Today it is "1.0".

They are kept apart because they change for different reasons. The manifest can gain a field without the container changing, and a change to the container is a much bigger decision. FormatVersion is meant to be a maintained contract: future versions of Collector are expected to keep reading FormatVersion: 1 packages, or to degrade gracefully with a clear message, rather than breaking silently. Changing it is a breaking-format decision and not a routine edit. Version 0.1.0 is a pre-release, and the project says so, so we will not promise more about the future than the documentation does. The marker is the part we intend to keep stable.

What the manifest records

manifest.json is the authoritative record of a collection. Its main sections are:

  • Collector: the collector name and version, and a BuildHash, which is the SHA-256 of the Collector executable itself, so you can confirm which build produced a package.
  • Host: the host name, operating system version and architecture, domain or workgroup, collection start and end in UTC, the account Collector ran as, whether it was elevated, and the raw Windows time zone registry values. The time zone is stored raw, deliberately not resolved to a display string, so that it stays meaningful on an analyst’s own machine in any locale.
  • Files[]: one entry per file in the package.
  • CollectorsRun[]: one entry per collector attempted, with its status, a human-readable reason, an artifact count and a duration.
  • Errors[]: a rollup of every collector that did not succeed.
  • RawArtifacts[] and Memory: records of how each raw artifact was obtained, and of any memory acquisition.

A trimmed, illustrative Files[] entry looks like this. The values are placeholders, not real output:

JSON
{
  "Path": "artifacts/Processes/processes.csv",
  "Sha256": "<64 hexadecimal characters>",
  "SizeBytes": 12345,
  "Compressed": false,
  "Provenance": "collector",
  "CollectedUtc": "<UTC timestamp>"
}

The SHA-256 is always computed over the file’s uncompressed bytes, which are the bytes you get by extracting it. That means the value is the same whether or not the Compress option was on when the package was written. Text artifacts can be deflate-compressed, while large binaries such as the $MFT, registry hives and memory dumps are always stored uncompressed. The manifest records which, in Compressed.

Inspecting a package with standard tools

Everything below uses tools that ship with Windows PowerShell, and none of it needs TVAK software. Replace C:\Evidence\HOST.tvak with your package.

First, list what is inside without extracting anything, and read the marker. .NET’s ZipFile reads by content, so it works on a .tvak file as it is:

POWERSHELL
Add-Type -AssemblyName System.IO.Compression.FileSystem
$pkg = 'C:\Evidence\HOST.tvak'
$zip = [System.IO.Compression.ZipFile]::OpenRead($pkg)
$zip.Entries | Select-Object FullName, Length      # the first entry should be tvak_format.json
$reader = [System.IO.StreamReader]::new($zip.GetEntry('tvak_format.json').Open())
$reader.ReadToEnd() | ConvertFrom-Json              # Format, FormatVersion, CreatedBy
$reader.Dispose(); $zip.Dispose()

Second, extract it. PowerShell’s own Expand-Archive cmdlet decides by file extension and refuses a .tvak file. On Windows PowerShell 5.1 we get this error:

TEXT
.tvak is not a supported archive file format. .zip is the only supported archive file format.

That is a limitation of the cmdlet, not corruption, and it is the same for any renamed ZIP format. Copy the file to a .zip name first, or use a ZIP tool such as 7-Zip:

POWERSHELL
Copy-Item C:\Evidence\HOST.tvak C:\Evidence\HOST-copy.zip
Expand-Archive C:\Evidence\HOST-copy.zip -DestinationPath C:\Evidence\HOST-extracted

Third, check every file against the manifest. Get-FileHash and the manifest both use SHA-256, and PowerShell’s -ne comparison is case-insensitive, which matters because Get-FileHash prints upper-case hexadecimal while the manifest uses lower-case:

POWERSHELL
$out = 'C:\Evidence\HOST-extracted'
$manifest = Get-Content (Join-Path $out 'manifest.json') -Raw | ConvertFrom-Json
foreach ($f in $manifest.Files) {
    $actual = (Get-FileHash (Join-Path $out $f.Path) -Algorithm SHA256).Hash
    if ($actual -ne $f.Sha256) { "MISMATCH  $($f.Path)" }
}

If that prints nothing, every file in the manifest matches. The paths in the manifest use forward slashes, which Windows accepts. For a single file, Get-FileHash on its own is enough: compare the output with that file’s Sha256 entry.

What the hashes do and do not tell you

It is worth being exact here. The manifest is inside the package. A check against it tells you that the files you extracted are the files the manifest describes. That is useful: it catches corruption in transit and files that were changed without the manifest being changed too.

It does not prove who made the package, and it cannot detect someone who edited both a file and the manifest. In version 0.1.0 the package is not encrypted, and the packaging code writes no signature. If you need to show that a package has not changed since you received it, record the hash of the whole package file at the time of hand-off, in a place you trust, and compare against that later. Encryption is planned. It is not implemented in 0.1.0, and the documentation describes the intended design: optional, off by default, layered on top of the integrity manifest and never replacing it, using a standard scheme that third-party tools can open.

Keep reading

Sources

  1. TVAK Collector file formats reference — TVAK Documentation · accessed
  2. TVAK Collector evidence handling — TVAK Documentation · accessed
  3. TVAK Collector releases — GitHub · accessed
  • format
  • interoperability
  • integrity

Keep reading

Product notes7 min read

Collector 0.1.0: the first public release

Product notes6 min read

What “AI-assisted, analyst-controlled” has to mean in practice

Advisories10 min read

FreeSWITCH CVE-2026-116779: one SIP message can run commands, and it is exploited