Skip to content
Cette page est affichée en anglais.La traduction française est prévue mais pas encore rédigée. Rien ici n’est traduit automatiquement, car une affirmation de sécurité mal traduite est une affirmation fausse.Lire en anglais

GUARDTALKOS · VERIFICATION · ALPHA

Verify before you trust.

You hold the verified-boot key. Here is how to confirm a release is ours, that your device is running it, and that the .onion you reached is authentic.

What verification proves.

Three things, and only three. The file you hold is byte-for-byte the file we published. That publication was signed by the key whose fingerprint is published here. Your device is enforcing a boot key you generated yourself.

That is a narrow result, and the narrowness is the useful part. Verification does not prove the build is free of defects. It does not prove the binary matches the source — that is the reproducible-build target, and it is planned. It does not reach the bootloader, radio or baseband firmware that sit beneath the OS.

Those boundaries are set out in the threat model.

What you need first.

  • A Tor client. The images are reachable over Tor only, and that target is planned rather than shipped.
  • A signature-verification tool. The exact tool and command are published with the first release. // confirm §19.7verification tool and command
  • The signing-key fingerprint, read from at least two independent surfaces: this page, docs.guardtalk.io and guardtalk.io. A fingerprint that travels alongside the artefact attests to nothing.
  • A device whose bootloader you can unlock and lock again, if you intend to work step four.

The five steps.

Work them in order. Each one ends with the condition under which you stop. Stopping is the useful outcome of a verification that fails; carrying on because four of five checks passed is not.

  1. STEP 01planned// confirm §19.7 — releases onion address and fingerprint

    Confirm that the onion service you reached is authentic.

    An onion address is derived from the service's public key. A network attacker cannot impersonate a correct address, so the entire risk sits in how you came by the address in the first place.

    Read it here, then read it again on docs.guardtalk.io and on guardtalk.io. Compare all three character by character. Onion addresses are long and deliberately unmemorable, and a substituted one is designed to survive a glance.

    Never accept an address from a search result, a forum post, a message or a code someone scanned for you. Those are the delivery paths a substituted service needs, and they are cheaper to attack than the service itself.

    expected shape · the authentic onion address
    releases onion    <onion-address>.onion
    fingerprint       <fingerprint>
    
    published on      os.guardtalk.io/releases
    published on      docs.guardtalk.io
    published on      guardtalk.io
    
    all three copies identical, character for character
    
    // confirm §19.7 — the address and its fingerprint are not published yet

    If the three published copies of the address differ by a single character, stop and fetch nothing.

  2. STEP 02live

    Fetch SHA256SUMS and its signature, then check that signature.

    Fetch two small files from the releases onion before you fetch anything large: SHA256SUMS and the detached signature over it. Fetch both in the same session, over Tor.

    Verify the signature against the fingerprint you already held before you arrived. Compare the fingerprint, not the key file. A key delivered alongside the artefact it signs proves only that the same party produced both, which is exactly what an attacker can arrange.

    This is the step that makes the next one meaningful. Without it, SHA256SUMS is a text file, and whoever can replace an image can replace the hash list too.

    expected shape · the SHA256SUMS signature
    $ <verify-tool> --verify SHA256SUMS.sig SHA256SUMS
    good signature over SHA256SUMS
    signing key fingerprint: <fingerprint>
    
    <fingerprint> matches the fingerprint you already held
    
    // confirm §19.7 — signing-key fingerprint not published yet
    // confirm §19.7 — the tool and the exact command ship with the first release

    If the signature does not verify, or the fingerprint differs anywhere, stop. Do not fetch the images.

  3. STEP 03live

    Compare every image hash against the signed list.

    Compute the SHA-256 digest of every file you fetched, and compare each one to its line in the SHA256SUMS you verified in step two. The list is only worth comparing against because of that signature.

    Compare the whole digest. A matching first eight characters is not a match, and a difference of one character is a total difference. Tools that print an abbreviated hash are convenient and are not what this step is for.

    A file with no line in SHA256SUMS was not published by us. Do not flash it because the rest of the fetch looked correct. A mixed set is the shape a substitution takes when only one image was the target.

    expected shape · comparing image hashes
    $ sha256sum <image-file>
    <sha256>  <image-file>
    
    $ grep <image-file> SHA256SUMS
    <sha256>  <image-file>
    
    the two <sha256> values are identical over all 64 characters
    
    // confirm §19.6 — release file naming is not published yet

    If one digest differs, stop. Discard every file from that fetch and begin again at step one.

  4. STEP 04alpha// confirm §19.2 — the AVB key workflow

    Install your own verified-boot key and confirm its hash at boot.

    The trust anchor is avb_pkmd.bin: the public-key metadata for a key pair you generate and keep. You flash that blob into the bootloader's custom-key slot, flash the signed images, then lock the bootloader again.

    Once locked, the bootloader refuses to boot an image your key did not sign. At boot the device reports the hash of the key it is enforcing. That hash has to be the hash of your key. The check is the whole reason the slot exists, and skipping it leaves you trusting whoever handed you the device.

    This is the step whose workflow is not final. The state of the mechanism is alpha and the enforcement state per release has not been confirmed against the build tree.

    Custom verified-boot key, held by you

    alpha

    A custom AVB key (avb_pkmd.bin) makes the trust anchor one the user generates and holds, not one the vendor keeps.

    Limit · Verified boot attests the OS image, not the bootloader, radio or baseband firmware beneath it.

    The AVB key workflowWhere this ends// confirm §19.2 — enforcement state per release
    expected shape · the verified-boot key at boot
    $ <avb-tool> --print-key-digest avb_pkmd.bin
    <key-hash>
    
    boot screen, custom key installed:
    ID: <key-hash>
    
    the two <key-hash> values are identical
    
    // confirm §19.2 — command sequence, boot-screen wording per device,
    //                and the enforcement state per release

    If the hash on the boot screen is not the hash of your key, stop. Do not lock the bootloader and do not use the device.

  5. STEP 05planned// confirm §19.2 — reproducible-build target

    Rebuild from source and reach the same hashes.

    This step does not exist yet. It is listed because its absence is a limit, and a limit belongs on the page rather than in a roadmap nobody reads.

    When it exists, an independent builder takes the published source, builds it in the documented environment, and reaches images with the same digests. The source is taken at the release tag. That is what turns a hash from this is our artefact into this artefact is that source.

    Until then, steps two and three prove provenance and say nothing about content. See the reproducible-build target for what it will mean and how it will be checked.

    Reproducible builds

    planned

    A reproducible-build target so a third party can rebuild the image and reach the same hashes.

    Limit · Not shipped. Until it is, a hash proves the artefact matches ours — not that ours matches its source.

    expected shape · a reproducible rebuild
    target:  sha256(<your rebuild>) == sha256(<published image>)
    today:   not available — the reproducible-build target is planned
    
    // confirm §19.2 — no date, no environment spec, no rebuild procedure yet

    Until this step exists, do not read a matching hash as evidence that the source and the binary agree.

What a correct verification looks like.

  1. The releases .onion matched, character for character, on all three surfaces that publish it.
  2. SHA256SUMS carried a good signature from the key whose fingerprint you already held.
  3. Every image you fetched matched its line in SHA256SUMS over the full digest.
  4. The device booted reporting the hash of the AVB key you generated, and you locked the bootloader after that.
  5. Step five was unavailable, because reproducible builds are planned.

That is the whole result: four confirmations and one stated gap. A page that reported five would be describing something this project does not have.

What a correct verification still does not tell you.

  • Nothing about defects in the code you have just proved you hold. Provenance and quality are different questions.
  • Nothing about bootloader, radio or baseband firmware. They sit below the OS and below your key, and they remain out of scope.
  • Nothing about anonymity. Fetching over Tor narrows who can watch; it does not remove an observer who can correlate both ends of a circuit.
  • Nothing about the system. The OS's headline protections require the Gateway. Without it, GuardTalkOS is a stripped ROM with a Wi-Fi radio.

Each of those boundaries is written out in the threat model, which is the page to read next if this one went well.

If a step fails.

  • Stop at the step that failed. Do not fetch the next artefact and do not flash anything.
  • Keep the files and the exact output. A mismatch is evidence, and evidence about a substituted artefact is worth more than a clean retry.
  • Report it through the disclosure address at guardtalk.io/security.
  • Do not report the mismatch by replying to whatever handed you the artefact. If the delivery path is compromised, so is the reply.

Read where the protections stop.

Verification tells you the artefact is ours. The threat model tells you what that is worth, against which adversary, and where the Gateway takes over.